From 99ab866e9fa6d18c9804b3c90e7546f6f6aebc08 Mon Sep 17 00:00:00 2001
From: Bingjie Wang <bwang.jhu@gmail.com>
Date: Tue, 6 Jun 2023 16:53:26 -0400
Subject: [PATCH 001/132] p-beta updates: add DymSFHfixZred and PhiSFHfixZred
 prior classes; fix small numerical errors in the CDFs; update doc

---
 doc/prospector-beta_priors.rst |  16 +-
 prospect/models/priors_beta.py | 504 +++++++++++++++++++++++++++++----
 2 files changed, 455 insertions(+), 65 deletions(-)

diff --git a/doc/prospector-beta_priors.rst b/doc/prospector-beta_priors.rst
index 3bb041d2..df411b4b 100644
--- a/doc/prospector-beta_priors.rst
+++ b/doc/prospector-beta_priors.rst
@@ -5,16 +5,20 @@ Prospector-beta Priors
 This model is intended for fitting galaxy photometry where the redshift is unknown.
 The priors encode empirical constraints of redshifts, masses, and star formation histories in the galaxy population.
 
+N.B.: Please make sure to update to the Prospector-beta version post commit `09a83f2 <https://github.com/bd-j/prospector/commit/09a83f28cae3bcc0f0397b3a0b8d85aa4f96bf12>`_, merged on May 19, 2023. This is a major update to the SFH(M, z) prior, ensuring the expectation values of SFRs are well-behaved over the full prior space.
+
 A set of prospector parameters implementing the full set of priors is available as the ``"beta"`` entry
 of :py:class:`prospect.models.templates.TemplateLibrary`.
 
 Additionally we provide different combinations of the priors for flexibility, which includes the following:
 
-* ``PhiMet``      : mass funtion + mass-met
-* ``ZredMassMet`` : number density + mass funtion + mass-met
-* ``DymSFH``      : mass-met + SFH(M, z)
-* ``PhiSFH``      : mass funtion + mass-met + SFH(M, z)
-* ``NzSFH``       : number density + mass funtion + mass-met + SFH(M, z); this is the full set of Prospector-beta priors.
+* ``PhiMet``         : mass function + mass-met
+* ``ZredMassMet``    : number density + mass function + mass-met
+* ``DymSFH``         : mass-met + SFH(M, z)
+* ``DymSFHfixZred``  : same as above, but keeping zred fixed to a user-specified value, 'zred', during fitting
+* ``PhiSFH``         : mass function + mass-met + SFH(M, z)
+* ``PhiSFHfixZred``  : same as above, but keeping zred fixed to a user-specified value, 'zred', during fitting
+* ``NzSFH``          : number density + mass function + mass-met + SFH(M, z); this is the full set of Prospector-beta priors.
 
 We describe each of the priors briefly below. Please cite `wang23 <https://ui.adsabs.harvard.edu/abs/2023ApJ...944L..58W/abstract>`_ and the relevant papers if any of the priors are used.
 
@@ -47,7 +51,7 @@ Dynamic Star-formation History
 
 The SFH is described non-parametrically as in Prospector-alpha; the number of age bins is set by ``"nbins_sfh"``.
 
-In contast to the null expectation assumed in Prospector-alpha, the expectation value in each age bin is matched to the cosmic star formation rate densities in `behroozi19 <https://ui.adsabs.harvard.edu/abs/2019MNRAS.488.3143B/abstract>`_, while the distribution about the mean remains to be the Student’s-t distribution. The sigma of the Student’s-t distribution is set by ``"logsfr_ratio_tscale"``, and the range is clipped to be within ``"logsfr_ratio_mini"`` and ``"logsfr_ratio_maxi"``.
+In contrast to the null expectation assumed in Prospector-alpha, the expectation value in each age bin is matched to the cosmic star formation rate densities in `behroozi19 <https://ui.adsabs.harvard.edu/abs/2019MNRAS.488.3143B/abstract>`_, while the distribution about the mean remains to be the Student’s-t distribution. The sigma of the Student’s-t distribution is set by ``"logsfr_ratio_tscale"``, and the range is clipped to be within ``"logsfr_ratio_mini"`` and ``"logsfr_ratio_maxi"``.
 
 A simple mass dependence on SFH is further introduced by shifting the start of the age bins as a function of mass. This SFH prior effectively encodes an expectation that high-mass galaxies form earlier, and low-mass galaxies form later, than naive expectations from the cosmic SFRD.
 
diff --git a/prospect/models/priors_beta.py b/prospect/models/priors_beta.py
index 4b1325ea..6b256b6d 100644
--- a/prospect/models/priors_beta.py
+++ b/prospect/models/priors_beta.py
@@ -5,13 +5,15 @@
 Ref: Wang, Leja, et al., 2023, ApJL.
 
 Specifically, this module includes the following priors --
-1. PhiMet      : p(logM|z)p(Z*|logM), i.e., mass funtion + mass-met
-2. ZredMassMet : p(z)p(logM|z)p(Z*|logM), i.e., number density + mass funtion + mass-met
-3. DymSFH      : p(Z*|logM) & SFH(M, z), i.e., mass-met + SFH
-4. PhiSFH      : p(logM|z)p(Z*|logM) & SFH(M, z), i.e., mass funtion + mass-met + SFH
-5. NzSFH       : p(z)p(logM|z)p(Z*|logM) & SFH(M, z),
-                 i.e., number density + mass funtion + mass-met + SFH;
-                 this is the full set of prospector-beta priors.
+1. PhiMet         : p(logM|z)p(Z*|logM), i.e., mass function + mass-met
+2. ZredMassMet    : p(z)p(logM|z)p(Z*|logM), i.e., number density + mass function + mass-met
+3. DymSFH         : p(Z*|logM) & SFH(M, z), i.e., mass-met + SFH
+4. DymSFHfixZred  : same as above, but keeping zred fixed to a user-specified value, 'zred', during fitting
+5. PhiSFH         : p(logM|z)p(Z*|logM) & SFH(M, z), i.e., mass function + mass-met + SFH
+6. PhiSFHfixZred  : same as above, but keeping zred fixed to a user-specified value, 'zred', during fitting
+7. NzSFH          : p(z)p(logM|z)p(Z*|logM) & SFH(M, z),
+                    i.e., number density + mass function + mass-met + SFH;
+                    this is the full set of prospector-beta priors.
 
 When called these return the ln-prior-probability, and they can also be used to
 construct prior transforms (for nested sampling) and can be sampled from.
@@ -24,7 +26,7 @@
 from scipy.stats import t
 from . import priors
 
-__all__ = ["PhiMet", "ZredMassMet", "DymSFH", "PhiSFH", "NzSFH"]
+__all__ = ["PhiMet", "ZredMassMet", "DymSFH", "DymSFHfixZred", "PhiSFH", "PhiSFHfixZred", "NzSFH"]
 
 prior_data_dir = os.path.join(os.path.dirname(__file__), 'prior_data')
 massmet = np.loadtxt( os.path.join(prior_data_dir, 'gallazzi_05_massmet.txt'))
@@ -45,7 +47,7 @@ class PhiMet(priors.Prior):
     prior_params = ['zred_mini', 'zred_maxi', 'mass_mini', 'mass_maxi', 'z_mini', 'z_maxi', 'const_phi'] # mass is in log10
 
     def __init__(self, parnames=[], name='', **kwargs):
-        """Overwrites __init__ in the base code Prior
+        """Overwrites __init__ in the base code priors.Prior
 
         Parameters
         ----------
@@ -64,7 +66,6 @@ def __init__(self, parnames=[], name='', **kwargs):
         self.update(**kwargs)
 
         self.zred_dist = priors.FastUniform(a=self.params['zred_mini'], b=self.params['zred_maxi'])
-
         self.mgrid = np.linspace(self.params['mass_mini'], self.params['mass_maxi'], 101)
 
     def __len__(self):
@@ -105,7 +106,7 @@ def __call__(self, x, **kwargs):
             # doing mcmc; x is [zred, logmass, logzsol]
             p = np.zeros_like(x)
             # p(m)
-            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'])
+            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
             # p(zsol)
             met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
                                                   mu=loc_massmet(x[1]), sig=scale_massmet(x[1]))
@@ -115,7 +116,7 @@ def __call__(self, x, **kwargs):
 
             # p(z)
             lnp[0] = self.zred_dist(x[0])
-            lnp[2] = met_dist(x[2]) # FastTruncatedNormal returns ln(p)
+            lnp[2] = met_dist(x[2]) # priors.FastTruncatedNormal returns ln(p)
             return lnp
 
         else:
@@ -129,7 +130,7 @@ def __call__(self, x, **kwargs):
             for i in range(len(_zreds)):
                 new_x = x[i]
                 p = np.zeros_like(new_x)
-                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'])
+                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
                 all_p.append(p)
 
             all_p = np.array(all_p)
@@ -157,7 +158,7 @@ def sample(self, nsample=None, **kwargs):
         zred = self.zred_dist.sample()
 
         # draw from the mass function at the above zred
-        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'])
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
         mass = draw_sample(xs=self.mgrid, cdf=cdf_mass)
 
         # given mass from above, draw logzsol
@@ -185,7 +186,7 @@ def unit_transform(self, x, **kwargs):
 
         zred = self.zred_dist.unit_transform(x[0])
 
-        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'])
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
         mass = ppf(x[1], self.mgrid, cdf=cdf_mass)
 
         met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
@@ -203,7 +204,7 @@ class ZredMassMet(priors.Prior):
     prior_params = ['zred_mini', 'zred_maxi', 'mass_mini', 'mass_maxi', 'z_mini', 'z_maxi', 'const_phi'] # mass is in log10
 
     def __init__(self, parnames=[], name='', **kwargs):
-        """Overwrites __init__ in the base code Prior
+        """Overwrites __init__ in the base code priors.Prior
 
         Parameters
         ----------
@@ -222,12 +223,11 @@ def __init__(self, parnames=[], name='', **kwargs):
         self.update(**kwargs)
 
         if self.params['const_phi']:
-            zreds, pdf_zred = np.loadtxt( file_pdf_of_z_l20, unpack=True)
+            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z_l20.txt'), unpack=True)
         else:
-            zreds, pdf_zred = np.loadtxt( file_pdf_of_z_l20t18, unpack=True)
+            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z.txt'), unpack=True)
 
         self.finterp_z_pdf, self.finterp_cdf_z = norm_pz(self.params['zred_mini'], self.params['zred_maxi'], zreds, pdf_zred)
-
         self.mgrid = np.linspace(self.params['mass_mini'], self.params['mass_maxi'], 101)
 
     def __len__(self):
@@ -270,7 +270,7 @@ def __call__(self, x, **kwargs):
             # p(z)
             p[0] = self.finterp_z_pdf(x[0])
             # p(m)
-            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'])
+            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
             # p(zsol)
             met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
                                                   mu=loc_massmet(x[1]), sig=scale_massmet(x[1]))
@@ -278,7 +278,7 @@ def __call__(self, x, **kwargs):
             with np.errstate(invalid='ignore', divide='ignore'):
                 lnp = np.log(p)
 
-            lnp[2] = met_dist(x[2]) # FastTruncatedNormal returns ln(p)
+            lnp[2] = met_dist(x[2]) # priors.FastTruncatedNormal returns ln(p)
             return lnp
 
         else:
@@ -293,7 +293,7 @@ def __call__(self, x, **kwargs):
                 new_x = x[i]
                 p = np.zeros_like(new_x)
                 p[0] = self.finterp_z_pdf(new_x[0])
-                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'])
+                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
 
                 all_p.append(p)
 
@@ -322,7 +322,7 @@ def sample(self, nsample=None, **kwargs):
         zred = self.finterp_cdf_z(u)
 
         # draw from the mass function at the above zred
-        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'])
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
         mass = draw_sample(xs=self.mgrid, cdf=cdf_mass)
 
         # given mass from above, draw logzsol
@@ -350,7 +350,7 @@ def unit_transform(self, x, **kwargs):
 
         zred = self.finterp_cdf_z(x[0])
 
-        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'])
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
         mass = ppf(x[1], self.mgrid, cdf=cdf_mass)
 
         met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
@@ -390,9 +390,7 @@ def __init__(self, parnames=[], name='', **kwargs):
         self.update(**kwargs)
 
         self.zred_dist = priors.FastUniform(a=self.params['zred_mini'], b=self.params['zred_maxi'])
-
         self.mass_dist = priors.FastUniform(a=self.params['mass_mini'], b=self.params['mass_maxi'])
-
         self.logsfr_ratios_dist = priors.FastTruncatedEvenStudentTFreeDeg2(hw=self.params['logsfr_ratio_maxi'], sig=self.params['logsfr_ratio_tscale'])
 
     def __len__(self):
@@ -551,6 +549,195 @@ def unit_transform(self, x, **kwargs):
                                np.atleast_1d(met), np.atleast_1d(logsfr_ratios_ppf)])
 
 
+############### SFH(M, z) at FIXED ZRED ################
+# mass-met & SFH(M, z) priors
+# expectation value of the nonparametric SFH ~ Behroozi+19 cosmic SFRD
+
+class DymSFHfixZred(priors.Prior):
+
+    prior_params = ['zred', 'mass_mini', 'mass_maxi', 'z_mini', 'z_maxi',
+                    'logsfr_ratio_mini', 'logsfr_ratio_maxi', 'logsfr_ratio_tscale', 'nbins_sfh',
+                    'const_phi'] # mass is in log10
+
+    def __init__(self, parnames=[], name='', **kwargs):
+        """Overwrites __init__ in the base code priors.Prior
+
+        Parameters
+        ----------
+        parnames : sequence of strings
+            A list of names of the parameters, used to alias the intrinsic
+            parameter names.  This way different instances of the same Prior
+            can have different parameter names, in case they are being fit for....
+        """
+        if len(parnames) == 0:
+            parnames = self.prior_params
+        assert len(parnames) == len(self.prior_params)
+        self.alias = dict(zip(self.prior_params, parnames))
+        self.params = {}
+
+        self.name = name
+        self.update(**kwargs)
+
+        self.zred = self.params['zred']
+        self.mass_dist = priors.FastUniform(a=self.params['mass_mini'], b=self.params['mass_maxi'])
+        self.logsfr_ratios_dist = priors.FastTruncatedEvenStudentTFreeDeg2(hw=self.params['logsfr_ratio_maxi'], sig=self.params['logsfr_ratio_tscale'])
+
+    def __len__(self):
+        """Hack to work with Prospector 0.3
+        """
+        return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios
+
+    @property
+    def range(self):
+        return (
+                (self.params['mass_mini'], self.params['mass_maxi']),\
+                (self.params['z_mini'], self.params['z_maxi']),\
+                (self.params['logsfr_ratio_mini'], self.params['logsfr_ratio_maxi'])
+               )
+
+    def bounds(self, **kwargs):
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+        return self.range
+
+    def __call__(self, x, **kwargs):
+        """Compute the value of the probability density function at x and
+        return the ln of that.
+
+        :params x: used to calculate the prior
+            x[0] = zred, x[1] = logmass, x[2] = logzsol, x[3:] = logsfr_ratios
+
+        :param kwargs: optional
+            All extra keyword arguments are used to update the `prior_params`.
+
+        :returns lnp:
+            The natural log of the prior probability at x, scalar or ndarray of
+            same length as the prior object.
+        """
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+
+        if x.ndim == 1:
+            # doing mcmc; x is [zred, logmass, logzsol]
+            p = np.zeros_like(x)
+
+            # p(zsol)
+            met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
+                                                  mu=loc_massmet(x[1]), sig=scale_massmet(x[1]))
+            # sfh = sfrd
+            logsfr_ratios = expe_logsfr_ratios(this_z=x[0], this_m=x[1], nbins_sfh=self.params['nbins_sfh'],
+                                               logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
+                                               logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
+            p[3:] = t.pdf(x[3:], df=2, loc=logsfr_ratios, scale=self.params['logsfr_ratio_tscale'])
+
+            with np.errstate(invalid='ignore', divide='ignore'):
+                lnp = np.log(p)
+
+            lnp[0] = 0 # zred is fixed
+            lnp[1] = self.mass_dist(x[1])
+            lnp[2] = met_dist(x[2]) # priors.FastTruncatedNormal returns ln(p)
+
+            return lnp
+
+        else:
+            # write_hdf5. last step.
+            # in prior_product, x is of size (nsamples, npriors)
+            # Fast* is not vectorized?
+            # so just do a loop here
+            _zreds = x[...,0]
+            _logms = x[...,1]
+
+            all_p = []
+            for i in range(len(_zreds)):
+                new_x = x[i]
+                p = np.zeros_like(new_x)
+
+                logsfr_ratios = expe_logsfr_ratios(this_z=new_x[0], this_m=new_x[1], nbins_sfh=self.params['nbins_sfh'],
+                                                   logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
+                                                   logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
+                p[3:] = t.pdf(new_x[3:], df=2, loc=logsfr_ratios, scale=self.params['logsfr_ratio_tscale'])
+
+                all_p.append(p)
+
+            all_p = np.array(all_p)
+
+            with np.errstate(invalid='ignore', divide='ignore'):
+                lnp = np.log(all_p)
+
+            met_dists = [priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
+                                                    mu=loc_massmet(mass_i), sig=scale_massmet(mass_i)) for mass_i in x[...,1]]
+            lnp[...,0] = np.zeros(len(lnp[...,0]))
+            lnp[...,1] = self.mass_dist(_logms)
+            lnp[...,2] = [met_dists[i](met_i) for (i, met_i) in enumerate(x[...,2])]
+
+            return lnp
+
+    def sample(self, nsample=None, **kwargs):
+        """Draw a sample from the prior distribution.
+        Needed for minimizer.
+
+        :param nsample: (optional)
+            Unused. Will not work if nsample > 1 in draw_sample()!
+        """
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+        # draw a zred from pdf(z)
+        zred = self.zred * 1
+
+        mass = self.mass_dist.sample()
+
+        # given mass from above, draw logzsol
+        met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
+                                              mu=loc_massmet(mass), sig=scale_massmet(mass))
+        met = met_dist.sample()
+
+        # sfh = sfrd
+        logsfr_ratios = expe_logsfr_ratios(this_z=zred, this_m=mass, nbins_sfh=self.params['nbins_sfh'],
+                                           logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
+                                           logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
+        logsfr_ratios_rvs = t.rvs(df=2, loc=logsfr_ratios, scale=self.params['logsfr_ratio_tscale'])
+        logsfr_ratios_rvs = np.clip(logsfr_ratios_rvs, a_min=self.params['logsfr_ratio_mini'], a_max=self.params['logsfr_ratio_maxi'])
+
+        return np.concatenate([np.atleast_1d(zred), np.atleast_1d(mass),
+                               np.atleast_1d(met), np.atleast_1d(logsfr_ratios_rvs)])
+
+    def unit_transform(self, x, **kwargs):
+        """Go from a value of the CDF (between 0 and 1) to the corresponding
+        parameter value.
+        Needed for nested sampling.
+
+        :param x:
+            A scalar or vector of same length as the Prior with values between
+            zero and one corresponding to the value of the CDF.
+
+        :returns theta:
+            The parameter value corresponding to the value of the CDF given by
+            `x`.
+        """
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+
+        zred = self.zred * 1
+
+        mass = self.mass_dist.unit_transform(x[1])
+
+        met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
+                                              mu=loc_massmet(mass), sig=scale_massmet(mass))
+        met = met_dist.unit_transform(x[2])
+
+        # sfh = sfrd
+        logsfr_ratios = expe_logsfr_ratios(this_z=zred, this_m=mass, nbins_sfh=self.params['nbins_sfh'],
+                                           logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
+                                           logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
+
+        logsfr_ratios_ppf = np.zeros_like(logsfr_ratios)
+        for i in range(len(logsfr_ratios_ppf)):
+            logsfr_ratios_ppf[i] = self.logsfr_ratios_dist.unit_transform(x[3+i]) + logsfr_ratios[i]
+        logsfr_ratios_ppf = np.clip(logsfr_ratios_ppf, a_min=self.params['logsfr_ratio_mini'], a_max=self.params['logsfr_ratio_maxi'])
+        return np.concatenate([np.atleast_1d(zred), np.atleast_1d(mass),
+                               np.atleast_1d(met), np.atleast_1d(logsfr_ratios_ppf)])
+
+
 ####################### p(logM|z)p(Z*|logM) & SFH(M, z) #######################
 # mass function & Gaussian metallicity & SFH(M, z) priors
 # expectation value of the nonparametric SFH ~ Behroozi+19 cosmic SFRD
@@ -562,7 +749,7 @@ class PhiSFH(priors.Prior):
                     'const_phi'] # mass is in log10
 
     def __init__(self, parnames=[], name='', **kwargs):
-        """Overwrites __init__ in the base code Prior
+        """Overwrites __init__ in the base code priors.Prior
 
         Parameters
         ----------
@@ -581,16 +768,14 @@ def __init__(self, parnames=[], name='', **kwargs):
         self.update(**kwargs)
 
         if self.params['const_phi']:
-            zreds, pdf_zred = np.loadtxt( file_pdf_of_z_l20, unpack=True)
+            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z_l20.txt'), unpack=True)
         else:
-            zreds, pdf_zred = np.loadtxt( file_pdf_of_z_l20t18, unpack=True)
+            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z.txt'), unpack=True)
 
         self.finterp_z_pdf, self.finterp_cdf_z = norm_pz(self.params['zred_mini'], self.params['zred_maxi'], zreds, pdf_zred)
 
         self.mgrid = np.linspace(self.params['mass_mini'], self.params['mass_maxi'], 101)
-
         self.zred_dist = priors.FastUniform(a=self.params['zred_mini'], b=self.params['zred_maxi'])
-
         self.logsfr_ratios_dist = priors.FastTruncatedEvenStudentTFreeDeg2(hw=self.params['logsfr_ratio_maxi'], sig=self.params['logsfr_ratio_tscale'])
 
     def __len__(self):
@@ -632,7 +817,8 @@ def __call__(self, x, **kwargs):
             # doing mcmc; x is [zred, logmass, logzsol]
             p = np.zeros_like(x)
             # p(m)
-            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'])
+            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
+
             # p(zsol)
             met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
                                                   mu=loc_massmet(x[1]), sig=scale_massmet(x[1]))
@@ -647,7 +833,7 @@ def __call__(self, x, **kwargs):
 
             # p(z)
             lnp[0] = self.zred_dist(x[0])
-            lnp[2] = met_dist(x[2]) # FastTruncatedNormal returns ln(p)
+            lnp[2] = met_dist(x[2]) # priors.FastTruncatedNormal returns ln(p)
 
             return lnp
 
@@ -662,7 +848,7 @@ def __call__(self, x, **kwargs):
             for i in range(len(_zreds)):
                 new_x = x[i]
                 p = np.zeros_like(new_x)
-                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'])
+                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
                 logsfr_ratios = expe_logsfr_ratios(this_z=new_x[0], this_m=new_x[1], nbins_sfh=self.params['nbins_sfh'],
                                                    logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
                                                    logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
@@ -695,7 +881,7 @@ def sample(self, nsample=None, **kwargs):
         zred = self.zred_dist.sample()
 
         # draw from the mass function at the above zred
-        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'])
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
         mass = draw_sample(xs=self.mgrid, cdf=cdf_mass)
 
         # given mass from above, draw logzsol
@@ -731,7 +917,197 @@ def unit_transform(self, x, **kwargs):
 
         zred = self.zred_dist.unit_transform(x[0])
 
-        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'])
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
+        mass = ppf(x[1], self.mgrid, cdf=cdf_mass)
+
+        met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
+                                              mu=loc_massmet(mass), sig=scale_massmet(mass))
+        met = met_dist.unit_transform(x[2])
+
+        # sfh = sfrd
+        logsfr_ratios = expe_logsfr_ratios(this_z=zred, this_m=mass, nbins_sfh=self.params['nbins_sfh'],
+                                           logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
+                                           logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
+
+        logsfr_ratios_ppf = np.zeros_like(logsfr_ratios)
+        for i in range(len(logsfr_ratios_ppf)):
+            logsfr_ratios_ppf[i] = self.logsfr_ratios_dist.unit_transform(x[3+i]) + logsfr_ratios[i]
+        logsfr_ratios_ppf = np.clip(logsfr_ratios_ppf, a_min=self.params['logsfr_ratio_mini'], a_max=self.params['logsfr_ratio_maxi'])
+        return np.concatenate([np.atleast_1d(zred), np.atleast_1d(mass),
+                               np.atleast_1d(met), np.atleast_1d(logsfr_ratios_ppf)])
+
+
+################ p(logM|z)p(Z*|logM) & SFH(M, z) at FIXED ZRED ################
+# mass function & Gaussian metallicity & SFH(M, z) priors
+# expectation value of the nonparametric SFH ~ Behroozi+19 cosmic SFRD
+
+class PhiSFHfixZred(priors.Prior):
+
+    prior_params = ['zred', 'mass_mini', 'mass_maxi', 'z_mini', 'z_maxi',
+                    'logsfr_ratio_mini', 'logsfr_ratio_maxi', 'logsfr_ratio_tscale', 'nbins_sfh',
+                    'const_phi'] # mass is in log10
+
+    def __init__(self, parnames=[], name='', **kwargs):
+        """Overwrites __init__ in the base code priors.Prior
+
+        Parameters
+        ----------
+        parnames : sequence of strings
+            A list of names of the parameters, used to alias the intrinsic
+            parameter names.  This way different instances of the same Prior
+            can have different parameter names, in case they are being fit for....
+        """
+        if len(parnames) == 0:
+            parnames = self.prior_params
+        assert len(parnames) == len(self.prior_params)
+        self.alias = dict(zip(self.prior_params, parnames))
+        self.params = {}
+
+        self.name = name
+        self.update(**kwargs)
+
+        self.mgrid = np.linspace(self.params['mass_mini'], self.params['mass_maxi'], 101)
+        self.zred = self.params['zred']
+        self.logsfr_ratios_dist = priors.FastTruncatedEvenStudentTFreeDeg2(hw=self.params['logsfr_ratio_maxi'], sig=self.params['logsfr_ratio_tscale'])
+
+    def __len__(self):
+        """Hack to work with Prospector 0.3
+        """
+        return self.params['nbins_sfh']+2 # z, mass, met, + logsfr_ratios
+
+    @property
+    def range(self):
+        return (
+                (self.params['mass_mini'], self.params['mass_maxi']),\
+                (self.params['z_mini'], self.params['z_maxi']),\
+                (self.params['logsfr_ratio_mini'], self.params['logsfr_ratio_maxi'])
+               )
+
+    def bounds(self, **kwargs):
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+        return self.range
+
+    def __call__(self, x, **kwargs):
+        """Compute the value of the probability density function at x and
+        return the ln of that.
+
+        :params x: used to calculate the prior
+            x[0] = zred, x[1] = logmass, x[2] = logzsol, x[3:] = logsfr_ratios
+
+        :param kwargs: optional
+            All extra keyword arguments are used to update the `prior_params`.
+
+        :returns lnp:
+            The natural log of the prior probability at x, scalar or ndarray of
+            same length as the prior object.
+        """
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+
+        if x.ndim == 1:
+            # doing mcmc; x is [zred, logmass, logzsol]
+            p = np.zeros_like(x)
+            # p(m)
+            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
+            # p(zsol)
+            met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
+                                                  mu=loc_massmet(x[1]), sig=scale_massmet(x[1]))
+            # sfh = sfrd
+            logsfr_ratios = expe_logsfr_ratios(this_z=x[0], this_m=x[1], nbins_sfh=self.params['nbins_sfh'],
+                                               logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
+                                               logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
+            p[3:] = t.pdf(x[3:], df=2, loc=logsfr_ratios, scale=self.params['logsfr_ratio_tscale'])
+
+            with np.errstate(invalid='ignore', divide='ignore'):
+                lnp = np.log(p)
+
+            lnp[0] = 0 # zred is fixed
+            lnp[2] = met_dist(x[2]) # priors.FastTruncatedNormal returns ln(p)
+
+            return lnp
+
+        else:
+            # write_hdf5. last step.
+            # in prior_product, x is of size (nsamples, npriors)
+            # Fast* is not vectorized?
+            # so just do a loop here
+            _zreds = x[...,0]
+
+            all_p = []
+            for i in range(len(_zreds)):
+                new_x = x[i]
+                p = np.zeros_like(new_x)
+                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
+                logsfr_ratios = expe_logsfr_ratios(this_z=new_x[0], this_m=new_x[1], nbins_sfh=self.params['nbins_sfh'],
+                                                   logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
+                                                   logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
+                p[3:] = t.pdf(new_x[3:], df=2, loc=logsfr_ratios, scale=self.params['logsfr_ratio_tscale'])
+
+                all_p.append(p)
+
+            all_p = np.array(all_p)
+
+            with np.errstate(invalid='ignore', divide='ignore'):
+                lnp = np.log(all_p)
+
+            met_dists = [priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
+                                                    mu=loc_massmet(mass_i), sig=scale_massmet(mass_i)) for mass_i in x[...,1]]
+            lnp[...,0] = np.zeros(len(lnp[...,0]))
+            lnp[...,2] = [met_dists[i](met_i) for (i, met_i) in enumerate(x[...,2])]
+
+            return lnp
+
+    def sample(self, nsample=None, **kwargs):
+        """Draw a sample from the prior distribution.
+        Needed for minimizer.
+
+        :param nsample: (optional)
+            Unused. Will not work if nsample > 1 in draw_sample()!
+        """
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+        # draw a zred from pdf(z)
+        zred = self.zred * 1
+
+        # draw from the mass function at the above zred
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
+        mass = draw_sample(xs=self.mgrid, cdf=cdf_mass)
+
+        # given mass from above, draw logzsol
+        met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
+                                              mu=loc_massmet(mass), sig=scale_massmet(mass))
+        met = met_dist.sample()
+
+        # sfh = sfrd
+        logsfr_ratios = expe_logsfr_ratios(this_z=zred, this_m=mass, nbins_sfh=self.params['nbins_sfh'],
+                                           logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
+                                           logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
+        logsfr_ratios_rvs = t.rvs(df=2, loc=logsfr_ratios, scale=self.params['logsfr_ratio_tscale'])
+        logsfr_ratios_rvs = np.clip(logsfr_ratios_rvs, a_min=self.params['logsfr_ratio_mini'], a_max=self.params['logsfr_ratio_maxi'])
+
+        return np.concatenate([np.atleast_1d(zred), np.atleast_1d(mass),
+                               np.atleast_1d(met), np.atleast_1d(logsfr_ratios_rvs)])
+
+    def unit_transform(self, x, **kwargs):
+        """Go from a value of the CDF (between 0 and 1) to the corresponding
+        parameter value.
+        Needed for nested sampling.
+
+        :param x:
+            A scalar or vector of same length as the Prior with values between
+            zero and one corresponding to the value of the CDF.
+
+        :returns theta:
+            The parameter value corresponding to the value of the CDF given by
+            `x`.
+        """
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+
+        zred = self.zred * 1
+
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
         mass = ppf(x[1], self.mgrid, cdf=cdf_mass)
 
         met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
@@ -762,7 +1138,7 @@ class NzSFH(priors.Prior):
                     'const_phi'] # mass is in log10
 
     def __init__(self, parnames=[], name='', **kwargs):
-        """Overwrites __init__ in the base code Prior
+        """Overwrites __init__ in the base code priors.Prior
 
         Parameters
         ----------
@@ -784,11 +1160,12 @@ def __init__(self, parnames=[], name='', **kwargs):
         # the tables were calculated in pdf_z_tables.ipynb
         # redshift range is 0 - 20
         if self.params['const_phi']:
-            zreds, pdf_zred = np.loadtxt(file_pdf_of_z_l20, unpack=True)
+            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z_l20.txt'), unpack=True)
         else:
-            zreds, pdf_zred = np.loadtxt(file_pdf_of_z_l20t18, unpack=True)
+            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z.txt'), unpack=True)
 
         self.finterp_z_pdf, self.finterp_cdf_z = norm_pz(self.params['zred_mini'], self.params['zred_maxi'], zreds, pdf_zred)
+
         self.mgrid = np.linspace(self.params['mass_mini'], self.params['mass_maxi'], 101)
         self.zred_dist = priors.FastUniform(a=self.params['zred_mini'], b=self.params['zred_maxi'])
         self.logsfr_ratios_dist = priors.FastTruncatedEvenStudentTFreeDeg2(hw=self.params['logsfr_ratio_maxi'], sig=self.params['logsfr_ratio_tscale'])
@@ -834,7 +1211,7 @@ def __call__(self, x, **kwargs):
             # p(z)
             p[0] = self.finterp_z_pdf(x[0])
             # p(m)
-            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'])
+            p[1] = mass_func_at_z(x[0], x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
             # p(zsol)
             met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
                                                   mu=loc_massmet(x[1]), sig=scale_massmet(x[1]))
@@ -847,7 +1224,7 @@ def __call__(self, x, **kwargs):
             with np.errstate(invalid='ignore', divide='ignore'):
                 lnp = np.log(p)
 
-            lnp[2] = met_dist(x[2]) # FastTruncatedNormal returns ln(p)
+            lnp[2] = met_dist(x[2]) # priors.FastTruncatedNormal returns ln(p)
 
             return lnp
 
@@ -863,7 +1240,7 @@ def __call__(self, x, **kwargs):
                 new_x = x[i]
                 p = np.zeros_like(new_x)
                 p[0] = self.finterp_z_pdf(new_x[0])
-                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'])
+                p[1] = mass_func_at_z(new_x[0], new_x[1], self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
                 logsfr_ratios = expe_logsfr_ratios(this_z=new_x[0], this_m=new_x[1], nbins_sfh=self.params['nbins_sfh'],
                                                    logsfr_ratio_mini=self.params['logsfr_ratio_mini'],
                                                    logsfr_ratio_maxi=self.params['logsfr_ratio_maxi'])
@@ -896,7 +1273,7 @@ def sample(self, nsample=None, **kwargs):
         zred = self.finterp_cdf_z(u)
 
         # draw from the mass function at the above zred
-        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'])
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
         mass = draw_sample(xs=self.mgrid, cdf=cdf_mass)
 
         # given mass from above, draw logzsol
@@ -932,7 +1309,7 @@ def unit_transform(self, x, **kwargs):
 
         zred = self.finterp_cdf_z(x[0])
 
-        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'])
+        cdf_mass = cdf_mass_func_at_z(z=zred, logm=self.mgrid, const_phi=self.params['const_phi'], bounds=[self.params['mass_mini'], self.params['mass_maxi']])
         mass = ppf(x[1], self.mgrid, cdf=cdf_mass)
 
         met_dist = priors.FastTruncatedNormal(a=self.params['z_mini'], b=self.params['z_maxi'],
@@ -1101,23 +1478,27 @@ def high_z_mass_func(z0, this_m):
         phi = phi0*w[0] + phi1*w[1]
         return phi
 
-def mass_func_at_z(z, this_logm, const_phi=False):
+def mass_func_at_z(z, this_logm, const_phi=False, bounds=[6.0, 12.5]):
     '''
-    if const_phi == True: use mass funtions in Leja+20 only;
+    if const_phi == True: use mass functions in Leja+20 only;
                           no redshfit evolution outside the range 0.2 <= z <= 3.0;
         i.e.,
-        z<=0.2: use mass funtion at z=0.2;
+        z<=0.2: use mass function at z=0.2;
         0.2<=z<=3.0: defined in Leja+20;
-        z>=3: use mass funtion at z=3.0.
+        z>=3: use mass function at z=3.0.
     if const_phi == False: combine Leja+20 and Tacchella+18 mass functions;
         i.e.,
         z<=3: mass function in Leja+20; continuous in redshift.
         3<z<4: cos^2 weighted average of L20 mass function at z=3 and T18 mass function at z=4;
-               i.e., we weight the L20 mass funtion as cos^2(0, pi/2), and T18 as 1 - cos^2(0, pi/2).
+               i.e., we weight the L20 mass function as cos^2(0, pi/2), and T18 as 1 - cos^2(0, pi/2).
         4<=z<=12: T18 mass function; discreate in redshift by definition;
                   we take cos^2 weighted average in each bin, with zrange being the bin edges.
         z>12: T18 mass function at z=12.
     '''
+    if not hasattr(this_logm, "__len__"):
+        if this_logm < bounds[0] or this_logm > bounds[1]:
+            return np.zeros_like(this_logm)
+
     if const_phi:
         phi = low_z_mass_func(z, this_logm)
     else:
@@ -1133,28 +1514,31 @@ def mass_func_at_z(z, this_logm, const_phi=False):
         else:
             phi = high_z_mass_func(z0=12, this_m=10**this_logm)
 
+    phi[this_logm < bounds[0]] = 0
+    phi[this_logm > bounds[1]] = 0
     return np.squeeze(phi)
 
 
 ############ Empirical PDF & CDF ############
-def pdf_mass_func_at_z(z, logm, const_phi):
-    phi_50 = mass_func_at_z(z, logm, const_phi)
+def pdf_mass_func_at_z(z, logm, const_phi, bounds):
+    phi_50 = mass_func_at_z(z, logm, const_phi, bounds)
     p_phi_int = np.trapz(phi_50, logm)
     pdf_at_m = phi_50/p_phi_int
     return pdf_at_m
 
-def cdf_mass_func_at_z(z, logm, const_phi):
+def cdf_mass_func_at_z(z, logm, const_phi, bounds):
     '''
     logm: an array of [mass_mini, ..., mass_maxi], or a float
     '''
-    pdf_at_m = pdf_mass_func_at_z(z, logm=logm, const_phi=const_phi)
+    pdf_at_m = pdf_mass_func_at_z(z, logm=logm, const_phi=const_phi, bounds=bounds)
     cdf_of_m = np.cumsum(pdf_at_m)
     cdf_of_m /= max(cdf_of_m)
 
-    # may have small numerical errors; force cdf to start at 0
+    # may have small numerical errors; force cdf to be within [0, 1]
     clean = np.where(cdf_of_m < 0)
     cdf_of_m[clean] = 0
     cdf_of_m[0] = 0
+    cdf_of_m[-1] = 1
 
     return cdf_of_m
 
@@ -1162,7 +1546,7 @@ def ppf(x, xs, cdf):
     '''Go from a value x of the CDF (between 0 and 1) to
     the corresponding parameter value.
     '''
-    func_interp = interp1d(cdf, xs, bounds_error=False, fill_value="extrapolate")
+    func_interp = interp1d(cdf, xs, bounds_error=False, fill_value=0)
     param = func_interp(x)
     return param
 
@@ -1170,7 +1554,7 @@ def draw_sample(xs, cdf, nsample=None):
     '''Draw sample(s) from any cdf
     '''
     u = np.random.uniform(0, 1, size=nsample)
-    func_interp = interp1d(cdf, xs, bounds_error=False, fill_value="extrapolate")
+    func_interp = interp1d(cdf, xs, bounds_error=False, fill_value=0)
     sample = func_interp(u)
     return sample
 
@@ -1183,13 +1567,14 @@ def norm_pz(zred_mini, zred_maxi, zreds, pdf_zred):
     pdf_zred_inrange = pdf_zred[idx_zrange]/p_int
     invalid = np.where(pdf_zred_inrange<0)
     pdf_zred_inrange[invalid] = 0
-    finterp_z_pdf = interp1d(zreds_inrange, pdf_zred_inrange, bounds_error=False, fill_value="extrapolate")
+    finterp_z_pdf = interp1d(zreds_inrange, pdf_zred_inrange, bounds_error=False, fill_value=0)
 
     cdf_zred = np.cumsum(pdf_zred_inrange)
     cdf_zred /= max(cdf_zred)
     invalid = np.where(cdf_zred<0)
     cdf_zred[invalid] = 0
-    finterp_cdf_z = interp1d(cdf_zred, zreds_inrange, bounds_error=False, fill_value="extrapolate")
+    cdf_zred[-1] = 1
+    finterp_cdf_z = interp1d(cdf_zred, zreds_inrange, bounds_error=False, fill_value=0)
 
     return (finterp_z_pdf, finterp_cdf_z)
 
@@ -1232,6 +1617,7 @@ def z_to_agebins_rescale(zstart, nbins_sfh=7, amin=7.1295):
     agebins = np.array([agelims[:-1], agelims[1:]]).T
     return 10**agebins
 
+### functions needed for the SFH(M,z) prior
 def slope(x, y):
     return (y[1]-y[0])/(x[1]-x[0])
 
@@ -1260,7 +1646,6 @@ def expe_logsfr_ratios(this_z, this_m, logsfr_ratio_mini, logsfr_ratio_maxi,
     age_shifted = np.log10(cosmo.age(this_z).value) + delta_t_dex(this_m)
     age_shifted = 10**age_shifted
 
-    # introduce these limits for stability
     zmin_thres = 0.15
     zmax_thres = 10
     if age_shifted < age[-1]:
@@ -1275,6 +1660,7 @@ def expe_logsfr_ratios(this_z, this_m, logsfr_ratio_mini, logsfr_ratio_maxi,
         z_shifted = zmin_thres * 1
 
     agebins_shifted = z_to_agebins_rescale(zstart=z_shifted, nbins_sfh=nbins_sfh, amin=amin)
+
     nsfrbins = agebins_shifted.shape[0]
     sfr_shifted = np.zeros(nsfrbins)
     for i in range(nsfrbins):

From a738950f28c8d6238a0f5e7879a6197344fc4bd3 Mon Sep 17 00:00:00 2001
From: Yasmeen Asali <yasmeenasali@gmail.com>
Date: Tue, 13 Jun 2023 13:20:33 -0400
Subject: [PATCH 002/132] fixing suspected typo in sfh.py

changing the parametric_pset() function call to remove a typo in argument
---
 prospect/plotting/sfh.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prospect/plotting/sfh.py b/prospect/plotting/sfh.py
index 0c136fe2..cfde42d5 100644
--- a/prospect/plotting/sfh.py
+++ b/prospect/plotting/sfh.py
@@ -151,7 +151,7 @@ def parametric_cmf(times=None, tage=1., **sfh):
     if times is None:
         times = np.array(sfh["tage"])
 
-    pset = parametric_pset(tage=tage**sfh)
+    pset = parametric_pset(tage=tage, **sfh)
     _, mass = compute_mass_formed(tage - times, pset)
     return mass
 

From 4e9d57add2c7625cbdd76c9b9d98cce43a68adc9 Mon Sep 17 00:00:00 2001
From: Elijah Mathews <me@elijahmathews.com>
Date: Thu, 29 Jun 2023 14:50:06 -0500
Subject: [PATCH 003/132] avoid RuntimeWarning when smoothing with 0 km/s

---
 prospect/utils/smoothing.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/prospect/utils/smoothing.py b/prospect/utils/smoothing.py
index e1e17540..dc90ef58 100644
--- a/prospect/utils/smoothing.py
+++ b/prospect/utils/smoothing.py
@@ -102,8 +102,12 @@ def smoothspec(wave, spec, resolution=None, outwave=None,
         units = 'km/s'
         sigma = resolution
         fwhm = sigma * sigma_to_fwhm
-        Rsigma = ckms / sigma
-        R = ckms / fwhm
+        if sigma == 0.0:
+            Rsigma = np.infty
+            R = np.infty
+        else:
+            Rsigma = ckms / sigma
+            R = ckms / fwhm
         width = Rsigma
         assert np.size(sigma) == 1, "`resolution` must be scalar for `smoothtype`='vel'"
 

From 2fa085df5c5f5a157b4409f836e39779f157ade6 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 7 Jul 2023 13:12:34 -0400
Subject: [PATCH 004/132] closes #288

---
 conda_install.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/conda_install.sh b/conda_install.sh
index 19bb4d45..22bd4323 100644
--- a/conda_install.sh
+++ b/conda_install.sh
@@ -12,7 +12,7 @@ export SPS_HOME="$PWD/fsps"
 # Create and activate environment (named 'prospector')
 git clone https://github.com/bd-j/prospector.git
 cd prospector
-conda env create -f environment.yml
+conda env create -f environment.yml -n prospector
 conda activate prospector
 python -m pip install .
 

From d9af876624606b16752dde2a430d7aa2bbcfb8e0 Mon Sep 17 00:00:00 2001
From: Bingjie Wang <bwang.jhu@gmail.com>
Date: Thu, 27 Jul 2023 23:00:17 -0400
Subject: [PATCH 005/132] mod write_h5_header so that no OSError is threw &
 added an option of write_model_params=False

---
 prospect/io/write_results.py | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index 00d0460f..d8d7a7bc 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -64,7 +64,8 @@ def paramfile_string(param_file=None, **extras):
 
 def write_hdf5(hfile, run_params, model, obs, sampler=None,
                optimize_result_list=None, tsample=0.0, toptimize=0.0,
-               sampling_initial_center=[], sps=None, **extras):
+               sampling_initial_center=[], sps=None, write_model_params=True,
+               **extras):
     """Write output and information to an HDF5 file object (or
     group).
 
@@ -138,7 +139,7 @@ def write_hdf5(hfile, run_params, model, obs, sampler=None,
 
     # ----------------------
     # High level parameter and version info
-    write_h5_header(hf, run_params, model)
+    write_h5_header(hf, run_params, model, write_model_params=write_model_params)
     hf.attrs['optimizer_duration'] = json.dumps(toptimize)
     hf.flush()
 
@@ -274,13 +275,23 @@ def write_dynesty_h5(hf, dynesty_out, model, tsample):
     hf.flush()
 
 
-def write_h5_header(hf, run_params, model):
+def write_h5_header(hf, run_params, model, write_model_params=True):
     """Write header information about the run.
     """
     serialize = {'run_params': run_params,
                  'model_params': [functions_to_names(p.copy())
                                   for p in model.config_list],
                  'paramfile_text': paramfile_string(**run_params)}
+    try:
+        hf.attrs['model_params'] = pick(serialize['model_params'])
+    except:
+        serialize['model_params'] = None
+
+    if not write_model_params:
+        serialize = {'run_params': run_params,
+                     'model_params': None,
+                     'paramfile_text': paramfile_string(**run_params)}
+
     for k, v in list(serialize.items()):
         try:
             hf.attrs[k] = json.dumps(v)  #, cls=NumpyEncoder)

From 770e3bf79eda6fa6a263727a17d5b4379c4ea819 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 28 Aug 2023 10:57:11 -0400
Subject: [PATCH 006/132] update rtd config.

---
 .readthedocs.yaml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index 47b238c2..54b10276 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -1,8 +1,12 @@
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
 sphinx:
    configuration: doc/conf.py
 
 python:
-  version: 3.7
   install:
     - requirements: doc/requirements.txt
     - method: pip

From 6e72fe36be8ae44621b67cf8364b1b07a4c01809 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 28 Aug 2023 11:05:58 -0400
Subject: [PATCH 007/132] update rtd config.

---
 .readthedocs.yaml | 4 +++-
 doc/conf.py       | 6 +++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index 54b10276..a7d3d299 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -1,7 +1,9 @@
+version: 2
+
 build:
   os: ubuntu-22.04
   tools:
-    python: "3.11"
+    python: "3.10"
 
 sphinx:
    configuration: doc/conf.py
diff --git a/doc/conf.py b/doc/conf.py
index 29993edb..3b3950c6 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -38,15 +38,15 @@
 
 # General information about the project.
 project = 'prospector'
-copyright = '2014-2022, Benjamin Johnson and Contributors'
+copyright = '2014-2023, Benjamin Johnson and Contributors'
 author = 'Benjamin Johnson'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 # The short X.Y version.
-version = '1.1'
-release = '1.1'
+version = '1.2'
+release = '1.2'
 
 language = None
 exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']

From c8ccfaaf9df6025d50b526538f700e5241dd9da8 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 28 Aug 2023 11:31:45 -0400
Subject: [PATCH 008/132] explicitly install scipy for tests.

---
 .github/workflows/tests.yml | 3 ++-
 README.md                   | 1 +
 environment.yml             | 2 +-
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 842a7ac7..ec6e8e71 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -12,7 +12,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9"]
+        python-version: ["3.9", "3.10"]
         os: [ubuntu-latest, macos-latest]
     steps:
       - name: Clone the repo
@@ -30,6 +30,7 @@ jobs:
         run: |
           python -m pip install -U pip pytest
           python -m pip install -U fsps astro-sedpy astropy
+          python -m pip install -U scipy
           python -m pip install -U six dynesty
           python -m pip install .
         env:
diff --git a/README.md b/README.md
index 60ed8ce0..3f6e55fc 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,7 @@
 ==========
 
 [![Docs](https://readthedocs.org/projects/prospect/badge/?version=latest)](https://readthedocs.org/projects/prospect/badge/?version=latest)
+[![Tests](https://github.com/bd-j/sedpy/workflows/Tests/badge.svg)](https://github.com/bd-j/sedpy/actions?query=workflow%3ATests)
 [![arXiv](https://img.shields.io/badge/arXiv-2012.01426-b31b1b.svg)](https://arxiv.org/abs/2012.01426)
 [![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/bd-j/prospector/blob/main/LICENSE)
 
diff --git a/environment.yml b/environment.yml
index 479fefeb..71e0be83 100644
--- a/environment.yml
+++ b/environment.yml
@@ -2,7 +2,7 @@ channels:
   - conda-forge
   - astropy
 dependencies:
-  - python==3.8
+  - python==3.10
   # infrastructure
   - pip
   - ipython

From 5c0255ae828c2b501e66747dcae963fec5e81a8d Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 28 Aug 2023 11:41:27 -0400
Subject: [PATCH 009/132] [ci skip] fix test badge link in readme.

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 3f6e55fc..da9bde78 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 ==========
 
 [![Docs](https://readthedocs.org/projects/prospect/badge/?version=latest)](https://readthedocs.org/projects/prospect/badge/?version=latest)
-[![Tests](https://github.com/bd-j/sedpy/workflows/Tests/badge.svg)](https://github.com/bd-j/sedpy/actions?query=workflow%3ATests)
+[![Tests](https://github.com/bd-j/prospector/workflows/Tests/badge.svg)](https://github.com/bd-j/prospector/actions?query=workflow%3ATests)
 [![arXiv](https://img.shields.io/badge/arXiv-2012.01426-b31b1b.svg)](https://arxiv.org/abs/2012.01426)
 [![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/bd-j/prospector/blob/main/LICENSE)
 

From f46ca4e76d95d356b01a4e2ba8b6ad5f5d50ee7d Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 23 Oct 2023 15:05:09 -0400
Subject: [PATCH 010/132] propogate the data mask to the eline fitting mask.

---
 prospect/models/sedmodel.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 8f15d9c2..9dc5980b 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -378,6 +378,7 @@ def cache_eline_parameters(self, obs, nsigma=5, forcelines=False):
         # This part has to go in every call
         linewidth = nsigma * self._ewave_obs / ckms * self._eline_sigma_kms
         pixel_mask = (np.abs(self._outwave - self._ewave_obs[:, None]) < linewidth[:, None])
+        pixel_mask = pixel_mask & obs.get("mask")[None, :]
         self._valid_eline = pixel_mask.any(axis=1) & self._use_eline
 
         # --- wavelengths corresponding to valid lines ---

From 0f93422d8a8038afb8c92a3cff22af0894202be4 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 5 Dec 2023 21:02:57 -0500
Subject: [PATCH 011/132] update citation info; fix line indices for
 AGNSpecModel to correspond to recent FSPS.

---
 doc/index.rst               | 32 +----------------------------
 doc/nebular.rst             |  2 +-
 doc/quickstart.rst          |  2 +-
 doc/ref.rst                 | 41 +++++++++++++++++++++++++++++++++++++
 prospect/models/sedmodel.py | 13 +++++++-----
 tests/test_eline.py         |  8 ++++----
 6 files changed, 56 insertions(+), 42 deletions(-)
 create mode 100644 doc/ref.rst

diff --git a/doc/index.rst b/doc/index.rst
index 1aa3ebb1..376bfbc2 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -34,6 +34,7 @@ Prospector allows you to:
    sfhs
    nebular
    output
+   ref
 
 .. toctree::
    :maxdepth: 1
@@ -55,37 +56,6 @@ Prospector allows you to:
    api/plotting_api
    api/utils_api
 
-License and Attribution
-------------------------------
-
-*Copyright 2014-2022 Benjamin D. Johnson and contributors.*
-
-This code is available under the `MIT License
-<https://raw.github.com/bdj/prospector/blob/main/LICENSE>`_.
-
-If you use this code, please reference `this paper <https://ui.adsabs.harvard.edu/abs/2021ApJS..254...22J/abstract>`_:
-
-.. code-block:: none
-
-    @ARTICLE{2021ApJS..254...22J,
-        author = {{Johnson}, Benjamin D. and {Leja}, Joel and {Conroy}, Charlie and {Speagle}, Joshua S.},
-            title = "{Stellar Population Inference with Prospector}",
-        journal = {\apjs},
-        keywords = {Galaxy evolution, Spectral energy distribution, Astronomy data modeling, 594, 2129, 1859, Astrophysics - Astrophysics of Galaxies, Astrophysics - Instrumentation and Methods for Astrophysics},
-            year = 2021,
-            month = jun,
-        volume = {254},
-        number = {2},
-            eid = {22},
-            pages = {22},
-            doi = {10.3847/1538-4365/abef67},
-    archivePrefix = {arXiv},
-        eprint = {2012.01426},
-    primaryClass = {astro-ph.GA},
-        adsurl = {https://ui.adsabs.harvard.edu/abs/2021ApJS..254...22J},
-        adsnote = {Provided by the SAO/NASA Astrophysics Data System}
-    }
-
 Changelog
 ---------
 
diff --git a/doc/nebular.rst b/doc/nebular.rst
index cfbbfb79..0a9063cc 100644
--- a/doc/nebular.rst
+++ b/doc/nebular.rst
@@ -75,7 +75,7 @@ photometry).  These parameters are:
 
 In all cases the line names to use in these lists are those given in the FSPS
 emission line line information table, ``$SPS_HOME/data/emlines_info.dat``, e.g.
-``"Ly alpha 1216"`` for the Lyman-alpha 1216 Angstrom line.
+``"Ly-alpha 1215"`` for the Lyman-alpha 1216 Angstrom line.
 
 Nebular Parameter Templates
 ---------------------------
diff --git a/doc/quickstart.rst b/doc/quickstart.rst
index 51f6606d..773d6b2d 100644
--- a/doc/quickstart.rst
+++ b/doc/quickstart.rst
@@ -91,7 +91,7 @@ Get a 'Source'
 Now we need an object that will actually generate the galaxy spectrum using
 stellar population synthesis.  For this we will use an object that wraps FSPS
 allowing access to all the parameterized SFHs.  We will also just check which
-spectral and isochrone librariews are being used.
+spectral and isochrone libraries are being used.
 
 .. code:: python
 
diff --git a/doc/ref.rst b/doc/ref.rst
new file mode 100644
index 00000000..07686408
--- /dev/null
+++ b/doc/ref.rst
@@ -0,0 +1,41 @@
+
+License and Attribution
+=======================
+
+*Copyright 2014-2023 Benjamin D. Johnson and contributors.*
+
+This code is available under the `MIT License
+<https://raw.github.com/bdj/prospector/blob/main/LICENSE>`_.
+
+If you use this code, please reference `this paper <https://ui.adsabs.harvard.edu/abs/2021ApJS..254...22J/abstract>`_:
+
+.. code-block:: none
+
+    @ARTICLE{2021ApJS..254...22J,
+        author = {{Johnson}, Benjamin D. and {Leja}, Joel and {Conroy}, Charlie and {Speagle}, Joshua S.},
+            title = "{Stellar Population Inference with Prospector}",
+        journal = {\apjs},
+        keywords = {Galaxy evolution, Spectral energy distribution, Astronomy data modeling, 594, 2129, 1859, Astrophysics - Astrophysics of Galaxies, Astrophysics - Instrumentation and Methods for Astrophysics},
+            year = 2021,
+            month = jun,
+        volume = {254},
+        number = {2},
+            eid = {22},
+            pages = {22},
+            doi = {10.3847/1538-4365/abef67},
+    archivePrefix = {arXiv},
+        eprint = {2012.01426},
+    primaryClass = {astro-ph.GA},
+        adsurl = {https://ui.adsabs.harvard.edu/abs/2021ApJS..254...22J},
+        adsnote = {Provided by the SAO/NASA Astrophysics Data System}
+    }
+
+and `Leja et al 2019 <https://ui.adsabs.harvard.edu/abs/2017ApJ...837..170L/abstract>`
+
+
+Please also see the reference requirements for dependencies
+
+* `FSPS <https://github.com/cconroy20/fsps#references>``
+* `python-fsps <https://python-fsps.readthedocs.io/en/latest/#license>`
+* `dynesty <https://dynesty.readthedocs.io/en/latest/references.html>`
+* `emcee <https://emcee.readthedocs.io/en/stable/#license-attribution>`
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 9dc5980b..6787c2d2 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -908,15 +908,18 @@ def _available_parameters(self):
 
     def init_aline_info(self):
         """AGN line spectrum. Based on data as reported in Richardson et al.
-        2014 (Table 3, the 'a42' dataset) and normalized to Hbeta.index=48 is Hbeta
+        2014 (Table 3, the 'a42' dataset) and normalized to Hbeta.
+
+        index=59 is Hbeta
         """
-        ainds = np.array([31, 33, 34, 35, 37, 42, 43, 44, 48,
-                          49, 50, 52, 56, 57, 58, 60, 61, 62,
-                          63, 64, 65, 66, 68])
+        ainds = np.array([38, 40, 41, 43, 45, 50, 51, 52, 59,
+                          61, 62, 64, 68, 69, 70, 72, 73, 74,
+                          75, 76, 77, 78, 80])
         afluxes = np.array([2.96, 0.06, 0.1 , 1.  , 0.2 , 0.25, 0.48, 0.13, 1.,
                             2.87, 8.53, 0.07, 0.02, 0.1 , 0.33, 0.09, 0.79, 2.86,
                             2.13, 0.03, 0.77, 0.65, 0.19])
-        self._aline_lum = np.zeros(128)
+        self._aline_lum = np.zeros(len(self.emline_info))
+        assert np.abs(self.emline_info["wave"][59] - 4863) < 2
         self._aline_lum[ainds] = afluxes
 
     def predict_spec(self, obs, sigma_spec=None, **extras):
diff --git a/tests/test_eline.py b/tests/test_eline.py
index 78acc6b1..14d9a53c 100644
--- a/tests/test_eline.py
+++ b/tests/test_eline.py
@@ -19,12 +19,12 @@ def test_eline_parsing():
     model_pars.update(TemplateLibrary["nebular"])
 
     # test ignoring a line
-    lya = "Ly alpha 1216"
+    lya = "Ly-alpha 1215"
     model_pars["elines_to_ignore"] = dict(init=lya, isfree=False)
     model = SpecModel(model_pars)
     model.parse_elines()
     assert not np.isin(lya, model.emline_info["name"][model._use_eline])
-    assert np.isin("H alpha 6563", model.emline_info["name"][model._use_eline])
+    assert np.isin("Ba-alpha 6563", model.emline_info["name"][model._use_eline])
     assert np.all(model._fix_eline)
     assert model._use_eline.sum() == len(model._use_eline) - 1
     assert len(model._use_eline) == len(model.emline_info)
@@ -36,7 +36,7 @@ def test_eline_parsing():
     assert model._fit_eline.sum() == len(model._use_eline)
 
     # test fitting just a line or two
-    fit_lines = ["[OIII]5007"]
+    fit_lines = ["[O III] 5007"]
     model_pars["elines_to_fit"] = dict(init=fit_lines)
     model = SpecModel(model_pars)
     model.parse_elines()
@@ -173,7 +173,7 @@ def test_eline_implementation():
     spec, phot, mfrac = model.predict(model.theta, obs=obs, sps=sps)
 
     # test ignoring a line
-    lya = "Ly alpha 1216"
+    lya = "Ly-alpha 1215"
     model_pars["elines_to_ignore"] = dict(init=lya, isfree=False)
     model = SpecModel(model_pars)
     spec_nolya, phot_nolya, mfrac = model.predict(model.theta, obs=obs, sps=sps)

From 0a0da6df357f54e7b7511acd3a244243fe754927 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 5 Dec 2023 22:07:44 -0500
Subject: [PATCH 012/132] [ci-skip] fix rst links.

---
 doc/ref.rst | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/ref.rst b/doc/ref.rst
index 07686408..682a8364 100644
--- a/doc/ref.rst
+++ b/doc/ref.rst
@@ -30,12 +30,12 @@ If you use this code, please reference `this paper <https://ui.adsabs.harvard.ed
         adsnote = {Provided by the SAO/NASA Astrophysics Data System}
     }
 
-and `Leja et al 2019 <https://ui.adsabs.harvard.edu/abs/2017ApJ...837..170L/abstract>`
+and `Leja et al 2019 <https://ui.adsabs.harvard.edu/abs/2017ApJ...837..170L/abstract>`_
 
 
 Please also see the reference requirements for dependencies
 
-* `FSPS <https://github.com/cconroy20/fsps#references>``
-* `python-fsps <https://python-fsps.readthedocs.io/en/latest/#license>`
-* `dynesty <https://dynesty.readthedocs.io/en/latest/references.html>`
-* `emcee <https://emcee.readthedocs.io/en/stable/#license-attribution>`
+* `FSPS <https://github.com/cconroy20/fsps#references>`_
+* `python-fsps <https://python-fsps.readthedocs.io/en/latest/#license>`_
+* `dynesty <https://dynesty.readthedocs.io/en/latest/references.html>`_
+* `emcee <https://emcee.readthedocs.io/en/stable/#license-attribution>`_

From 30d2babb64c46137a7fcd504028db0ec7cf5a9ca Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 6 Dec 2023 11:07:55 -0500
Subject: [PATCH 013/132] [ci-skip] doc clarification.

---
 doc/ref.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/ref.rst b/doc/ref.rst
index 682a8364..37cd1307 100644
--- a/doc/ref.rst
+++ b/doc/ref.rst
@@ -33,7 +33,7 @@ If you use this code, please reference `this paper <https://ui.adsabs.harvard.ed
 and `Leja et al 2019 <https://ui.adsabs.harvard.edu/abs/2017ApJ...837..170L/abstract>`_
 
 
-Please also see the reference requirements for dependencies
+Please also see the reference requirements for any dependencies that are used
 
 * `FSPS <https://github.com/cconroy20/fsps#references>`_
 * `python-fsps <https://python-fsps.readthedocs.io/en/latest/#license>`_

From dd50479ad5784d02304a2f14e6cc92b529ca47a5 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 11 Dec 2023 09:31:03 -0500
Subject: [PATCH 014/132] fix polynomial regularization bug (#296)

---
 prospect/models/sedmodel.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 6787c2d2..64f1cb38 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -659,9 +659,8 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
         """Implements a Chebyshev polynomial calibration model. This uses
         least-squares to find the maximum-likelihood Chebyshev polynomial of a
         certain order describing the ratio of the observed spectrum to the model
-        spectrum, conditional on all other parameters, using least squares. If
-        emission lines are being marginalized out, they are excluded from the
-        least-squares fit.
+        spectrum, conditional on all other parameters. If emission lines are
+        being marginalized out, they are excluded from the least-squares fit.
 
         :returns cal:
            A polynomial given by :math:`\sum_{m=0}^M a_{m} * T_m(x)`.
@@ -670,11 +669,10 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
             self.set_parameters(theta)
 
         # norm = self.params.get('spec_norm', 1.0)
-        polyopt = ((self.params.get('polyorder', 0) > 0) &
+        order = np.squeeze(self.params.get('polyorder', 0))
+        polyopt = ((order > 0) &
                    (obs.get('spectrum', None) is not None))
         if polyopt:
-            order = self.params['polyorder']
-
             # generate mask
             # remove region around emission lines if doing analytical marginalization
             mask = obs.get('mask', np.ones_like(obs['wavelength'], dtype=bool)).copy()
@@ -1225,10 +1223,10 @@ def spec_calibration(self, theta=None, obs=None, **kwargs):
             self.set_parameters(theta)
 
         norm = self.params.get('spec_norm', 1.0)
-        polyopt = ((self.params.get('polyorder', 0) > 0) &
+        order = np.squeeze(self.params.get('polyorder', 0))
+        polyopt = ((order > 0) &
                    (obs.get('spectrum', None) is not None))
         if polyopt:
-            order = self.params['polyorder']
             mask = obs.get('mask', slice(None))
             # map unmasked wavelengths to the interval -1, 1
             # masked wavelengths may have x>1, x<-1

From 6583fd042fd8c391d5edabfc98832faa26e880a5 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 11 Dec 2023 13:54:24 -0500
Subject: [PATCH 015/132] fix PolySpec regularization dimension mismatch (#296)

---
 prospect/models/sedmodel.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 64f1cb38..c41649c9 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -689,7 +689,7 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
             ATA = np.dot(A.T, A / yvar[:, None])
             reg = self.params.get('poly_regularization', 0.)
             if np.any(reg > 0):
-                ATA += reg**2 * np.eye(order)
+                ATA += reg**2 * np.eye(order+1)
             ATAinv = np.linalg.inv(ATA)
             c = np.dot(ATAinv, np.dot(A.T, y / yvar))
             Afull = chebvander(x, order)

From 364d0c014059450413ced68cbe8d7fc2ef4c5273 Mon Sep 17 00:00:00 2001
From: davidjsetton <davidsetton@pitt.edu>
Date: Tue, 12 Dec 2023 15:06:27 -0500
Subject: [PATCH 016/132] set the values in np.clip() from [-100,100] to
 [-10,10] to help with numerical issues with large logsfr_ratio jumps that
 were causing the returned SFHs to contain nans

---
 prospect/models/transforms.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/prospect/models/transforms.py b/prospect/models/transforms.py
index b8d2697c..7563e78d 100755
--- a/prospect/models/transforms.py
+++ b/prospect/models/transforms.py
@@ -184,7 +184,7 @@ def logsfr_ratios_to_masses(logmass=None, logsfr_ratios=None, agebins=None,
     time.
     """
     nbins = agebins.shape[0]
-    sratios = 10**np.clip(logsfr_ratios, -100, 100)  # numerical issues...
+    sratios = 10**np.clip(logsfr_ratios, -10, 10)  # numerical issues...
     dt = (10**agebins[:, 1] - 10**agebins[:, 0])
     coeffs = np.array([ (1. / np.prod(sratios[:i])) * (np.prod(dt[1: i+1]) / np.prod(dt[: i]))
                         for i in range(nbins)])
@@ -209,8 +209,8 @@ def logsfr_ratios_to_sfrs(logmass=None, logsfr_ratios=None, agebins=None, **extr
 def logsfr_ratios_to_masses_flex(logmass=None, logsfr_ratios=None,
                                  logsfr_ratio_young=None, logsfr_ratio_old=None,
                                  **extras):
-    logsfr_ratio_young = np.clip(logsfr_ratio_young, -100, 100)
-    logsfr_ratio_old = np.clip(logsfr_ratio_old, -100, 100)
+    logsfr_ratio_young = np.clip(logsfr_ratio_young, -10, 10)
+    logsfr_ratio_old = np.clip(logsfr_ratio_old, -10, 10)
 
     abins = logsfr_ratios_to_agebins(logsfr_ratios=logsfr_ratios, **extras)
 
@@ -236,7 +236,7 @@ def logsfr_ratios_to_agebins(logsfr_ratios=None, agebins=None, **extras):
     """
 
     # numerical stability
-    logsfr_ratios = np.clip(logsfr_ratios, -100, 100)
+    logsfr_ratios = np.clip(logsfr_ratios, -10, 10)
 
     # calculate delta(t) for oldest, youngest bins (fixed)
     lower_time = (10**agebins[0, 1] - 10**agebins[0, 0])

From 14011373961e9942117df03a253a232b9af16f45 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 18 Jun 2022 20:39:03 -0400
Subject: [PATCH 017/132] readme laying out goals for version 2.0

---
 README.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/README.md b/README.md
index da9bde78..fee61c18 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,19 @@
 <img src="doc/_static/logo_name_kh.png" height=75/>  <!-- . -->
 ==========
 
+Version 2.0! (in progress)
+--------------------------
+
+This is a major refactor to allow for multiple datasets (i.e. multiple spectra)
+with different noise models and instrument parameters to constrain a single
+galaxy model.  It will also include substantial updates to the outputs to allow
+samples of the spectra (and mfrac) generated during sampling to be saved as well
+as as cleaner parameter sample output. It may include emulator models and
+gradient based sampling.
+
+Badges
+------
+
 [![Docs](https://readthedocs.org/projects/prospect/badge/?version=latest)](https://readthedocs.org/projects/prospect/badge/?version=latest)
 [![Tests](https://github.com/bd-j/prospector/workflows/Tests/badge.svg)](https://github.com/bd-j/prospector/actions?query=workflow%3ATests)
 [![arXiv](https://img.shields.io/badge/arXiv-2012.01426-b31b1b.svg)](https://arxiv.org/abs/2012.01426)

From d3b2949a36d22e26cafcba7b6156721df1cbb778 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 19 Jun 2022 10:12:24 -0400
Subject: [PATCH 018/132] add a to-do list.

---
 README.md | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index fee61c18..d6ad5f71 100644
--- a/README.md
+++ b/README.md
@@ -11,16 +11,37 @@ samples of the spectra (and mfrac) generated during sampling to be saved as well
 as as cleaner parameter sample output. It may include emulator models and
 gradient based sampling.
 
-Badges
-------
+Work to do includes:
+
+- [x] Convert to/from old style observation dictionaries
+- [x] Put responsibility for Noise Models including outlier modeling in individual Observation instances
+- [x] Make predictions even when there is no fittable data (e.g. model spectra when fitting photometry only)
+- [x] Store Observation objects in HDF5, FITS, etc as structured arrays with metadata
+- [ ] Test multi-spectral calibration
+- [ ] Test multi-spectral instrumental & physical smoothing
+- [ ] Test smoothing accounting for library resolution
+- [ ] Test multi-spectra noise modeling
+- [ ] Catch (and handle?) emission line marginalization if spectra overlap.
+- [x] Update demo scripts
+- [x] Update docs
+- [ ] Update notebooks
+- [x] Structured ndarray for output chains and lnlikehoods
+- [ ] Test i/o with structured arrays
+- [ ] Structured ndarray for derived parameters
+- [ ] Store samples of spectra, photometry, and mfrac
+- [ ] Update plotting module
+- [ ] Implement an emulator-based SpecModel class
+
+
+Purpose
+-------
 
 [![Docs](https://readthedocs.org/projects/prospect/badge/?version=latest)](https://readthedocs.org/projects/prospect/badge/?version=latest)
 [![Tests](https://github.com/bd-j/prospector/workflows/Tests/badge.svg)](https://github.com/bd-j/prospector/actions?query=workflow%3ATests)
 [![arXiv](https://img.shields.io/badge/arXiv-2012.01426-b31b1b.svg)](https://arxiv.org/abs/2012.01426)
 [![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/bd-j/prospector/blob/main/LICENSE)
 
-Purpose
--------
+
 Conduct principled inference of stellar population properties from photometric
 and/or spectroscopic data.  Prospector allows you to:
 

From 9eb80f9998986790db053513cdf891325dd1c9e8 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 19 Jun 2022 10:21:20 -0400
Subject: [PATCH 019/132] run tests on branch v2.0

---
 .github/workflows/tests.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index ec6e8e71..beb1b179 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -1,9 +1,9 @@
 name: Tests
 on:
   push:
-    branches: [main]
+    branches: [main, v2.0]
   pull_request:
-    branches: [main]
+    branches: [main, v2.0]
 
 jobs:
   tests:

From ba7aec15c86dc67c75419798994c1f88c4ccdc5d Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 29 Jun 2021 10:29:07 -0400
Subject: [PATCH 020/132] Start work on Observation class, trying to maintain
 backwards compatibility with obs dicts.

---
 prospect/utils/observation.py | 154 ++++++++++++++++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 prospect/utils/observation.py

diff --git a/prospect/utils/observation.py b/prospect/utils/observation.py
new file mode 100644
index 00000000..02209de3
--- /dev/null
+++ b/prospect/utils/observation.py
@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+
+import json
+import numpy as np
+
+
+class NumpyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        if isinstance(obj, type):
+            return str(obj)
+        return json.JSONEncoder.default(self, obj)
+
+
+class Observation:
+
+    logify_spectrum = False
+    alias = {}
+
+    def __init__(self,
+                 flux=None,
+                 uncertainty=None,
+                 mask=slice(None),
+                 **kwargs
+                 ):
+
+        self.flux = flux
+        self.uncertainty = uncertainty
+        self.mask = mask
+        self.from_oldstyle(**kwargs)
+
+    def __getitem__(self, item):
+        """Dict-like interface for backwards compatibility
+        """
+        k = self.alias.get(item, item)
+        return getattr(self, k)
+
+    def from_oldstyle(self, **kwargs):
+        """Take an old-style obs dict and use it to populate the relevant
+        attributes.
+        """
+        for k, v in self.alias.items():
+            if k in kwargs:
+                setattr(self, v, kwargs[k])
+
+    def rectify(self):
+        """Make sure required attributes are present and have the appropriate
+        sizes.  Also auto-masks non-finite data or negative uncertainties.
+        """
+        assert self.wavelength.ndim == 1, "`wavelength` is not 1-d array"
+        assert self.ndata > 0, "no wavelength points supplied!"
+        assert len(self.wavelength) == len(self.flux), "Flux array not same shape as wavelength"
+        assert len(self.wavelength) == len(self.uncertainty), "Uncertainty array not same shape as wavelength"
+
+        # make mask array with automatic filters
+        marr = np.zeros(self.ndata, dtype=bool)
+        marr[self.mask] = True
+        self.mask = (marr &
+                     (np.isfinite(self.flux)) &
+                     (np.isfinite(self.uncertainty)) &
+                     (self.uncertainty > 0))
+
+        assert self.ndof > 0, "No valid data to fit: check the sign of the masks."
+
+    def render(self, wavelength, spectrum):
+        raise(NotImplementedError)
+
+    @property
+    def ndof(self):
+        return int(self.mask.sum())
+
+    @property
+    def ndata(self):
+        if self.wavelength is None:
+            return 0
+        else:
+            return len(self.wavelength)
+
+    def serialize(self):
+        obs = vars(self)
+        serial = json.dumps(obs, cls=NumpyEncoder)
+
+
+class Photometry(Observation):
+
+    kind = "photometry"
+    alias = dict(maggies="flux",
+                 maggies_unc="uncertainty",
+                 filters="filters",
+                 phot_mask="mask")
+
+    def __init__(self, filters=[], **kwargs):
+
+        super(Photometry, self).__init__(**kwargs)
+        self.filters = filters
+
+    def render(self, wavelength, spectrum):
+        w, s = wavelength, spectrum
+        mags = [f.ab_mag(w, s, **self.render_kwargs)
+                for f in self.filters]
+        return 10**(-0.4 * np.array(mags))
+
+    @property
+    def wavelength(self):
+        return np.array([f.wave_effective for f in self.filters])
+
+    def to_oldstyle(self):
+        obs = vars(self)
+        obs.update({k: self[v] for k, v in self.alias.items()})
+        _ = [obs.pop(k) for k in ["flux", "uncertainty", "mask"]]
+        obs["phot_wave"] = self.wavelength
+        return obs
+
+
+class Spectrum(Observation):
+
+    kind = "spectrum"
+    alias = dict(spectrum="flux",
+                 unc="uncertainty",
+                 wavelength="wavelength",
+                 mask="mask")
+
+    def __init__(self,
+                 wavelength=None,
+                 resolution=None,
+                 calibration=None,
+                 **kwargs):
+
+        """
+        :param resolution: (optional, default: None)
+            Instrumental resolution at each wavelength point in units of km/s
+            dispersion (:math:`= c \, \sigma_\lambda / \lambda = c \, \FWHM_\lambda / 2.355 / \lambda = c / (2.355 \, R_\lambda)`
+            where :math:`c=2.998e5 {\rm km}/{\rm s}`
+
+        :param calibration:
+            not sure yet ....
+        """
+        super(Spectrum, self).__init__(**kwargs)
+        self.wavelength = wavelength
+        self.resolution = resolution
+        self.calibration = calibration
+
+    def render(self, wavelength, spectrum):
+        if self.ndata > 0:
+            wave = self.wavelength
+            spec = np.interp(wave, wavelength, spectrum)
+        return wave, spec
+
+    def to_oldstyle(self):
+        obs = vars(self)
+        obs.update({k: self[v] for k, v in self.alias.items()})
+        _ = [obs.pop(k) for k in ["flux", "uncertainty"]]
+        return obs

From 501d9525f8cb62fc2ab3c9c19ce55488716b8c3d Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 1 Feb 2022 14:05:01 -0500
Subject: [PATCH 021/132] Working basic predictions with multiple spectra. Also
 add logic for caching emission line variances from MLE.

---
 prospect/models/sedmodel.py   | 105 +++++++++++++++++++---------------
 prospect/utils/observation.py |  14 +++++
 tests/test_predict.py         |  63 ++++++++++++++++++++
 3 files changed, 135 insertions(+), 47 deletions(-)
 create mode 100644 tests/test_predict.py

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index c41649c9..d92be6cc 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -41,6 +41,8 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.init_eline_info()
 
+        self.parse_elines()
+
     def _available_parameters(self):
         new_pars = [("sigma_smooth", ""),
                     ("marginalize_elines", ""),
@@ -51,26 +53,24 @@ def _available_parameters(self):
                     ("eline_sigma", ""),
                     ("use_eline_priors", ""),
                     ("eline_prior_width", "")]
-        relevant_pars = [("mass", ""),
-                         ("lumdist", ""),
-                         ("zred", ""),
-                         ("nebemlineinspec", ""),
-                         ("add_neb_emission")]
+
+        referenced_pars = [("mass", ""),
+                           ("lumdist", ""),
+                           ("zred", ""),
+                           ("nebemlineinspec", ""),
+                           ("add_neb_emission")]
 
         return new_pars
 
-    def predict(self, theta, obs=None, sps=None, sigma_spec=None, **extras):
+    def predict(self, theta, obslist=None, sps=None, sigma_spec=None, **extras):
         """Given a ``theta`` vector, generate a spectrum, photometry, and any
         extras (e.g. stellar mass), including any calibration effects.
 
         :param theta:
             ndarray of parameter values, of shape ``(ndim,)``
 
-        :param obs:
-            An observation dictionary, containing the output wavelength array,
-            the photometric filter lists, and the observed fluxes and
-            uncertainties thereon.  Assumed to be the result of
-            :py:func:`utils.obsutils.rectify_obs`
+        :param obslist:
+            A list of `Observation` instances.
 
         :param sps:
             An `sps` object to be used in the model generation.  It must have
@@ -80,14 +80,17 @@ def predict(self, theta, obs=None, sps=None, sigma_spec=None, **extras):
             The covariance matrix for the spectral noise. It is only used for
             emission line marginalization.
 
-        :returns spec:
-            The model spectrum for these parameters, at the wavelengths
-            specified by ``obs['wavelength']``, including multiplication by the
-            calibration vector.  Units of maggies
+        :returns predictions: (list of ndarrays)
+            List of predictions for the given list of observations.
 
-        :returns phot:
-            The model photometry for these parameters, for the filters
-            specified in ``obs['filters']``.  Units of maggies.
+            If the observation kind is "spectrum" then this is the model spectrum for these
+            parameters, at the wavelengths specified by ``obs['wavelength']``,
+            including multiplication by the calibration vector.  Units of
+            maggies
+
+            If the observation kind is "photometry" then this is the model
+            photometry for these parameters, for the filters specified in
+            ``obs['filters']``.  Units of maggies.
 
         :returns extras:
             Any extra aspects of the model that are returned.  Typically this
@@ -103,15 +106,28 @@ def predict(self, theta, obs=None, sps=None, sigma_spec=None, **extras):
         # Flux normalize
         self._norm_spec = self._spec * self.flux_norm()
 
-        # generate spectrum and photometry for likelihood
-        # predict_spec should be called before predict_phot
-        # because in principle it can modify the emission line parameters
-        # and also needs some things done in 'cache_eline_parameters`
-        # especially _ewave_obs and _use_elines
-        spec = self.predict_spec(obs, sigma_spec=sigma_spec)
-        phot = self.predict_phot(obs.get('filters', None))
+        # cache eline observed wavelengths
+        eline_z = self.params.get("eline_delta_zred", 0.0)
+        self._ewave_obs = (1 + eline_z + self._zred) * self._eline_wave
+        # cache eline mle info
+        self._ln_eline_penalty = 0
+        self._eline_lum_var = np.zeros_like(self._eline_wave)
+
+        # generate predictions for likelihood
+        # this assumes all spectral datasets (if present) occur first
+        # because they can change the line strengths during marginalization.
+        predictions = [self.predict_one(obs, sigma_spec=sigma_spec)
+                       for obs in obslist]
 
-        return spec, phot, self._mfrac
+        return predictions, self._mfrac
+
+    def predict_one(self, obs, sigma_spec=None):
+        self.cache_eline_parameters(obs)
+        if obs.kind == "spectrum":
+            prediction = self.predict_spec(obs, sigma_spec)
+        elif obs.kind == "photometry":
+            prediction = self.predict_phot(obs["filters"])
+        return prediction
 
     def predict_spec(self, obs, sigma_spec=None, **extras):
         """Generate a prediction for the observed spectrum.  This method assumes
@@ -139,10 +155,9 @@ def predict_spec(self, obs, sigma_spec=None, **extras):
         ``cache_eline_parameters()`` and ``fit_el()`` for details.)
 
         :param obs:
-            An observation dictionary, containing the output wavelength array,
-            the photometric filter lists, and the observed fluxes and
-            uncertainties thereon.  Assumed to be the result of
-            :py:meth:`utils.obsutils.rectify_obs`
+            An instance of `Spectrum`, containing the output wavelength array,
+            the observed fluxes and uncertainties thereon.  Assumed to be the
+            result of :py:meth:`utils.obsutils.rectify_obs`
 
         :param sigma_spec: (optional)
             The covariance matrix for the spectral noise. It is only used for
@@ -160,9 +175,6 @@ def predict_spec(self, obs, sigma_spec=None, **extras):
         if self._outwave is None:
             self._outwave = obs_wave
 
-        # --- cache eline parameters ---
-        self.cache_eline_parameters(obs)
-
         # --- smooth and put on output wavelength grid ---
         smooth_spec = self.smoothspec(obs_wave, self._norm_spec)
 
@@ -340,29 +352,21 @@ def cache_eline_parameters(self, obs, nsigma=5, forcelines=False):
         redshift - first looks for ``eline_delta_zred``, and defaults to ``zred``
         sigma - first looks for ``eline_sigma``, defaults to 100 km/s
 
+        N.B. This must be run separately for each `Observation` instance at each
+        likelihood call!!!
+
+        param
+
         :param nsigma: (float, optional, default: 5.)
             Number of sigma from a line center to use for defining which lines
             to fit and useful spectral elements for the fitting.  float.
         """
-
-        # observed wavelengths
-        eline_z = self.params.get("eline_delta_zred", 0.0)
-        self._ewave_obs = (1 + eline_z + self._zred) * self._eline_wave
-        self._eline_lum_var = np.zeros_like(self._eline_wave)
-
-        # masks for lines to be treated in various ways.
-        # always run this becuase it's need for spec *and* phot if adding lines
-        # by hand
-        self.parse_elines()
-
         # exit gracefully if not adding lines.  We also exit if only fitting
         # photometry, for performance reasons
         hasspec = obs.get('spectrum', None) is not None
         if not (self._want_lines & self._need_lines & hasspec):
-            self._fit_eline = None
             self._fit_eline_pixelmask = np.array([], dtype=bool)
             self._fix_eline_pixelmask = np.array([], dtype=bool)
-            self._fix_eline = None
             return
 
         # observed linewidths
@@ -497,6 +501,7 @@ def fit_el(self, obs, calibrated_spec, sigma_spec=None):
             K = ln_mvn(alpha_hat, mean=alpha_hat, cov=sigma_alpha_hat)
 
         # Cache the ln-penalty
+        # FIXME this needs to be acumulated if there are multiple spectra
         self._ln_eline_penalty = K
 
         # Store fitted emission line luminosities in physical units
@@ -637,7 +642,10 @@ def absolute_rest_maggies(self, filters):
     def mean_model(self, theta, obs, sps=None, sigma=None, **extras):
         """Legacy wrapper around predict()
         """
-        return self.predict(theta, obs, sps=sps, sigma_spec=sigma, **extras)
+        from ..utils.observation import from_oldstyle
+        obslist = from_oldstyle(obs)
+        predictions, mfrac = self.predict(theta, obslist, sps=sps, sigma_spec=sigma, **extras)
+        return predictions[0], predictions[1], mfrac
 
 
 class PolySpecModel(SpecModel):
@@ -662,6 +670,9 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
         spectrum, conditional on all other parameters. If emission lines are
         being marginalized out, they are excluded from the least-squares fit.
 
+        :param obs:
+            Instance of `Spectrum`
+
         :returns cal:
            A polynomial given by :math:`\sum_{m=0}^M a_{m} * T_m(x)`.
         """
diff --git a/prospect/utils/observation.py b/prospect/utils/observation.py
index 02209de3..da159e8c 100644
--- a/prospect/utils/observation.py
+++ b/prospect/utils/observation.py
@@ -3,6 +3,8 @@
 import json
 import numpy as np
 
+__all__ = ["Observation", "Spectrum", "Photometry",
+           "from_oldstyle"]
 
 class NumpyEncoder(json.JSONEncoder):
     def default(self, obj):
@@ -36,6 +38,12 @@ def __getitem__(self, item):
         k = self.alias.get(item, item)
         return getattr(self, k)
 
+    def get(self, item, default):
+        try:
+            return self[item]
+        except(AttributeError):
+            return default
+
     def from_oldstyle(self, **kwargs):
         """Take an old-style obs dict and use it to populate the relevant
         attributes.
@@ -152,3 +160,9 @@ def to_oldstyle(self):
         obs.update({k: self[v] for k, v in self.alias.items()})
         _ = [obs.pop(k) for k in ["flux", "uncertainty"]]
         return obs
+
+
+def from_oldstyle(obs):
+    """Convert from an oldstyle dictionary to a list of observations
+    """
+    return [Spectrum().from_oldstyle(obs), Photometry().from_oldstyle(obs)]
\ No newline at end of file
diff --git a/tests/test_predict.py b/tests/test_predict.py
new file mode 100644
index 00000000..a14d6f20
--- /dev/null
+++ b/tests/test_predict.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+
+from sedpy.observate import load_filters
+from prospect.sources import CSPSpecBasis
+from prospect.models import SpecModel, templates
+from prospect.utils.observation import Spectrum, Photometry
+
+
+def build_model():
+    model_params = templates.TemplateLibrary["parametric_sfh"]
+    return SpecModel(model_params)
+
+
+def build_obs(multispec=True):
+    N = 1500 * (2 - multispec)
+    wmax = 7000
+    wsplit = wmax - N * multispec
+
+    filterlist = load_filters([f"sdss_{b}0" for b in "ugriz"])
+    Nf = len(filterlist)
+    phot = [Photometry(filters=filterlist, flux=np.ones(Nf), uncertainty=np.ones(Nf)/10)]
+    spec = [Spectrum(wavelength=np.linspace(4000, wsplit, N),
+                     flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                     mask=slice(None))]
+
+    if multispec:
+        spec += [Spectrum(wavelength=np.linspace(wsplit+1, wmax, N),
+                          flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                          mask=slice(None))]
+
+    obslist = spec + phot
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+def build_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+if __name__ == "__main__":
+    obslist_single = build_obs(multispec=False)
+    obslist = build_obs()
+    model = build_model()
+    sps = build_sps()
+
+    #sys.exit()
+    predictions_single, mfrac = model.predict(model.theta, obslist=obslist_single, sps=sps)
+    #sys.exit()
+    predictions, mfrac = model.predict(model.theta, obslist=obslist, sps=sps)
+
+    import matplotlib.pyplot as pl
+    fig, ax = pl.subplots()
+    ax.plot(obslist_single[0].wavelength, predictions_single[0])
+    for p, o in zip(predictions, obslist):
+        if o.kind == "photometry":
+            ax.plot(o.wavelength, p, "o")
+        else:
+            ax.plot(o.wavelength, p)
+

From dc3c71c095e789e468eb517810f0fb64232a3806 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 29 Apr 2022 10:58:28 -0400
Subject: [PATCH 022/132] Move noise models to observation objects.   Offloads
 likelihood computations to NoiseModel objects that are   attached to
 individual Observation instances.  Also updates lnprobfn   to handle lists of
 observations, and adds some docstrings and   rough tests.

fitting ubdates for observation lists; dosctring modernization.
---
 prospect/fitting/fitting.py        | 343 +++++++++++++----------------
 prospect/likelihood/likelihood.py  | 225 +++----------------
 prospect/likelihood/noise_model.py | 140 ++++++++++--
 prospect/models/sedmodel.py        |  73 +++---
 prospect/utils/observation.py      |  47 +++-
 tests/test_predict.py              |  28 ++-
 6 files changed, 390 insertions(+), 466 deletions(-)

diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index dfc19a7e..e14ee930 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -16,8 +16,7 @@
 from .minimizer import minimize_wrapper, minimizer_ball
 from .ensemble import run_emcee_sampler
 from .nested import run_dynesty_sampler
-from ..likelihood import lnlike_spec, lnlike_phot, chi_spec, chi_phot, write_log
-from ..utils.obsutils import fix_obs
+from ..likelihood.likelihood import compute_chi, compute_lnlike
 
 
 __all__ = ["lnprobfn", "fit_model",
@@ -25,67 +24,60 @@
            ]
 
 
-def lnprobfn(theta, model=None, obs=None, sps=None, noise=(None, None),
+<<<<<<< HEAD
+def lnprobfn(theta, model=None, observations=None, sps=None, noises=None,
              residuals=False, nested=False, negative=False, verbose=False):
+=======
+def lnprobfn(theta, model=None, observations=None, sps=None,
+             residuals=False, nested=False, verbose=False):
+>>>>>>> 5617c8c (fitting ubdates for observation lists; dosctring modernization.)
     """Given a parameter vector and optionally a dictionary of observational
     ata and a model object, return the matural log of the posterior. This
     requires that an sps object (and if using spectra and gaussian processes, a
     NoiseModel) be instantiated.
 
-    :param theta:
-        Input parameter vector, ndarray of shape (ndim,)
-
-    :param model:
-        SedModel model object, with attributes including ``params``, a
-        dictionary of model parameter state.  It must also have
-        :py:func:`prior_product`, and :py:func:`predict` methods
-        defined.
-
-    :param obs:
-        A dictionary of observational data.  The keys should be
-
-        + ``"wavelength"``  (angstroms)
-        + ``"spectrum"``    (maggies)
-        + ``"unc"``         (maggies)
-        + ``"maggies"``     (photometry in maggies)
-        + ``"maggies_unc"`` (photometry uncertainty in maggies)
-        + ``"filters"``     (:py:class:`sedpy.observate.FilterSet` or iterable of :py:class:`sedpy.observate.Filter`)
-        +  and optional spectroscopic ``"mask"`` and ``"phot_mask"`` (same
-           length as ``spectrum`` and ``maggies`` respectively, True means use
-           the data points)
-
-    :param sps:
-        A :py:class:`prospect.sources.SSPBasis` object or subclass thereof, or
-        any object with a ``get_spectrum`` method that will take a dictionary
-        of model parameters and return a spectrum, photometry, and ancillary
-        information.
-
-    :param noise: (optional, default: (None, None))
-        A 2-element tuple of :py:class:`prospect.likelihood.NoiseModel` objects.
-
-    :param residuals: (optional, default: False)
+    Parameters
+    ----------
+    theta :  ndarray of shape ``(ndim,)``
+        Input parameter vector
+
+    model : instance of the :py:class:`prospect.models.SedModel`
+        The model parameterization and parameter state. Must have
+        :py:meth:`predict()` defined
+
+    observations : A list of :py:class:`observation.Observation` instances
+        The data to be fit.
+
+    sps : instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
+        The object used to construct the basic physical spectral model.
+        Anything with a compatible :py:func:`get_galaxy_spectrum` can
+        be used here. It will be passed to ``lnprobfn``
+
+    residuals : bool (optional, default: False)
         A switch to allow vectors of :math:`\chi` values to be returned instead
         of a scalar posterior probability.  This can be useful for
         least-squares optimization methods. Note that prior probabilities are
         not included in this calculation.
 
-    :param nested: (optional, default: False)
+    nested : bool (optional, default: False)
         If ``True``, do not add the ln-prior probability to the ln-likelihood
         when computing the ln-posterior.  For nested sampling algorithms the
         prior probability is incorporated in the way samples are drawn, so
         should not be included here.
 
-    :param negative: (optiona, default: False)
+    negative: bool (optional, default: False)
         If ``True`` return the negative on the ln-probability for minimization
         purposes.
 
-    :returns lnp:
+    Returns
+    -------
+    lnp : float or ndarry of shape `(ndof,)`
         Ln-probability, unless ``residuals=True`` in which case a vector of
         :math:`\chi` values is returned.
     """
     if residuals:
-        lnnull = np.zeros(obs["ndof"]) - 1e18  # np.infty
-        #lnnull = -np.infty
+        ndof = np.sum([obs["ndof"] for obs in observations])
+        lnnull = np.zeros(ndof) - 1e18  # -np.infty
     else:
         lnnull = -np.infty
 
@@ -94,25 +86,16 @@ def lnprobfn(theta, model=None, obs=None, sps=None, noise=(None, None),
     if not np.isfinite(lnp_prior):
         return lnnull
 
-    #  --- Update Noise Model ---
-    spec_noise, phot_noise = noise
-    vectors, sigma_spec = {}, None
+    # set parameters
     model.set_parameters(theta)
-    if spec_noise is not None:
-        spec_noise.update(**model.params)
-        vectors.update({"unc": obs.get('unc', None)})
-        sigma_spec = spec_noise.construct_covariance(**vectors)
-    if phot_noise is not None:
-        phot_noise.update(**model.params)
-        vectors.update({'phot_unc': obs.get('maggies_unc', None),
-                        'phot': obs.get('maggies', None),
-                        'filter_names': obs.get('filter_names', None)})
+
+    #  --- Update Noise Model Parameters ---
+    [obs.noise.update(**model.params) for obs in observations
+     if obs.noise is not None]
 
     # --- Generate mean model ---
     try:
-        t1 = time.time()
-        spec, phot, x = model.predict(theta, obs, sps=sps, sigma_spec=sigma_spec)
-        d1 = time.time() - t1
+        predictions, x = model.predict(theta, observations, sps=sps)
     except(ValueError):
         return lnnull
     except:
@@ -122,78 +105,52 @@ def lnprobfn(theta, model=None, obs=None, sps=None, noise=(None, None),
     # --- Optionally return chi vectors for least-squares ---
     # note this does not include priors!
     if residuals:
-        chispec = chi_spec(spec, obs)
-        chiphot = chi_phot(phot, obs)
-        return np.concatenate([chispec, chiphot])
-
-    #  --- Mixture Model ---
-    f_outlier_spec = model.params.get('f_outlier_spec', 0.0)
-    if (f_outlier_spec != 0.0):
-        sigma_outlier_spec = model.params.get('nsigma_outlier_spec', 10)
-        vectors.update({'nsigma_outlier_spec': sigma_outlier_spec})
-    f_outlier_phot = model.params.get('f_outlier_phot', 0.0)
-    if (f_outlier_phot != 0.0):
-        sigma_outlier_phot = model.params.get('nsigma_outlier_phot', 10)
-        vectors.update({'nsigma_outlier_phot': sigma_outlier_phot})
+        chi = [compute_chi(spec, obs) for pred, obs in zip(predictions, observations)]
+        return np.concatenate(chi)
 
     # --- Emission Lines ---
+    lnp_eline = getattr(model, "_ln_eline_penalty", 0.0)
 
     # --- Calculate likelihoods ---
-    t1 = time.time()
-    lnp_spec = lnlike_spec(spec, obs=obs,
-                           f_outlier_spec=f_outlier_spec,
-                           spec_noise=spec_noise,
-                           **vectors)
-    lnp_phot = lnlike_phot(phot, obs=obs,
-                           f_outlier_phot=f_outlier_phot,
-                           phot_noise=phot_noise, **vectors)
-    lnp_eline = getattr(model, '_ln_eline_penalty', 0.0)
-
-    d2 = time.time() - t1
-    if verbose:
-        write_log(theta, lnp_prior, lnp_spec, lnp_phot, d1, d2)
-
-    lnp = lnp_prior + lnp_phot + lnp_spec + lnp_eline
+    lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs
+                in zip(predictions, observations)]
+
+    lnp = lnp_prior + np.sum(lnp_data) + lnp_eline
     if negative:
         lnp *= -1
 
     return lnp
 
 
-def wrap_lnp(lnpfn, obs, model, sps, **lnp_kwargs):
-    return argfix(lnpfn, obs=obs, model=model, sps=sps,
+def wrap_lnp(lnpfn, observations, model, sps, **lnp_kwargs):
+    return argfix(lnpfn, observations=observations, model=model, sps=sps,
                   **lnp_kwargs)
 
 
-def fit_model(obs, model, sps, noise=(None, None), lnprobfn=lnprobfn,
+def fit_model(observations, model, sps, lnprobfn=lnprobfn,
               optimize=False, emcee=False, dynesty=True, **kwargs):
     """Fit a model to observations using a number of different methods
 
-    :param obs:
-        The ``obs`` dictionary containing the data to fit to, which will be
-        passed to ``lnprobfn``.
+    Parameters
+    ----------
+    observations : list of :py:class:`observate.Observation` instances
+        The data to be fit.
 
-    :param model:
-        An instance of the :py:class:`prospect.models.SedModel` class
-        containing the model parameterization and parameter state.  It will be
+    model : instance of the :py:class:`prospect.models.SedModel`
+        The model parameterization and parameter state.  It will be
         passed to ``lnprobfn``.
 
-    :param sps:
-        An instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
-        Alternatively, anything with a compatible :py:func:`get_spectrum` can
+    sps : instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
+        The object used to construct the basic physical spectral model.
+        Anything with a compatible :py:func:`get_galaxy_spectrum` can
         be used here. It will be passed to ``lnprobfn``
 
-    :param noise: (optional, default: (None, None))
-        A tuple of NoiseModel objects for the spectroscopy and photometry
-        respectively.  Can also be (None, None) in which case simple chi-square
-        will be used.
-
-    :param lnprobfn: (optional, default: lnprobfn)
-        A posterior probability function that can take ``obs``, ``model``,
-        ``sps``, and ``noise`` as keywords. By default use the
+    lnprobfn : callable (optional, default: :py:meth:`lnprobfn`)
+        A posterior probability function that can take ``observations``,
+        ``model``, and ``sps`` as keywords. By default use the
         :py:func:`lnprobfn` defined above.
 
-    :param optimize: (optional, default: False)
+    optimize : bool (optional, default: False)
         If ``True``, conduct a round of optimization before sampling from the
         posterior.  The model state will be set to the best value at the end of
         optimization before continuing on to sampling or returning.  Parameters
@@ -207,7 +164,7 @@ def fit_model(obs, model, sps, noise=(None, None), lnprobfn=lnprobfn,
 
         See :py:func:`run_minimize` for details.
 
-    :param emcee:  (optional, default: False)
+    emcee : bool  (optional, default: False)
         If ``True``, sample from the posterior using emcee.  Additonal
         parameters controlling emcee can be passed via ``**kwargs``.  These include
 
@@ -217,18 +174,20 @@ def fit_model(obs, model, sps, noise=(None, None), lnprobfn=lnprobfn,
         Many additional emcee parameters can be provided here, see
         :py:func:`run_emcee` for details.
 
-    :param dynesty:
+    dynesty : bool (optional, default: True)
         If ``True``, sample from the posterior using dynesty.  Additonal
         parameters controlling dynesty can be passed via ``**kwargs``. See
         :py:func:`run_dynesty` for details.
 
-    :returns output:
+    Returns
+    -------
+    output : dictionary
         A dictionary with two keys, ``"optimization"`` and ``"sampling"``.  The
         value of each of these is a 2-tuple with results in the first element
         and durations (in seconds) in the second element.
     """
     # Make sure obs has required keys
-    obs = fix_obs(obs)
+    [obs.rectify() for obs in observations]
 
     if emcee & dynesty:
         msg = ("Cannot run both emcee and dynesty fits "
@@ -243,7 +202,7 @@ def fit_model(obs, model, sps, noise=(None, None), lnprobfn=lnprobfn,
               "sampling": (None, 0.)}
 
     if optimize:
-        optres, topt, best = run_minimize(obs, model, sps, noise,
+        optres, topt, best = run_minimize(observations, model, sps,
                                           lnprobfn=lnprobfn, **kwargs)
         # set to the best
         model.set_parameters(optres[best].x)
@@ -256,63 +215,61 @@ def fit_model(obs, model, sps, noise=(None, None), lnprobfn=lnprobfn,
     else:
         return output
 
-    output["sampling"] = run_sampler(obs, model, sps, noise,
+    output["sampling"] = run_sampler(observations, model, sps,
                                      lnprobfn=lnprobfn, **kwargs)
     return output
 
 
-def run_minimize(obs=None, model=None, sps=None, noise=None, lnprobfn=lnprobfn,
+def run_minimize(observations=None, model=None, sps=None, lnprobfn=lnprobfn,
                  min_method='lm', min_opts={}, nmin=1, pool=None, **extras):
     """Run a minimization.  This wraps the lnprobfn fixing the ``obs``,
     ``model``, ``noise``, and ``sps`` objects, and then runs a minimization of
     -lnP using scipy.optimize methods.
 
-    :param obs:
-        The ``obs`` dictionary containing the data to fit to, which will be
-        passed to ``lnprobfn``.
+    Parameters
+    ----------
+    observations : list of :py:class:`observate.Observation` instances
+        The data to be fit.
 
-    :param model:
-        An instance of the :py:class:`prospect.models.SedModel` class
-        containing the model parameterization and parameter state.  It will be
+    model : instance of the :py:class:`prospect.models.SedModel`
+        The model parameterization and parameter state.  It will be
         passed to ``lnprobfn``.
 
-    :param sps:
-        An instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
-        Alternatively, anything with a compatible :py:func:`get_spectrum` can
+    sps : instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
+        The object used to construct the basic physical spectral model.
+        Anything with a compatible :py:func:`get_galaxy_spectrum` can
         be used here. It will be passed to ``lnprobfn``
 
-    :param noise: (optional)
-        If given, a tuple of :py:class:`NoiseModel` objects passed to
-        ``lnprobfn``.
-
-    :param lnprobfn: (optional, default: lnprobfn)
-        A posterior probability function that can take ``obs``, ``model``,
-        ``sps``, and ``noise`` as keywords. By default use the
+    lnprobfn : callable (optional, default: :py:meth:`lnprobfn`)
+        A posterior probability function that can take ``observations``,
+        ``model``, and ``sps`` as keywords. By default use the
         :py:func:`lnprobfn` defined above.
 
-    :param min_method: (optional, default: 'lm')
+    min_method : string (optional, default: 'lm')
         Method to use for minimization
         * 'lm': Levenberg-Marquardt
         * 'powell': Powell line search method
 
-    :param nmin: (optional, default: 1)
+    nmin : int (optional, default: 1)
         Number of minimizations to do.  Beyond the first, minimizations will be
         started from draws from the prior.
 
-    :param min_opts: (optional, default: {})
+    min_opts : dict (optional, default: {})
         Dictionary of minimization options passed to the scipy.optimize method.
         These include things like 'xtol', 'ftol', etc..
 
-    :param pool: (optional, default: None)
+    pool : object (optional, default: None)
         A pool to use for parallel optimization from multiple initial positions.
 
-    :returns results:
+    Returns
+    -------
+    results :
         A list of `scipy.optimize.OptimizeResult` objects.
 
-    :returns tm:
+    t_wall : float
         Wall time used for the minimization, in seconds.
 
-    :returns best:
+    best : int
         The index of the results list containing the lowest chi-square result.
     """
     initial = model.theta.copy()
@@ -330,8 +287,12 @@ def run_minimize(obs=None, model=None, sps=None, noise=None, lnprobfn=lnprobfn,
         residuals = False
 
     args = []
+<<<<<<< HEAD
     loss = argfix(lnprobfn, obs=obs, model=model, sps=sps,
                   noise=noise, residuals=residuals, negative=True)
+=======
+    loss = argfix(lnprobfn, observations=observations, model=model, sps=sps, residuals=residuals)
+>>>>>>> 5617c8c (fitting ubdates for observation lists; dosctring modernization.)
     minimizer = minimize_wrapper(algorithm, loss, [], min_method, min_opts)
     qinit = minimizer_ball(initial, nmin, model)
 
@@ -353,60 +314,54 @@ def run_minimize(obs=None, model=None, sps=None, noise=None, lnprobfn=lnprobfn,
     return results, tm, best
 
 
-def run_emcee(obs, model, sps, noise, lnprobfn=lnprobfn,
-              hfile=None, initial_positions=None,
-              **kwargs):
+def run_emcee(observations, model, sps, lnprobfn=lnprobfn,
+              hfile=None, initial_positions=None, **kwargs):
     """Run emcee, optionally including burn-in and convergence checking.  Thin
     wrapper on :py:class:`prospect.fitting.ensemble.run_emcee_sampler`
 
-    :param obs:
-        The ``obs`` dictionary containing the data to fit to, which will be
-        passed to ``lnprobfn``.
+    Parameters
+    ----------
+    observations : list of :py:class:`observate.Observation` instances
+        The data to be fit.
 
-    :param model:
-        An instance of the :py:class:`prospect.models.SedModel` class
-        containing the model parameterization and parameter state.  It will be
+    model : instance of the :py:class:`prospect.models.SedModel`
+        The model parameterization and parameter state.  It will be
         passed to ``lnprobfn``.
 
-    :param sps:
-        An instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
-        Alternatively, anything with a compatible :py:func:`get_spectrum` can
+    sps : instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
+        The object used to construct the basic physical spectral model.
+        Anything with a compatible :py:func:`get_galaxy_spectrum` can
         be used here. It will be passed to ``lnprobfn``
 
-    :param noise:
-        A tuple of :py:class:`NoiseModel` objects passed to ``lnprobfn``.
-
-    :param lnprobfn: (optional, default: lnprobfn)
-        A posterior probability function that can take ``obs``, ``model``,
-        ``sps``, and ``noise`` as keywords. By default use the
+    lnprobfn : callable (optional, default: :py:meth:`lnprobfn`)
+        A posterior probability function that can take ``observations``,
+        ``model``, and ``sps`` as keywords. By default use the
         :py:func:`lnprobfn` defined above.
 
-    :param hfile: (optional, default: None)
+    hfile : :py:class:`h5py.File()` instance (optional, default: None)
         A file handle for a :py:class:`h5py.File` object that will be written
         to incremantally during sampling.
 
-    :param initial_positions: (optional, default: None)
-        If given, a set of initial positions for the emcee walkers.  Must have
-        shape (nwalkers, ndim).  Rounds of burn-in will be skipped if this
-        parameter is present.
+    initial_positions : ndarray of shape ``(nwalkers, ndim)`` (optional, default: None)
+        If given, a set of initial positions for the emcee walkers.  Rounds of
+        burn-in will be skipped if this parameter is present.
 
     Extra Parameters
     --------
-
-    :param nwalkers:
+    nwalkers : int
         The number of walkers to use.  If None, use the nearest power of two to
         ``ndim * walker_factor``.
 
-    :param niter:
+    niter : int
         Number of iterations for the production run
 
-    :param nburn:
+    nburn : list of int
         List of the number of iterations to run in each round of burn-in (for
         removing stuck walkers.) E.g. `nburn=[32, 64]` will run the sampler for
         32 iterations before reinitializing and then run the sampler for
         another 64 iterations before starting the production run.
 
-    :param storechain: (default: True)
+    storechain : bool (default: True)
         If using HDF5 output, setting this to False will keep the chain from
         being held in memory by the sampler object.
 
@@ -432,19 +387,17 @@ def run_emcee(obs, model, sps, noise, lnprobfn=lnprobfn,
 
     Returns
     --------
-
-    :returns sampler:
+    sampler :
         An instance of :py:class:`emcee.EnsembleSampler`.
 
-    :returns ts:
+    t_wall : float
         Duration of sampling (including burn-in) in seconds of wall time.
     """
     q = model.theta.copy()
 
-    postkwargs = {"obs": obs,
+    postkwargs = {"observations": observations,
                   "model": model,
                   "sps": sps,
-                  "noise": noise,
                   "nested": False,
                   }
 
@@ -467,62 +420,62 @@ def run_emcee(obs, model, sps, noise, lnprobfn=lnprobfn,
     return sampler, ts
 
 
+<<<<<<< HEAD
 def run_dynesty(obs, model, sps, noise, lnprobfn=lnprobfn,
                 pool=None, nested_target_n_effective=10000, **kwargs):
+=======
+def run_dynesty(obs, model, sps, lnprobfn=lnprobfn,
+                pool=None, nested_posterior_thresh=0.05, **kwargs):
+>>>>>>> 5617c8c (fitting ubdates for observation lists; dosctring modernization.)
     """Thin wrapper on :py:class:`prospect.fitting.nested.run_dynesty_sampler`
 
-    :param obs:
-        The ``obs`` dictionary containing the data to fit to, which will be
-        passed to ``lnprobfn``.
+    Parameters
+    ----------
+    observations : list of :py:class:`observate.Observation` instances
+        The data to be fit.
 
-    :param model:
-        An instance of the :py:class:`prospect.models.SedModel` class
-        containing the model parameterization and parameter state.  It will be
+    model : instance of the :py:class:`prospect.models.SedModel`
+        The model parameterization and parameter state.  It will be
         passed to ``lnprobfn``.
 
-    :param sps:
-        An instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
-        Alternatively, anything with a compatible :py:func:`get_spectrum` can
+    sps : instance of a :py:class:`prospect.sources.SSPBasis` (sub-)class.
+        The object used to construct the basic physical spectral model.
+        Anything with a compatible :py:func:`get_galaxy_spectrum` can
         be used here. It will be passed to ``lnprobfn``
 
-    :param noise:
-        A tuple of :py:class:`prospect.likelihood.NoiseModel` objects passed to
-        ``lnprobfn``.
-
-    :param lnprobfn: (optional, default: :py:func:`lnprobfn`)
-        A posterior probability function that can take ``obs``, ``model``,
-        ``sps``, and ``noise`` as keywords. This function must also take a
-        ``nested`` keyword.
+    lnprobfn : callable (optional, default: :py:meth:`lnprobfn`)
+        A posterior probability function that can take ``observations``,
+        ``model``, and ``sps`` as keywords. By default use the
+        :py:func:`lnprobfn` defined above.
 
     Extra Parameters
     --------
-    :param nested_bound: (optional, default: 'multi')
+    nested_bound: (optional, default: 'multi')
 
-    :param nested_sample: (optional, default: 'unif')
+    nested_sample: (optional, default: 'unif')
 
-    :param nested_nlive_init: (optional, default: 100)
+    nested_nlive_init: (optional, default: 100)
 
-    :param nested_nlive_batch: (optional, default: 100)
+    nested_nlive_batch: (optional, default: 100)
 
-    :param nested_dlogz_init: (optional, default: 0.02)
+    nested_dlogz_init: (optional, default: 0.02)
 
-    :param nested_maxcall: (optional, default: None)
+    nested_maxcall: (optional, default: None)
 
-    :param nested_walks: (optional, default: 25)
+    nested_walks: (optional, default: 25)
 
     Returns
     --------
-
-    :returns result:
+    result:
         An instance of :py:class:`dynesty.results.Results`.
 
-    :returns ts:
+    t_wall : float
         Duration of sampling in seconds of wall time.
     """
     from dynesty.dynamicsampler import stopping_function, weight_function
     nested_stop_kwargs = {"target_n_effective": nested_target_n_effective}
 
-    lnp = wrap_lnp(lnprobfn, obs, model, sps, noise=noise,
+    lnp = wrap_lnp(lnprobfn, observations, model, sps, noise=noise,
                    nested=True)
 
     # Need to deal with postkwargs...
diff --git a/prospect/likelihood/likelihood.py b/prospect/likelihood/likelihood.py
index 1b648cde..590723fe 100644
--- a/prospect/likelihood/likelihood.py
+++ b/prospect/likelihood/likelihood.py
@@ -1,217 +1,48 @@
+# -*- coding: utf-8 -*-
+
 import time, sys, os
 import numpy as np
 from scipy.linalg import LinAlgError
 
-__all__ = ["lnlike_spec", "lnlike_phot", "chi_spec", "chi_phot", "write_log"]
-
-
-def lnlike_spec(spec_mu, obs=None, spec_noise=None, f_outlier_spec=0.0, **vectors):
-    """Calculate the likelihood of the spectroscopic data given the
-    spectroscopic model.  Allows for the use of a gaussian process
-    covariance matrix for multiplicative residuals.
-
-    :param spec_mu:
-        The mean model spectrum, in linear or logarithmic units, including
-        e.g. calibration and sky emission.
-
-    :param obs: (optional)
-        A dictionary of the observational data, including the keys
-        *``spectrum`` a numpy array of the observed spectrum, in linear or
-         logarithmic units (same as ``spec_mu``).
-        *``unc`` the uncertainty of same length as ``spectrum``
-        *``mask`` optional boolean array of same length as ``spectrum``
-        *``wavelength`` if using a GP, the metric that is used in the
-         kernel generation, of same length as ``spectrum`` and typically
-         giving the wavelength array.
+from .noise_model import NoiseModel
 
-    :param spec_noise: (optional)
-        A NoiseModel object with the methods `compute` and `lnlikelihood`.
-        If ``spec_noise`` is supplied, the `wavelength` entry in the obs
-        dictionary must exist.
+__all__ = ["compute_lnlike", "compute_chi"]
 
-    :param f_outlier_spec: (optional)
-        The fraction of spectral pixels which are considered outliers
-        by the mixture model
 
-    :param vectors: (optional)
-        A dictionary of vectors of same length as ``wavelength`` giving
-        possible weghting functions for the kernels
-
-    :returns lnlikelhood:
-        The natural logarithm of the likelihood of the data given the mean
-        model spectrum.
-    """
-    if obs['spectrum'] is None:
-        return 0.0
+basic_noise_model = NoiseModel()
 
-    mask = obs.get('mask', slice(None))
-    vectors['mask'] = mask
-    vectors['wavelength'] = obs['wavelength']
 
-    delta = (obs['spectrum'] - spec_mu)[mask]
-    var = (obs['unc'][mask])**2
+def compute_lnlike(pred, obs, vectors={}):
+    """Calculate the likelihood of the observational data given the
+    prediction.  This is a very thin wrapper on the noise model that should be
+    attached to each Observation instance.
 
-    if spec_noise is not None:
-        try:
-            spec_noise.compute(**vectors)
-            if (f_outlier_spec == 0.0):
-                return spec_noise.lnlikelihood(spec_mu[mask], obs['spectrum'][mask])
-
-            # disallow (correlated noise model + mixture model)
-            # and redefine errors
-            assert spec_noise.Sigma.ndim == 1
-            var = spec_noise.Sigma
-
-        except(LinAlgError):
-            return np.nan_to_num(-np.inf)
-
-    lnp = -0.5*( (delta**2/var) + np.log(2*np.pi*var) )
-    if (f_outlier_spec == 0.0):
-        return lnp.sum()
-    else:
-        var_bad = var * (vectors["nsigma_outlier_spec"]**2)
-        lnp_bad = -0.5*( (delta**2/var_bad) + np.log(2*np.pi*var_bad) )
-        lnp_tot = np.logaddexp(lnp + np.log(1-f_outlier_spec), lnp_bad + np.log(f_outlier_spec))
-
-        return lnp_tot.sum()
-
-
-def lnlike_phot(phot_mu, obs=None, phot_noise=None, f_outlier_phot=0.0, **vectors):
-    """Calculate the likelihood of the photometric data given the spectroscopic
-    model.  Allows for the use of a gaussian process covariance matrix.
-
-    :param phot_mu:
-        The mean model sed, in linear flux units (i.e. maggies).
+    :param pred:
+        The predicted data, including calibration.
 
     :param obs: (optional)
-        A dictionary of the observational data, including the keys
-          *``maggies`` a numpy array of the observed SED, in linear flux
-           units
-          *``maggies_unc`` the uncertainty of same length as ``maggies``
-          *``phot_mask`` optional boolean array of same length as
-           ``maggies``
-          *``filters`` optional list of sedpy.observate.Filter objects,
-           necessary if using fixed filter groups with different gp
-           amplitudes for each group.
-       If not supplied then the obs dictionary given at initialization will
-       be used.
-
-    :param phot_noise: (optional)
-        A ``prospect.likelihood.NoiseModel`` object with the methods
-        ``compute()`` and ``lnlikelihood()``.  If not supplied a simple chi^2
-        likelihood will be evaluated.
-
-    :param f_outlier_phot: (optional)
-        The fraction of photometric bands which are considered outliers
-        by the mixture model
+        Instance of observation.Observation() or subclass thereof.
 
-    :param vectors:
-        A dictionary of possibly relevant vectors of same length as maggies
-        that will be passed to the NoiseModel object for constructing weighted
-        covariance matrices.
-
-    :returns lnlikelhood:
-        The natural logarithm of the likelihood of the data given the mean
-        model spectrum.
+    :param vectors: (optional)
+        A dictionary of vectors of same length as ``obs.wavelength`` giving
+        possible weghting functions for the kernels
     """
-    if obs['maggies'] is None:
-        return 0.0
-
-    mask = obs.get('phot_mask', slice(None))
-    delta = (obs['maggies'] - phot_mu)[mask]
-    var = (obs['maggies_unc'][mask])**2
-    psamples = obs.get('phot_samples', None)
-
-    if phot_noise is not None:
-        try:
-            filternames = obs['filters'].filternames
-        except(AttributeError):
-            filternames = [f.name for f in obs['filters']]
-        vectors['mask'] = mask
-        vectors['filternames'] = np.array(filternames)
-        vectors['phot_samples'] = psamples
-        try:
-            phot_noise.compute(**vectors)
-            if (f_outlier_phot == 0.0):
-                return phot_noise.lnlikelihood(phot_mu[mask], obs['maggies'][mask])
-
-            # disallow (correlated noise model + mixture model)
-            # and redefine errors
-            assert phot_noise.Sigma.ndim == 1
-            var = phot_noise.Sigma
-
-        except(LinAlgError):
-            return np.nan_to_num(-np.inf)
-
-    # simple noise model
-    lnp = -0.5*( (delta**2/var) + np.log(2*np.pi*var) )
-    if (f_outlier_phot == 0.0):
-        return lnp.sum()
-    else:
-        var_bad = var * (vectors["nsigma_outlier_phot"]**2)
-        lnp_bad = -0.5*( (delta**2/var_bad) + np.log(2*np.pi*var_bad) )
-        lnp_tot = np.logaddexp(lnp + np.log(1-f_outlier_phot), lnp_bad + np.log(f_outlier_phot))
-
-        return lnp_tot.sum()
-
+    try:
+        return obs.noise.lnlike(pred, obs, vectors=vectors)
+    except:
+        return basic_noise_model.lnlike(pred, obs, vectors=vectors)
 
-def chi_phot(phot_mu, obs, **extras):
-    """Return a vector of chi values, for use in non-linear least-squares
-    algorithms.
 
-    :param phot_mu:
-        Model photometry, same units as the photometry in `obs`.
-
-    :param obs:
-        An observational data dictionary, with the keys ``"maggies"`` and
-        ``"maggies_unc"``.  If ``"maggies"`` is None then an empty array is
-        returned.
-
-    :returns chi:
-        An array of noise weighted residuals, same length as the number of
-        unmasked phtometric points.
+def compute_chi(pred, obs):
     """
-    if obs['maggies'] is None:
-        return np.array([])
-
-    mask = obs.get('phot_mask', slice(None))
-    delta = (obs['maggies'] - phot_mu)[mask]
-    unc = obs['maggies_unc'][mask]
-    chi = delta / unc
-    return chi
-
-
-def chi_spec(spec_mu, obs, **extras):
-    """Return a vector of chi values, for use in non-linear least-squares
-    algorithms.
+    Parameters
+    ----------
+    pred : ndarray of shape (ndata,)
+        The model prediction for this observation
 
-    :param spec_mu:
-        Model spectroscopy, same units as the photometry in `obs`.
-
-    :param obs:
-        An observational data dictionary, with the keys ``"spectrum"`` and
-        ``"unc"``.  If ``"spectrum"`` is None then an empty array is returned.
-        Optinally a ``"mask"`` boolean vector may be supplied that will be used
-        to index the residual vector.
-
-    :returns chi:
-        An array of noise weighted residuals, same length as the number of
-        unmasked spectroscopic points.
+    obs : instance of Observation()
+        The observational data
     """
-    if obs['spectrum'] is None:
-        return np.array([])
-    mask = obs.get('mask', slice(None))
-    delta = (obs['spectrum'] - spec_mu)[mask]
-    unc = obs['unc'][mask]
-    chi = delta / unc
-    return chi
+    chi = (pred - obs.flux) / obs.uncertainty
+    return chi[obs.mask]
 
-
-def write_log(theta, lnp_prior, lnp_spec, lnp_phot, d1, d2):
-    """Write all sorts of documentary info for debugging.
-    """
-    print(theta)
-    print('model calc = {0}s, lnlike calc = {1}'.format(d1, d2))
-    fstring = 'lnp = {0}, lnp_spec = {1}, lnp_phot = {2}'
-    values = [lnp_spec + lnp_phot + lnp_prior, lnp_spec, lnp_phot]
-    print(fstring.format(*values))
diff --git a/prospect/likelihood/noise_model.py b/prospect/likelihood/noise_model.py
index 02f155a3..1f6b18de 100644
--- a/prospect/likelihood/noise_model.py
+++ b/prospect/likelihood/noise_model.py
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+
 import numpy as np
 from scipy.linalg import cho_factor, cho_solve
 try:
@@ -5,21 +7,104 @@
 except(ImportError):
     pass
 
-__all__ = ["NoiseModel", "NoiseModelKDE"]
+__all__ = ["NoiseModel", "NoiseModelCov", "NoiseModelKDE"]
+
+
+class NoiseModel:
+
+    """This class allows for 1-d covariance matrix noise models without any
+    special kernels for covariance matrix construction.
+    """
+
+    f_outlier = 0
+    n_sigma_outlier = 50
+
+    def __init__(self, f_outlier_name="f_outlier", n_sigma_name="nsigma_outlier"):
+        self.f_outlier_name = f_outlier_name
+        self.n_sigma_name = n_sigma_name
+        self.kernels = []
+
+    def update(self, **params):
+        self.f_outlier = params.get(self.f_outlier_name, 0)
+        self.n_sigma_outlier = params.get(self.n_sigma_name, 50)
+        [k.update(**params) for k in self.kernels]
+
+    def lnlike(self, pred, obs, vectors={}):
+
+        # Construct Sigma (and factorize if 2d)
+        vectors = self.populate_vectors(obs)
+        self.compute(**vectors)
+
+        # Compute likelihood
+        if (self.f_outlier == 0.0):
+            # Let the noise model do it
+            lnp = self.lnlikelihood(pred[obs.mask], obs.flux[obs.mask])
+            return lnp
+        elif self.f_outlier > 0:
+            # Use the noise model variance, but otherwise compute on our own
+            assert self.Sigma.ndim == 1, "Outlier modeling only available for uncorrelated errors"
+            delta = obs.flux[obs.mask] - pred[obs.mask]
+            var = self.Sigma
+            lnp = -0.5*((delta**2 / var) + np.log(2*np.pi*var))
+            var_bad = var * (self.n_sigma_outlier**2)
+            lnp_bad = -0.5*((delta**2 / var_bad) + np.log(2*np.pi*var_bad))
+            lnp_tot = np.logaddexp(lnp + np.log(1 - self.f_outlier), lnp_bad + np.log(self.f_outlier))
+            return lnp_tot
+        else:
+            raise ValueError("f_outlier must be >= 0")
+
+    def populate_vectors(self, obs, vectors={}):
+        # update vectors
+        vectors["mask"] = obs.mask
+        vectors["unc"] = obs.uncertainty
+        if obs.kind == "photometry":
+            vectors["filternames"] = obs.filternames
+            vectors["phot_samples"] = obs.get("phot_samples", None)
+        return vectors
+
+    def construct_covariance(self, unc=[], mask=slice(None), **vectors):
+        self.Sigma = np.atleast_1d(unc[mask]**2)
+
+    def compute(self, **vectors):
+        """Make a boring diagonal Covariance array
+        """
+        self.construct_covariance(**vectors)
+        self.log_det = np.sum(np.log(self.Sigma))
+
+    def lnlikelihood(self, pred, data):
+        """Simple ln-likihood for diagonal covariance matrix.
+        """
+        delta = data - pred
+        lnp = -0.5*(np.dot(delta**2, np.log(2*np.pi) / self.Sigma) +
+                    self.log_det)
+        return lnp.sum()
+
 
+class NoiseModelCov(NoiseModel):
+    """This object allows for 1d or 2d covariance matrices constructed from kernels
+    """
 
-class NoiseModel(object):
+    def __init__(self, f_outlier_name="f_outlier", n_sigma_name="nsigma_outlier",
+                 metric_name='', mask_name='mask', kernels=[], weight_by=[]):
 
-    def __init__(self, metric_name='', mask_name='mask', kernels=[],
-                 weight_by=[]):
+        super().__init__(f_outlier_name=f_outlier_name,
+                         n_sigma_name=n_sigma_name)
         assert len(kernels) == len(weight_by)
         self.kernels = kernels
         self.weight_names = weight_by
         self.metric_name = metric_name
         self.mask_name = mask_name
 
-    def update(self, **params):
-        [k.update(**params) for k in self.kernels]
+    def populate_vectors(self, vectors, obs):
+        # update vectors
+        vectors["mask"] = obs.mask
+        vectors["wavelength"] = obs.wavelength
+        vectors["unc"] = obs.uncertainty
+        vectors["flux"] = obs.flux
+        if obs.kind == "photometry":
+            vectors["filternames"] = obs.filternames
+            vectors["phot_samples"] = obs.get("phot_samples", None)
+        return vectors
 
     def construct_covariance(self, **vectors):
         """Construct a covariance matrix from a metric, a list of kernel
@@ -58,38 +143,45 @@ def compute(self, check_finite=False, **vectors):
         and cache that.  Also cache ``log_det``.
         """
         self.Sigma = self.construct_covariance(**vectors)
-        if self.Sigma.ndim > 1:
-            self.factorized_Sigma = cho_factor(self.Sigma, overwrite_a=True,
-                                               check_finite=check_finite)
+        if self.Sigma.ndim == 1:
+            self.log_det = np.sum(np.log(self.Sigma))
+        else:
+            self.factorized_Sigma = cho_factor(self.Sigma, overwrite_a=True, check_finite=check_finite)
             self.log_det = 2 * np.sum(np.log(np.diag(self.factorized_Sigma[0])))
             assert np.isfinite(self.log_det)
-        else:
-            self.log_det = np.sum(np.log(self.Sigma))
 
-    def lnlikelihood(self, phot_mu, phot_obs, check_finite=False, **extras):
-        """Compute the ln of the likelihood, using the current factorized
-        covariance matrix.
+    def lnlikelihood(self, prediction, data, check_finite=False):
+        """Compute the ln of the likelihood, using the current cached (and
+        factorized if non-diagonal) covariance matrix.
 
-        :param phot_mu:
-            Model photometry, same units as the photometry in `phot_obs`.
-        :param phot_obs:
-            Observed photometry, in linear flux units (i.e. maggies).
+        Parameters
+        ----------
+        prediction : ndarray of float
+            Model flux, same units as `data`.
+
+        data : ndarray of float
+            Observed flux, in linear flux units (i.e. maggies).
+
+        Returns
+        -------
+        lnlike : float
+            The likelihood fo the data
         """
-        residual = phot_obs - phot_mu
+        residual = data - prediction
         n = len(residual)
         assert n == self.Sigma.shape[0]
-        if self.Sigma.ndim > 1:
-            first_term = np.dot(residual, cho_solve(self.factorized_Sigma,
-                                residual, check_finite=check_finite))
+        if self.Sigma.ndim == 1:
+            first_term = np.dot(residual**2, 1.0 / self.Sigma)
         else:
-            first_term = np.dot(residual**2, 1.0/self.Sigma)
+            CinvD = cho_solve(self.factorized_Sigma, residual, check_finite=check_finite)
+            first_term = np.dot(residual, CinvD)
 
         lnlike = -0.5 * (first_term + self.log_det + n * np.log(2.*np.pi))
 
         return lnlike
 
 
-class NoiseModelKDE(object):
+class NoiseModelKDE:
 
     def __init__(self, metric_name="phot_samples", mask_name="mask"):
         # , kernel=None, weight_by=None):
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index d92be6cc..da6163a1 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -62,25 +62,25 @@ def _available_parameters(self):
 
         return new_pars
 
-    def predict(self, theta, obslist=None, sps=None, sigma_spec=None, **extras):
+    def predict(self, theta, observations=None, sps=None, **extras):
         """Given a ``theta`` vector, generate a spectrum, photometry, and any
         extras (e.g. stellar mass), including any calibration effects.
 
-        :param theta:
-            ndarray of parameter values, of shape ``(ndim,)``
+        Parameters
+        ----------
+        theta : ndarray of shape ``(ndim,)``
+            Vector of free model parameter values.
 
-        :param obslist:
-            A list of `Observation` instances.
+        observations : A list of `Observation` instances.
+            The data to predict
 
-        :param sps:
+        sps :
             An `sps` object to be used in the model generation.  It must have
             the :py:func:`get_galaxy_spectrum` method defined.
 
-        :param sigma_spec: (optional)
-            The covariance matrix for the spectral noise. It is only used for
-            emission line marginalization.
-
-        :returns predictions: (list of ndarrays)
+        Returns
+        -------
+        predictions: (list of ndarrays)
             List of predictions for the given list of observations.
 
             If the observation kind is "spectrum" then this is the model spectrum for these
@@ -92,12 +92,13 @@ def predict(self, theta, obslist=None, sps=None, sigma_spec=None, **extras):
             photometry for these parameters, for the filters specified in
             ``obs['filters']``.  Units of maggies.
 
-        :returns extras:
+        extras :
             Any extra aspects of the model that are returned.  Typically this
             will be `mfrac` the ratio of the surviving stellar mass to the
             stellar mass formed.
         """
-        # generate and cache model spectrum and info
+
+        # generate and cache intrinsic model spectrum and info
         self.set_parameters(theta)
         self._wave, self._spec, self._mfrac = sps.get_galaxy_spectrum(**self.params)
         self._zred = self.params.get('zred', 0)
@@ -116,20 +117,18 @@ def predict(self, theta, obslist=None, sps=None, sigma_spec=None, **extras):
         # generate predictions for likelihood
         # this assumes all spectral datasets (if present) occur first
         # because they can change the line strengths during marginalization.
-        predictions = [self.predict_one(obs, sigma_spec=sigma_spec)
-                       for obs in obslist]
+        predictions = [self.predict_obs(obs) for obs in observations]
 
         return predictions, self._mfrac
 
-    def predict_one(self, obs, sigma_spec=None):
-        self.cache_eline_parameters(obs)
+    def predict_obs(self, obs, sigma_spec=None):
         if obs.kind == "spectrum":
-            prediction = self.predict_spec(obs, sigma_spec)
+            prediction = self.predict_spec(obs)
         elif obs.kind == "photometry":
             prediction = self.predict_phot(obs["filters"])
         return prediction
 
-    def predict_spec(self, obs, sigma_spec=None, **extras):
+    def predict_spec(self, obs, **extras):
         """Generate a prediction for the observed spectrum.  This method assumes
         that the parameters have been set and that the following attributes are
         present and correct
@@ -169,14 +168,19 @@ def predict_spec(self, obs, sigma_spec=None, **extras):
             including multiplication by the calibration vector.
             ndarray of shape ``(nwave,)`` in units of maggies.
         """
-        # redshift wavelength
+        self._outwave = obs['wavelength']
+
+        # redshift model wavelength
         obs_wave = self.observed_wave(self._wave, do_wavecal=False)
-        self._outwave = obs.get('wavelength', obs_wave)
-        if self._outwave is None:
-            self._outwave = obs_wave
+
+        # Set up for emission lines
+        self.cache_eline_parameters(obs)
 
         # --- smooth and put on output wavelength grid ---
+        # physical smoothing
         smooth_spec = self.smoothspec(obs_wave, self._norm_spec)
+        # instrumental smoothing (accounting for library resolution)
+        smooth_spec = obs.instrumental_smoothing(self._outwave, smooth_spec, libres=0)
 
         # --- add fixed lines if necessary ---
         emask = self._fix_eline_pixelmask
@@ -194,7 +198,12 @@ def predict_spec(self, obs, sigma_spec=None, **extras):
         # --- fit and add lines if necessary ---
         emask = self._fit_eline_pixelmask
         if emask.any():
-            self._fit_eline_spec = self.fit_el(obs, calibrated_spec, sigma_spec)
+            # We need the spectroscopic covariance matrix to do emission line optimization and marginalization
+            sigma_spec = None
+            # FIXME: do this only if the noise model is non-trivial, and make sure masking is consistent
+            #vectors = obs.noise.populate_vectors(obs)
+            #sigma_spec = obs.noise.construct_covariance(**vectors)
+            self._fit_eline_spec = self.get_el(obs, calibrated_spec, sigma_spec)
             calibrated_spec[emask] += self._fit_eline_spec.sum(axis=1)
 
         # --- cache intrinsic spectrum ---
@@ -228,9 +237,7 @@ def predict_phot(self, filters):
         # generate photometry w/o emission lines
         obs_wave = self.observed_wave(self._wave, do_wavecal=False)
         flambda = self._norm_spec * lightspeed / obs_wave**2 * (3631*jansky_cgs)
-        phot = 10**(-0.4 * np.atleast_1d(getSED(obs_wave, flambda, filters)))
-        # TODO: below is faster for sedpy > 0.2.0
-        #phot = np.atleast_1d(getSED(obs_wave, flambda, filters, linear_flux=True))
+        phot = np.atleast_1d(getSED(obs_wave, flambda, filters, linear_flux=True))
 
         # generate emission-line photometry
         if (self._want_lines & self._need_lines):
@@ -670,10 +677,16 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
         spectrum, conditional on all other parameters. If emission lines are
         being marginalized out, they are excluded from the least-squares fit.
 
-        :param obs:
-            Instance of `Spectrum`
+        Parameters
+        ----------
+        obs :  Instance of `Spectrum`
 
-        :returns cal:
+        spec : ndarray of shape (nwave,)
+            The model spectrum.
+
+        Returns
+        -------
+        cal : ndarray of shape (nwave,)
            A polynomial given by :math:`\sum_{m=0}^M a_{m} * T_m(x)`.
         """
         if theta is not None:
diff --git a/prospect/utils/observation.py b/prospect/utils/observation.py
index da159e8c..da1e3b69 100644
--- a/prospect/utils/observation.py
+++ b/prospect/utils/observation.py
@@ -3,9 +3,16 @@
 import json
 import numpy as np
 
+from sedpy.observate import FilterSet
+from sedpy.smoothing import smoothspec
+
+from ..likelihood.noise_model import NoiseModel
+
+
 __all__ = ["Observation", "Spectrum", "Photometry",
            "from_oldstyle"]
 
+
 class NumpyEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, np.ndarray):
@@ -17,6 +24,15 @@ def default(self, obj):
 
 class Observation:
 
+    """
+    Attributes
+    ----------
+    flux :
+    uncertainty :
+    mask :
+    noise :
+    """
+
     logify_spectrum = False
     alias = {}
 
@@ -24,12 +40,14 @@ def __init__(self,
                  flux=None,
                  uncertainty=None,
                  mask=slice(None),
+                 noise=NoiseModel(),
                  **kwargs
                  ):
 
         self.flux = flux
         self.uncertainty = uncertainty
         self.mask = mask
+        self.noise = noise
         self.from_oldstyle(**kwargs)
 
     def __getitem__(self, item):
@@ -70,6 +88,7 @@ def rectify(self):
                      (self.uncertainty > 0))
 
         assert self.ndof > 0, "No valid data to fit: check the sign of the masks."
+        assert hasattr(self, "noise")
 
     def render(self, wavelength, spectrum):
         raise(NotImplementedError)
@@ -101,13 +120,10 @@ class Photometry(Observation):
     def __init__(self, filters=[], **kwargs):
 
         super(Photometry, self).__init__(**kwargs)
-        self.filters = filters
-
-    def render(self, wavelength, spectrum):
-        w, s = wavelength, spectrum
-        mags = [f.ab_mag(w, s, **self.render_kwargs)
-                for f in self.filters]
-        return 10**(-0.4 * np.array(mags))
+        self.filterset = FilterSet(filters)
+        # filters on the gridded resolution
+        self.filters = [f for f in self.filterset.filters]
+        self.filternames = np.array([f.name for f in self.filters])
 
     @property
     def wavelength(self):
@@ -148,12 +164,19 @@ def __init__(self,
         self.wavelength = wavelength
         self.resolution = resolution
         self.calibration = calibration
+        self.instrument_smoothing_parameters = dict(smoothtype="R", fftsmooth=True)
+
+    def instrumental_smoothing(self, inwave, influx, libres=0):
+        if self.resolution:
+            out = smoothspec(inwave, spec,
+                             self.resolution,
+                             outwave=self.wavelength,
+                             **self.instrument_smoothing_parameters)
+        else:
+            #out = np.interp(self.wavelength, inwave, influx)
+            out = influx
 
-    def render(self, wavelength, spectrum):
-        if self.ndata > 0:
-            wave = self.wavelength
-            spec = np.interp(wave, wavelength, spectrum)
-        return wave, spec
+        return out
 
     def to_oldstyle(self):
         obs = vars(self)
diff --git a/tests/test_predict.py b/tests/test_predict.py
index a14d6f20..451103ae 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import sys
 import numpy as np
 
 from sedpy.observate import load_filters
@@ -9,8 +10,10 @@
 from prospect.utils.observation import Spectrum, Photometry
 
 
-def build_model():
+def build_model(add_neb=False):
     model_params = templates.TemplateLibrary["parametric_sfh"]
+    if add_neb:
+        model_params.update(templates.TemplateLibrary["nebular_emission"])
     return SpecModel(model_params)
 
 
@@ -19,9 +22,9 @@ def build_obs(multispec=True):
     wmax = 7000
     wsplit = wmax - N * multispec
 
-    filterlist = load_filters([f"sdss_{b}0" for b in "ugriz"])
-    Nf = len(filterlist)
-    phot = [Photometry(filters=filterlist, flux=np.ones(Nf), uncertainty=np.ones(Nf)/10)]
+    fnames = list([f"sdss_{b}0" for b in "ugriz"])
+    Nf = len(fnames)
+    phot = [Photometry(filters=fnames, flux=np.ones(Nf), uncertainty=np.ones(Nf)/10)]
     spec = [Spectrum(wavelength=np.linspace(4000, wsplit, N),
                      flux=np.ones(N), uncertainty=np.ones(N) / 10,
                      mask=slice(None))]
@@ -47,10 +50,8 @@ def build_sps():
     model = build_model()
     sps = build_sps()
 
-    #sys.exit()
-    predictions_single, mfrac = model.predict(model.theta, obslist=obslist_single, sps=sps)
-    #sys.exit()
-    predictions, mfrac = model.predict(model.theta, obslist=obslist, sps=sps)
+    predictions_single, mfrac = model.predict(model.theta, observations=obslist_single, sps=sps)
+    predictions, mfrac = model.predict(model.theta, observations=obslist, sps=sps)
 
     import matplotlib.pyplot as pl
     fig, ax = pl.subplots()
@@ -61,3 +62,14 @@ def build_sps():
         else:
             ax.plot(o.wavelength, p)
 
+    # -- TESting ---
+    observations = obslist
+    arr = np.zeros(model.ndim)
+    from prospect.likelihood.likelihood import compute_lnlike
+    from prospect.fitting import lnprobfn
+
+    sys.exit()
+    #%timeit model.prior_product(model.theta)
+    #%timeit predictions, x = model.predict(model.theta + np.random.uniform(0, 3) * arr, observations=obslist, sps=sps)
+    #%timeit lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs in zip(predictions, observations)]
+    #%timeit lnp = lnprobfn(model.theta + np.random.uniform(0, 3) * arr, model=model, observations=obslist, sps=sps)
\ No newline at end of file

From 4bb0e830e9832f201c650683b3ee7977e18a1afc Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 2 May 2022 11:50:55 -0400
Subject: [PATCH 023/132] Remove SedModel and it's subclasses; cache library
 resolution if avaialble.

---
 prospect/fitting/fitting.py |  20 +---
 prospect/models/sedmodel.py | 224 +++---------------------------------
 tests/test_predict.py       |   4 +-
 3 files changed, 18 insertions(+), 230 deletions(-)

diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index e14ee930..7356d91d 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -24,13 +24,8 @@
            ]
 
 
-<<<<<<< HEAD
-def lnprobfn(theta, model=None, observations=None, sps=None, noises=None,
-             residuals=False, nested=False, negative=False, verbose=False):
-=======
 def lnprobfn(theta, model=None, observations=None, sps=None,
-             residuals=False, nested=False, verbose=False):
->>>>>>> 5617c8c (fitting ubdates for observation lists; dosctring modernization.)
+             residuals=False, nested=False, negative=False, verbose=False):
     """Given a parameter vector and optionally a dictionary of observational
     ata and a model object, return the matural log of the posterior. This
     requires that an sps object (and if using spectra and gaussian processes, a
@@ -287,12 +282,8 @@ def run_minimize(observations=None, model=None, sps=None, lnprobfn=lnprobfn,
         residuals = False
 
     args = []
-<<<<<<< HEAD
-    loss = argfix(lnprobfn, obs=obs, model=model, sps=sps,
-                  noise=noise, residuals=residuals, negative=True)
-=======
-    loss = argfix(lnprobfn, observations=observations, model=model, sps=sps, residuals=residuals)
->>>>>>> 5617c8c (fitting ubdates for observation lists; dosctring modernization.)
+    loss = argfix(lnprobfn, observations=observations, model=model, sps=sps,
+                  residuals=residuals, negative=True)
     minimizer = minimize_wrapper(algorithm, loss, [], min_method, min_opts)
     qinit = minimizer_ball(initial, nmin, model)
 
@@ -420,13 +411,8 @@ def run_emcee(observations, model, sps, lnprobfn=lnprobfn,
     return sampler, ts
 
 
-<<<<<<< HEAD
 def run_dynesty(obs, model, sps, noise, lnprobfn=lnprobfn,
                 pool=None, nested_target_n_effective=10000, **kwargs):
-=======
-def run_dynesty(obs, model, sps, lnprobfn=lnprobfn,
-                pool=None, nested_posterior_thresh=0.05, **kwargs):
->>>>>>> 5617c8c (fitting ubdates for observation lists; dosctring modernization.)
     """Thin wrapper on :py:class:`prospect.fitting.nested.run_dynesty_sampler`
 
     Parameters
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index da6163a1..94d9aba6 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -22,7 +22,7 @@
 
 __all__ = ["SpecModel", "PolySpecModel", "SplineSpecModel",
            "LineSpecModel", "AGNSpecModel",
-           "SedModel", "PolySedModel", "PolyFitModel"]
+           "PolyFitModel"]
 
 
 class SpecModel(ProspectorParams):
@@ -103,6 +103,7 @@ def predict(self, theta, observations=None, sps=None, **extras):
         self._wave, self._spec, self._mfrac = sps.get_galaxy_spectrum(**self.params)
         self._zred = self.params.get('zred', 0)
         self._eline_wave, self._eline_lum = sps.get_galaxy_elines()
+        self._library_resolution = getattr(sps, "spectral_resolution", 0.0)
 
         # Flux normalize
         self._norm_spec = self._spec * self.flux_norm()
@@ -121,7 +122,7 @@ def predict(self, theta, observations=None, sps=None, **extras):
 
         return predictions, self._mfrac
 
-    def predict_obs(self, obs, sigma_spec=None):
+    def predict_obs(self, obs):
         if obs.kind == "spectrum":
             prediction = self.predict_spec(obs)
         elif obs.kind == "photometry":
@@ -180,7 +181,8 @@ def predict_spec(self, obs, **extras):
         # physical smoothing
         smooth_spec = self.smoothspec(obs_wave, self._norm_spec)
         # instrumental smoothing (accounting for library resolution)
-        smooth_spec = obs.instrumental_smoothing(self._outwave, smooth_spec, libres=0)
+        smooth_spec = obs.instrumental_smoothing(self._outwave, smooth_spec,
+                                                 libres=self._library_resolution)
 
         # --- add fixed lines if necessary ---
         emask = self._fix_eline_pixelmask
@@ -1083,201 +1085,10 @@ def predict_aline_spec(self, line_indices, wave):
         return aline_spec
 
 
-class SedModel(ProspectorParams):
+class PolyFitModel(SpecModel):
 
-    """A subclass of :py:class:`ProspectorParams` that passes the models
-    through to an ``sps`` object and returns spectra and photometry, including
-    optional spectroscopic calibration and sky emission.
-    """
-
-    def predict(self, theta, obs=None, sps=None, **extras):
-        """Given a ``theta`` vector, generate a spectrum, photometry, and any
-        extras (e.g. stellar mass), including any calibration effects.
-
-        :param theta:
-            ndarray of parameter values, of shape ``(ndim,)``
-
-        :param obs:
-            An observation dictionary, containing the output wavelength array,
-            the photometric filter lists, and the observed fluxes and
-            uncertainties thereon.  Assumed to be the result of
-            :py:func:`utils.obsutils.rectify_obs`
-
-        :param sps:
-            An `sps` object to be used in the model generation.  It must have
-            the :py:func:`get_spectrum` method defined.
-
-        :param sigma_spec: (optional, unused)
-            The covariance matrix for the spectral noise. It is only used for
-            emission line marginalization.
-
-        :returns spec:
-            The model spectrum for these parameters, at the wavelengths
-            specified by ``obs['wavelength']``, including multiplication by the
-            calibration vector.  Units of maggies
-
-        :returns phot:
-            The model photometry for these parameters, for the filters
-            specified in ``obs['filters']``.  Units of maggies.
-
-        :returns extras:
-            Any extra aspects of the model that are returned.  Typically this
-            will be `mfrac` the ratio of the surviving stellar mass to the
-            stellar mass formed.
-        """
-        s, p, x = self.sed(theta, obs, sps=sps, **extras)
-        self._speccal = self.spec_calibration(obs=obs, **extras)
-        if obs.get('logify_spectrum', False):
-            s = np.log(s) + np.log(self._speccal)
-        else:
-            s *= self._speccal
-        return s, p, x
-
-    def sed(self, theta, obs=None, sps=None, **kwargs):
-        """Given a vector of parameters ``theta``, generate a spectrum, photometry,
-        and any extras (e.g. surviving mass fraction), ***not** including any
-        instrument calibration effects.  The intrinsic spectrum thus produced is
-        cached in `_spec` attribute
-
-        :param theta:
-            ndarray of parameter values.
-
-        :param obs:
-            An observation dictionary, containing the output wavelength array,
-            the photometric filter lists, and the observed fluxes and
-            uncertainties thereon.  Assumed to be the result of
-            :py:func:`utils.obsutils.rectify_obs`
-
-        :param sps:
-            An `sps` object to be used in the model generation.  It must have
-            the :py:func:`get_spectrum` method defined.
-
-        :returns spec:
-            The model spectrum for these parameters, at the wavelengths
-            specified by ``obs['wavelength']``.  Default units are maggies, and
-            the calibration vector is **not** applied.
-
-        :returns phot:
-            The model photometry for these parameters, for the filters
-            specified in ``obs['filters']``. Units are maggies.
-
-        :returns extras:
-            Any extra aspects of the model that are returned.  Typically this
-            will be `mfrac` the ratio of the surviving stellar mass to the
-            steallr mass formed.
-        """
-        self.set_parameters(theta)
-        spec, phot, extras = sps.get_spectrum(outwave=obs['wavelength'],
-                                              filters=obs['filters'],
-                                              component=obs.get('component', -1),
-                                              lnwavegrid=obs.get('lnwavegrid', None),
-                                              **self.params)
-
-        spec *= obs.get('normalization_guess', 1.0)
-        # Remove negative fluxes.
-        try:
-            tiny = 1.0 / len(spec) * spec[spec > 0].min()
-            spec[spec < tiny] = tiny
-        except:
-            pass
-        spec = (spec + self.sky(obs))
-        self._spec = spec.copy()
-        return spec, phot, extras
-
-    def sky(self, obs):
-        """Model for the *additive* sky emission/absorption"""
-        return 0.
-
-    def spec_calibration(self, theta=None, obs=None, **kwargs):
-        """Implements an overall scaling of the spectrum, given by the
-        parameter ``'spec_norm'``
-
-        :returns cal: (float)
-          A scalar multiplicative factor that gives the ratio between the true
-          spectrum and the observed spectrum
-        """
-        if theta is not None:
-            self.set_parameters(theta)
-
-        return 1.0 * self.params.get('spec_norm', 1.0)
-
-    def wave_to_x(self, wavelength=None, mask=slice(None), **extras):
-        """Map unmasked wavelengths to the interval (-1, 1). Masked wavelengths may have x>1, x<-1
-
-        :param wavelength:
-            The input wavelengths.  ndarray of shape ``(nwave,)``
-
-        :param mask: optional
-            The mask.  slice or boolean array with ``True`` for unmasked elements.
-            The interval (-1, 1) will be defined only by unmasked wavelength points
-
-        :returns x:
-            The wavelength vector, remapped to the interval (-1, 1).
-            ndarray of same shape as  ``wavelength``
-        """
-        x = wavelength - (wavelength[mask]).min()
-        x = 2.0 * (x / (x[mask]).max()) - 1.0
-        return x
-
-    def mean_model(self, theta, obs, sps=None, sigma_spec=None, **extras):
-        """Legacy wrapper around predict()
-        """
-        return self.predict(theta, obs, sps=sps, sigma=sigma_spec, **extras)
-
-
-class PolySedModel(SedModel):
-
-    """This is a subclass of SedModel that replaces the calibration vector with
-    the maximum likelihood chebyshev polynomial describing the difference
-    between the observed and the model spectrum.
-    """
-
-    def spec_calibration(self, theta=None, obs=None, **kwargs):
-        """Implements a Chebyshev polynomial calibration model. This uses
-        least-squares to find the maximum-likelihood Chebyshev polynomial of a
-        certain order describing the ratio of the observed spectrum to the
-        model spectrum, conditional on all other parameters, using least
-        squares.  The first coefficient is always set to 1, as the overall
-        normalization is controlled by ``spec_norm``.
-
-        :returns cal:
-           A polynomial given by 'spec_norm' * (1 + \sum_{m=1}^M a_{m} * T_m(x)).
-        """
-        if theta is not None:
-            self.set_parameters(theta)
-
-        norm = self.params.get('spec_norm', 1.0)
-        order = np.squeeze(self.params.get('polyorder', 0))
-        polyopt = ((order > 0) &
-                   (obs.get('spectrum', None) is not None))
-        if polyopt:
-            mask = obs.get('mask', slice(None))
-            # map unmasked wavelengths to the interval -1, 1
-            # masked wavelengths may have x>1, x<-1
-            x = self.wave_to_x(obs["wavelength"], mask)
-            y = (obs['spectrum'] / self._spec)[mask] / norm - 1.0
-            yerr = (obs['unc'] / self._spec)[mask] / norm
-            yvar = yerr**2
-            A = chebvander(x[mask], order)[:, 1:]
-            ATA = np.dot(A.T, A / yvar[:, None])
-            reg = self.params.get('poly_regularization', 0.)
-            if np.any(reg > 0):
-                ATA += reg**2 * np.eye(order)
-            ATAinv = np.linalg.inv(ATA)
-            c = np.dot(ATAinv, np.dot(A.T, y / yvar))
-            Afull = chebvander(x, order)[:, 1:]
-            poly = np.dot(Afull, c)
-            self._poly_coeffs = c
-        else:
-            poly = 0.0
-
-        return (1.0 + poly) * norm
-
-
-class PolyFitModel(SedModel):
-
-    """This is a subclass of *SedModel* that generates the multiplicative
-    calibration vector as a Chebyshev polynomial described by the
+    """This is a subclass of :py:class:`SpecModel` that generates the
+    multiplicative calibration vector as a Chebyshev polynomial described by the
     ``'poly_coeffs'`` parameter of the model, which may be free (fittable)
     """
 
@@ -1297,8 +1108,7 @@ def spec_calibration(self, theta=None, obs=None, **kwargs):
 
         :returns cal:
            If ``params["cal_type"]`` is ``"poly"``, a polynomial given by
-           ``'spec_norm'`` :math:`\times (1 + \Sum_{m=1}^M```'poly_coeffs'[m-1]``:math:` \times T_n(x))`.
-           Otherwise, the exponential of a Chebyshev polynomial.
+           :math:`\times (\Sum_{m=0}^M```'poly_coeffs'[m]``:math:` \times T_n(x))`.
         """
         if theta is not None:
             self.set_parameters(theta)
@@ -1308,20 +1118,12 @@ def spec_calibration(self, theta=None, obs=None, **kwargs):
             # map unmasked wavelengths to the interval -1, 1
             # masked wavelengths may have x>1, x<-1
             x = self.wave_to_x(obs["wavelength"], mask)
-            # get coefficients.  Here we are setting the first term to 0 so we
-            # can deal with it separately for the exponential and regular
-            # multiplicative cases
-            c = np.insert(self.params['poly_coeffs'], 0, 0)
+            # get coefficients.
+            c = self.params['poly_coeffs']
             poly = chebval(x, c)
-            # switch to have spec_norm be multiplicative or additive depending
-            # on whether the calibration model is multiplicative in exp^poly or
-            # just poly
-            if self.params.get('cal_type', 'exp_poly') == 'poly':
-                return (1.0 + poly) * self.params.get('spec_norm', 1.0)
-            else:
-                return np.exp(self.params.get('spec_norm', 0) + poly)
+            return poly
         else:
-            return 1.0 * self.params.get('spec_norm', 1.0)
+            return 1.0
 
 
 def ln_mvn(x, mean=None, cov=None):
diff --git a/tests/test_predict.py b/tests/test_predict.py
index 451103ae..70c1e61a 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -13,7 +13,7 @@
 def build_model(add_neb=False):
     model_params = templates.TemplateLibrary["parametric_sfh"]
     if add_neb:
-        model_params.update(templates.TemplateLibrary["nebular_emission"])
+        model_params.update(templates.TemplateLibrary["nebular"])
     return SpecModel(model_params)
 
 
@@ -47,7 +47,7 @@ def build_sps():
 if __name__ == "__main__":
     obslist_single = build_obs(multispec=False)
     obslist = build_obs()
-    model = build_model()
+    model = build_model(add_neb=True)
     sps = build_sps()
 
     predictions_single, mfrac = model.predict(model.theta, observations=obslist_single, sps=sps)

From 563e713fa9937050bd1ea8982b29e86656521e5c Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 2 May 2022 14:53:44 -0400
Subject: [PATCH 024/132] Move observation submodule to new data module;
 Numerous tweaks to observation generation from old style dicts; Changes to
 test_eline for new predict() api.

---
 prospect/data/__init__.py               |   6 +
 prospect/{utils => data}/observation.py |  97 +++++++---
 prospect/{utils => data}/obsutils.py    |   0
 prospect/fitting/fitting.py             |  10 +-
 prospect/models/__init__.py             |   9 +-
 prospect/models/model_setup.py          | 237 ------------------------
 pyproject.toml                          |   2 +-
 tests/test_eline.py                     |  48 ++---
 tests/test_predict.py                   |  38 ++--
 9 files changed, 129 insertions(+), 318 deletions(-)
 create mode 100644 prospect/data/__init__.py
 rename prospect/{utils => data}/observation.py (63%)
 rename prospect/{utils => data}/obsutils.py (100%)
 delete mode 100644 prospect/models/model_setup.py

diff --git a/prospect/data/__init__.py b/prospect/data/__init__.py
new file mode 100644
index 00000000..f4bb7dc4
--- /dev/null
+++ b/prospect/data/__init__.py
@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+from .observation import Photometry, Spectrum, from_oldstyle
+
+__all__ = ["Photometry", "Spectrum",
+           "from_oldstyle"]
diff --git a/prospect/utils/observation.py b/prospect/data/observation.py
similarity index 63%
rename from prospect/utils/observation.py
rename to prospect/data/observation.py
index da1e3b69..85936802 100644
--- a/prospect/utils/observation.py
+++ b/prospect/data/observation.py
@@ -24,7 +24,8 @@ def default(self, obj):
 
 class Observation:
 
-    """
+    """Data to be predicted (and fit)
+
     Attributes
     ----------
     flux :
@@ -41,6 +42,7 @@ def __init__(self,
                  uncertainty=None,
                  mask=slice(None),
                  noise=NoiseModel(),
+                 name="ObsA",
                  **kwargs
                  ):
 
@@ -48,6 +50,7 @@ def __init__(self,
         self.uncertainty = uncertainty
         self.mask = mask
         self.noise = noise
+        self.name = name
         self.from_oldstyle(**kwargs)
 
     def __getitem__(self, item):
@@ -70,14 +73,18 @@ def from_oldstyle(self, **kwargs):
             if k in kwargs:
                 setattr(self, v, kwargs[k])
 
-    def rectify(self):
-        """Make sure required attributes are present and have the appropriate
-        sizes.  Also auto-masks non-finite data or negative uncertainties.
+    def rectify(self, for_fitting=False):
+        """Make sure required attributes for fitting are present and have the
+        appropriate sizes.  Also auto-masks non-finite data or negative
+        uncertainties.
         """
+
         assert self.wavelength.ndim == 1, "`wavelength` is not 1-d array"
         assert self.ndata > 0, "no wavelength points supplied!"
-        assert len(self.wavelength) == len(self.flux), "Flux array not same shape as wavelength"
-        assert len(self.wavelength) == len(self.uncertainty), "Uncertainty array not same shape as wavelength"
+        assert self.flux is not None, " No data."
+        assert self.uncertainty is not None, "No uncertainties."
+        assert len(self.wavelength) == len(self.flux), "Flux array not same shape as wavelength."
+        assert len(self.wavelength) == len(self.uncertainty), "Uncertainty array not same shape as wavelength."
 
         # make mask array with automatic filters
         marr = np.zeros(self.ndata, dtype=bool)
@@ -87,7 +94,7 @@ def rectify(self):
                      (np.isfinite(self.uncertainty)) &
                      (self.uncertainty > 0))
 
-        assert self.ndof > 0, "No valid data to fit: check the sign of the masks."
+        assert self.ndof == 0, f"{self.__repr__()} has no valid data to fit: check the sign of the masks."
         assert hasattr(self, "noise")
 
     def render(self, wavelength, spectrum):
@@ -95,10 +102,12 @@ def render(self, wavelength, spectrum):
 
     @property
     def ndof(self):
-        return int(self.mask.sum())
+        # TODO: cache this?
+        return int(np.sum(np.ones(self.ndata)[self.mask]))
 
     @property
     def ndata(self):
+        # TODO: cache this?
         if self.wavelength is None:
             return 0
         else:
@@ -117,13 +126,18 @@ class Photometry(Observation):
                  filters="filters",
                  phot_mask="mask")
 
-    def __init__(self, filters=[], **kwargs):
+    def __init__(self, filters=[], name="PhotA", **kwargs):
+
+        if type(filters[0]) is str:
+            self.filternames = filters
+        else:
+            self.filternames = [f.name for f in filters]
 
-        super(Photometry, self).__init__(**kwargs)
-        self.filterset = FilterSet(filters)
+        self.filterset = FilterSet(self.filternames)
         # filters on the gridded resolution
         self.filters = [f for f in self.filterset.filters]
-        self.filternames = np.array([f.name for f in self.filters])
+
+        super(Photometry, self).__init__(name=name, **kwargs)
 
     @property
     def wavelength(self):
@@ -149,10 +163,13 @@ def __init__(self,
                  wavelength=None,
                  resolution=None,
                  calibration=None,
+                 name="SpecA",
                  **kwargs):
 
         """
-        :param resolution: (optional, default: None)
+        Parameters
+        ----------
+        resolution : (optional, default: None)
             Instrumental resolution at each wavelength point in units of km/s
             dispersion (:math:`= c \, \sigma_\lambda / \lambda = c \, \FWHM_\lambda / 2.355 / \lambda = c / (2.355 \, R_\lambda)`
             where :math:`c=2.998e5 {\rm km}/{\rm s}`
@@ -160,22 +177,45 @@ def __init__(self,
         :param calibration:
             not sure yet ....
         """
-        super(Spectrum, self).__init__(**kwargs)
+        super(Spectrum, self).__init__(name=name, **kwargs)
         self.wavelength = wavelength
         self.resolution = resolution
         self.calibration = calibration
-        self.instrument_smoothing_parameters = dict(smoothtype="R", fftsmooth=True)
-
-    def instrumental_smoothing(self, inwave, influx, libres=0):
-        if self.resolution:
-            out = smoothspec(inwave, spec,
-                             self.resolution,
-                             outwave=self.wavelength,
-                             **self.instrument_smoothing_parameters)
-        else:
-            #out = np.interp(self.wavelength, inwave, influx)
-            out = influx
+        self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
+
+    def instrumental_smoothing(self, obswave, influx, libres=0):
+        """Smooth a spectrum by the instrumental resolution, optionally
+        accounting (in quadrature) the intrinsic library resolution.
 
+        Parameters
+        ----------
+        obswave : ndarray
+            Observed frame wavelengths, in units of AA
+
+        influx : ndarray
+            Flux array
+
+        libres : float or ndarray
+            Library resolution in units of km/ (dispersion) to be subtracted from the smoothing kernel.
+
+        Returns
+        -------
+        outflux : ndarray
+            If instrument resolution is not None, this is the smoothed flux on
+            the observed ``wavelength`` grid.  If resolution is None, this just
+            passes ``influx`` right back again.
+        """
+        if self.resolution is None:
+            # no-op
+            return influx
+
+        if libres:
+            kernel = np.sqrt(self.resolution**2 - libres**2)
+        else:
+            kernel = self.resolution
+        out = smoothspec(obswave, influx, kernel,
+                         outwave=self.wavelength,
+                         **self.instrument_smoothing_parameters)
         return out
 
     def to_oldstyle(self):
@@ -185,7 +225,10 @@ def to_oldstyle(self):
         return obs
 
 
-def from_oldstyle(obs):
+def from_oldstyle(obs, **kwargs):
     """Convert from an oldstyle dictionary to a list of observations
     """
-    return [Spectrum().from_oldstyle(obs), Photometry().from_oldstyle(obs)]
\ No newline at end of file
+    obslist = [Spectrum(**obs), Photometry(**obs)]
+    #[o.rectify() for o in obslist]
+
+    return obslist
diff --git a/prospect/utils/obsutils.py b/prospect/data/obsutils.py
similarity index 100%
rename from prospect/utils/obsutils.py
rename to prospect/data/obsutils.py
diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index 7356d91d..4afa53bd 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -36,7 +36,7 @@ def lnprobfn(theta, model=None, observations=None, sps=None,
     theta :  ndarray of shape ``(ndim,)``
         Input parameter vector
 
-    model : instance of the :py:class:`prospect.models.SedModel`
+    model : instance of the :py:class:`prospect.models.SpecModel`
         The model parameterization and parameter state. Must have
         :py:meth:`predict()` defined
 
@@ -131,7 +131,7 @@ def fit_model(observations, model, sps, lnprobfn=lnprobfn,
     observations : list of :py:class:`observate.Observation` instances
         The data to be fit.
 
-    model : instance of the :py:class:`prospect.models.SedModel`
+    model : instance of the :py:class:`prospect.models.SpecModel`
         The model parameterization and parameter state.  It will be
         passed to ``lnprobfn``.
 
@@ -226,7 +226,7 @@ def run_minimize(observations=None, model=None, sps=None, lnprobfn=lnprobfn,
     observations : list of :py:class:`observate.Observation` instances
         The data to be fit.
 
-    model : instance of the :py:class:`prospect.models.SedModel`
+    model : instance of the :py:class:`prospect.models.SpecModel`
         The model parameterization and parameter state.  It will be
         passed to ``lnprobfn``.
 
@@ -315,7 +315,7 @@ def run_emcee(observations, model, sps, lnprobfn=lnprobfn,
     observations : list of :py:class:`observate.Observation` instances
         The data to be fit.
 
-    model : instance of the :py:class:`prospect.models.SedModel`
+    model : instance of the :py:class:`prospect.models.SpecModel`
         The model parameterization and parameter state.  It will be
         passed to ``lnprobfn``.
 
@@ -420,7 +420,7 @@ def run_dynesty(obs, model, sps, noise, lnprobfn=lnprobfn,
     observations : list of :py:class:`observate.Observation` instances
         The data to be fit.
 
-    model : instance of the :py:class:`prospect.models.SedModel`
+    model : instance of the :py:class:`prospect.models.SpecModel`
         The model parameterization and parameter state.  It will be
         passed to ``lnprobfn``.
 
diff --git a/prospect/models/__init__.py b/prospect/models/__init__.py
index 407c21ef..59d362c9 100644
--- a/prospect/models/__init__.py
+++ b/prospect/models/__init__.py
@@ -9,7 +9,10 @@
 from .sedmodel import PolySpecModel, SplineSpecModel
 from .sedmodel import AGNSpecModel, LineSpecModel
 
-__all__ = ["ProspectorParams", "SpecModel",
+
+__all__ = ["ProspectorParams",
+           "SpecModel",
            "PolySpecModel", "SplineSpecModel",
-           "LineSpecModel", "AGNSpecModel",
-           "SedModel"]
+           "LineSpecModel", "AGNSpecModel"
+           ]
+
diff --git a/prospect/models/model_setup.py b/prospect/models/model_setup.py
deleted file mode 100644
index 1a1063e3..00000000
--- a/prospect/models/model_setup.py
+++ /dev/null
@@ -1,237 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import sys, os, getopt, json, warnings
-from copy import deepcopy
-import numpy as np
-from . import parameters
-from ..utils.obsutils import fix_obs
-
-"""This module has methods to take a .py file containing run parameters, model
-parameters and other info and return a run_params dictionary, an obs
-dictionary, and a model.  It also has methods to parse command line options and
-return an sps object and noise objects.
-
-Most of the load_<x> methods are just really shallow wrappers on
-```import_module_from_file(param_file).load_<x>(**kwargs)``` and could probably
-be done away with at this point, as they add a mostly useless layer of
-abstraction.  Kept here for future flexibility.
-"""
-
-__all__ = ["parse_args", "import_module_from_file", "get_run_params",
-           "load_model", "load_obs", "load_sps", "load_gp", "show_syntax"]
-
-
-deprecation_msg = ("Use argparse based operation; usage via prospector_*.py "
-                   "scripts will be disabled in the future.")
-
-
-def parse_args(argv, argdict={}):
-    """Parse command line arguments, allowing for optional arguments.
-    Simple/Fragile.
-    """
-    warnings.warn(deprecation_msg, FutureWarning)
-    args = [sub for arg in argv[1:] for sub in arg.split('=')]
-    for i, a in enumerate(args):
-        if (a[:2] == '--'):
-            abare = a[2:]
-            if abare == 'help':
-                show_syntax(argv, argdict)
-                sys.exit()
-        else:
-            continue
-        if abare in argdict.keys():
-            apo = deepcopy(args[i+1])
-            func = type(argdict[abare])
-            try:
-                argdict[abare] = func(apo)
-                if func is bool:
-                    argdict[abare] = apo in ['True', 'true', 'T', 't', 'yes']
-            except TypeError:
-                argdict[abare] = apo
-    return argdict
-
-
-def get_run_params(param_file=None, argv=None, **kwargs):
-    """Get a run_params dictionary from the param_file (if passed) otherwise
-    return the kwargs dictionary.
-
-    The order of precedence of parameter specification locations is:
-        * 1. param_file (lowest)
-        * 2. kwargs passsed to this function
-        * 3. command line arguments
-    """
-    warnings.warn(deprecation_msg, FutureWarning)
-    rp = {}
-    if param_file is None:
-        ext = ""
-    else:
-        ext = param_file.split('.')[-1]
-    if ext == 'py':
-        setup_module = import_module_from_file(param_file)
-        rp = deepcopy(setup_module.run_params)
-    elif ext == 'json':
-        rp, mp = parameters.read_plist(param_file)
-    if kwargs is not None:
-        kwargs.update(rp)
-        rp = kwargs
-    if argv is not None:
-        rp = parse_args(argv, argdict=rp)
-    rp['param_file'] = param_file
-
-    return rp
-
-
-def load_sps(param_file=None, **kwargs):
-    """Return an ``sps`` object which is used to hold spectral libraries,
-    perform interpolations, convolutions, etc.
-    """
-    warnings.warn(deprecation_msg, FutureWarning)
-    ext = param_file.split('.')[-1]
-    assert ext == 'py'
-    setup_module = import_module_from_file(param_file)
-
-    if hasattr(setup_module, 'load_sps'):
-        builder = setup_module.load_sps
-    elif hasattr(setup_module, 'build_sps'):
-        builder = setup_module.build_sps
-    else:
-        warnings.warn("Could not find load_sps or build_sps methods in param_file")
-        return None
-
-    sps = builder(**kwargs)
-
-    return sps
-
-
-def load_gp(param_file=None, **kwargs):
-    """Return two Gaussian Processes objects, either using BSFH's internal GP
-    objects or George.
-
-    :returns gp_spec:
-        The gaussian process object to use for the spectroscopy.
-
-    :returns gp_phot:
-        The gaussian process object to use for the photometry.
-    """
-    warnings.warn(deprecation_msg, FutureWarning)
-    ext = param_file.split('.')[-1]
-    assert ext == "py"
-    setup_module = import_module_from_file(param_file)
-
-    if hasattr(setup_module, 'load_gp'):
-        builder = setup_module.load_gp
-    elif hasattr(setup_module, 'build_noise'):
-        builder = setup_module.build_noise
-    else:
-        warnings.warn("Could not find load_gp or build_noise methods in param_file")
-        return None, None
-
-    spec_noise, phot_noise = builder(**kwargs)
-
-    return spec_noise, phot_noise
-
-
-def load_model(param_file=None, **kwargs):
-    """Load the model object from a model config list given in the config file.
-
-    :returns model:
-        An instance of the parameters.ProspectorParams object which has
-        been configured
-    """
-    warnings.warn(deprecation_msg, FutureWarning)
-    ext = param_file.split('.')[-1]
-    assert ext == 'py'
-    setup_module = import_module_from_file(param_file)
-        #mp = deepcopy(setup_module.model_params)
-
-    if hasattr(setup_module, 'load_model'):
-        builder = setup_module.load_model
-    elif hasattr(setup_module, 'build_model'):
-        builder = setup_module.build_model
-    else:
-        warnings.warn("Could not find load_model or build_model methods in param_file")
-        return None
-
-    model = builder(**kwargs)
-
-    return model
-
-
-def load_obs(param_file=None, **kwargs):
-    """Load the obs dictionary using the `obs` attribute or methods in
-    ``param_file``.  kwargs are passed to these methods and ``fix_obs()``
-
-    :returns obs:
-        A dictionary of observational data.
-    """
-    warnings.warn(deprecation_msg, FutureWarning)
-    ext = param_file.split('.')[-1]
-    obs = None
-    assert ext == 'py'
-    print('reading py script {}'.format(param_file))
-    setup_module = import_module_from_file(param_file)
-
-    if hasattr(setup_module, 'obs'):
-        return fix_obs(deepcopy(setup_module.obs))
-    if hasattr(setup_module, 'load_obs'):
-        builder = setup_module.load_obs
-    elif hasattr(setup_module, 'build_obs'):
-        builder = setup_module.build_obs
-    else:
-        warnings.warn("Could not find load_obs or build_obs methods in param_file")
-        return None
-
-    obs = builder(**kwargs)
-    obs = fix_obs(obs, **kwargs)
-
-    return obs
-
-
-def import_module_from_file(path_to_file):
-    """This has to break everything ever, right?
-    """
-    from importlib import import_module
-    path, filename = os.path.split(path_to_file)
-    modname = filename.replace('.py', '')
-    sys.path.insert(0, path)
-    user_module = import_module(modname)
-    sys.path.remove(path)
-    return user_module
-
-
-def import_module_from_string(source, name, add_to_sys_modules=True):
-    """Well this seems dangerous.
-    """
-    import imp
-    user_module = imp.new_module(name)
-    exec(source, user_module.__dict__)
-    if add_to_sys_modules:
-        sys.modules[name] = user_module
-
-    return user_module
-
-
-def show_syntax(args, ad):
-    """Show command line syntax corresponding to the provided arg dictionary
-    `ad`.
-    """
-    print('Usage:\n {0} '.format(args[0]) +
-          ' '.join(['--{0}=<value>'.format(k) for k in ad.keys()]))
-
-
-class Bunch(object):
-    """ Simple storage.
-    """
-    def __init__(self, **kwargs):
-        self.__dict__.update(kwargs)
-
-
-def custom_filter_dict(filename):
-    filter_dict = {}
-    with open(filename, 'r') as f:
-        for line in f:
-            ind, name = line.split()
-            filter_dict[name.lower()] = Bunch(index=int(ind)-1)
-
-    return filter_dict
diff --git a/pyproject.toml b/pyproject.toml
index e83a3d11..56035247 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,7 +24,7 @@ test = ["pytest", "pytest-xdist"]
 
 [tool.setuptools]
 packages = ["prospect",
-            "prospect.models", "prospect.sources",
+            "prospect.models", "prospect.sources", "prospect.data",
             "prospect.likelihood", "prospect.fitting",
             "prospect.io", "prospect.plotting", "prospect.utils"]
 
diff --git a/tests/test_eline.py b/tests/test_eline.py
index 14d9a53c..05197f69 100644
--- a/tests/test_eline.py
+++ b/tests/test_eline.py
@@ -6,9 +6,9 @@
 from sedpy import observate
 
 from prospect import prospect_args
-from prospect.utils.obsutils import fix_obs
+from prospect.data import Photometry, Spectrum, from_oldstyle
 from prospect.models.templates import TemplateLibrary
-from prospect.models.sedmodel import SpecModel, SedModel
+from prospect.models.sedmodel import SpecModel
 
 from prospect.sources import CSPSpecBasis
 
@@ -61,7 +61,7 @@ def test_nebline_phot_addition():
                wavelength=np.linspace(3000, 9000, 1000),
                spectrum=np.ones(1000),
                unc=np.ones(1000)*0.1)
-    obs = fix_obs(obs)
+    obslist = from_oldstyle(obs)
 
     sps = CSPSpecBasis(zcontinuous=1)
 
@@ -81,26 +81,28 @@ def test_nebline_phot_addition():
     model_pars["nebemlineinspec"]["init"] = False
     m2 = SpecModel(model_pars)
 
-    _, p1, _ = m1.predict(m1.theta, obs, sps)
-    _, p2, _ = m2.predict(m2.theta, obs, sps)
+    (s1, p1), _ = m1.predict(m1.theta, obslist, sps)
+    (s2, p2), _ = m2.predict(m2.theta, obslist, sps)
 
     # make sure some of the lines were important
     p1n = m1.nebline_photometry(filts)
-    assert np.any(p1n / p1 > 0.05)
+    assert np.any(p1n / p1[1] > 0.05)
 
     # make sure you got the same answer
     assert np.all(np.abs(p1 - p2) / p1 < 1e-3)
 
 
 def test_filtersets():
+    """This test no longer relevant.....
+    """
     fnames = [f"sdss_{b}0" for b in "ugriz"]
     flist = observate.load_filters(fnames)
-    fset = observate.FilterSet(fnames)
 
     obs = dict(wavelength=np.linspace(3000, 9000, 1000),
                spectrum=np.ones(1000),
-               unc=np.ones(1000)*0.1)
-    obs = fix_obs(obs)
+               unc=np.ones(1000)*0.1,
+               filters=fnames)
+    obslist = from_oldstyle(obs)
 
     sps = CSPSpecBasis(zcontinuous=1)
 
@@ -120,31 +122,18 @@ def test_filtersets():
     model_pars["nebemlineinspec"]["init"] = False
     models.append(SpecModel(model_pars))
 
-    # test old usage w/ SedModel (mags computed in sps object)
-    model_pars = TemplateLibrary["parametric_sfh"]
-    model_pars["zred"]["init"] = zred
-    model_pars.update(TemplateLibrary["nebular"])
-    models.append(SedModel(model_pars))
-
     for i, model in enumerate(models):
-        obs["filters"] = flist
-        _, plist, _ = model.predict(model.theta, obs, sps)
-        obs["filters"] = fset
-        _, pset, _ = model.predict(model.theta, obs, sps)
+        (_, pset), _ = model.predict(model.theta, obslist, sps)
 
         # make sure some of the filters are affected by lines
+        # ( nebular flux > 10% of total flux)
         if i == 1:
             nebphot = model.nebline_photometry(flist)
             assert np.any(nebphot / pset > 0.1)
 
-        dmag = np.abs(pset - plist) / plist
-        #print(plist)
-        #print(dmag)
-
         # make sure photometry is consistent
-        assert np.all(dmag < 5e-2), f"photometry inconsistent between Filter list and FilterSet on model {i}: {dmag}"
         # make sure we actually used different filter types
-        assert np.any(dmag > 0)
+        # We always use filtersets now
 
 
 def test_eline_implementation():
@@ -158,7 +147,7 @@ def test_eline_implementation():
                unc=np.ones(1000)*0.1,
                maggies=np.ones(len(filters))*1e-7,
                maggies_unc=np.ones(len(filters))*1e-8)
-    obs = fix_obs(obs)
+    obslist = from_oldstyle(obs)
 
     model_pars = TemplateLibrary["parametric_sfh"]
     model_pars.update(TemplateLibrary["nebular"])
@@ -170,21 +159,20 @@ def test_eline_implementation():
     sps = CSPSpecBasis(zcontinuous=1)
 
     # generate with all fixed lines added
-    spec, phot, mfrac = model.predict(model.theta, obs=obs, sps=sps)
+    (spec, phot), mfrac = model.predict(model.theta, obslist, sps=sps)
 
     # test ignoring a line
     lya = "Ly-alpha 1215"
     model_pars["elines_to_ignore"] = dict(init=lya, isfree=False)
     model = SpecModel(model_pars)
-    spec_nolya, phot_nolya, mfrac = model.predict(model.theta, obs=obs, sps=sps)
+    (spec_nolya, phot_nolya), mfrac = model.predict(model.theta, obslist, sps=sps)
     assert np.any((phot - phot_nolya) / phot != 0.0)
     lint = np.trapz(spec - spec_nolya, obs["wavelength"])
     assert lint > 0
 
     # test igoring a line, phot only
-    obs_spec = obs.pop("spectrum")
     model = SpecModel(model_pars)
-    spec_nolya_2, phot_nolya_2, mfrac = model.predict(model.theta, obs=obs, sps=sps)
+    (phot_nolya_2,), mfrac = model.predict(model.theta, [obslist[1]], sps=sps)
     obs["spectrum"] = obs_spec
     assert np.all(phot_nolya == phot_nolya_2)
 
diff --git a/tests/test_predict.py b/tests/test_predict.py
index 70c1e61a..48f36a3a 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -7,7 +7,7 @@
 from sedpy.observate import load_filters
 from prospect.sources import CSPSpecBasis
 from prospect.models import SpecModel, templates
-from prospect.utils.observation import Spectrum, Photometry
+from prospect.data import Spectrum, Photometry
 
 
 def build_model(add_neb=False):
@@ -44,7 +44,7 @@ def build_sps():
     return sps
 
 
-if __name__ == "__main__":
+def test_multispec():
     obslist_single = build_obs(multispec=False)
     obslist = build_obs()
     model = build_model(add_neb=True)
@@ -53,22 +53,30 @@ def build_sps():
     predictions_single, mfrac = model.predict(model.theta, observations=obslist_single, sps=sps)
     predictions, mfrac = model.predict(model.theta, observations=obslist, sps=sps)
 
-    import matplotlib.pyplot as pl
-    fig, ax = pl.subplots()
-    ax.plot(obslist_single[0].wavelength, predictions_single[0])
-    for p, o in zip(predictions, obslist):
-        if o.kind == "photometry":
-            ax.plot(o.wavelength, p, "o")
-        else:
-            ax.plot(o.wavelength, p)
-
-    # -- TESting ---
-    observations = obslist
-    arr = np.zeros(model.ndim)
+    assert len(predictions_single) == 2
+    assert len(predictions) == 3
+    assert np.allclose(predictions_single[-1], predictions[-1])
+    # TODO: turn this plot into an actual test
+    #import matplotlib.pyplot as pl
+    #fig, ax = pl.subplots()
+    #ax.plot(obslist_single[0].wavelength, predictions_single[0])
+    #for p, o in zip(predictions, obslist):
+    #    if o.kind == "photometry":
+    #        ax.plot(o.wavelength, p, "o")
+    #    else:
+    #        ax.plot(o.wavelength, p)
+
+
+def lnlike_testing():
+
+    # testing lnprobfn
+    observations = build_obs()
+    model = build_model(add_neb=True)
     from prospect.likelihood.likelihood import compute_lnlike
     from prospect.fitting import lnprobfn
 
-    sys.exit()
+    lnp = lnprobfn(model.theta, model=model, observations=obslist, sps=sps)
+
     #%timeit model.prior_product(model.theta)
     #%timeit predictions, x = model.predict(model.theta + np.random.uniform(0, 3) * arr, observations=obslist, sps=sps)
     #%timeit lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs in zip(predictions, observations)]

From 56781a17bf48086d066df8688d75750e3294b2c1 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 2 May 2022 16:08:25 -0400
Subject: [PATCH 025/132] Update docs for new observation object, including
 noise model description.

---
 doc/dataformat.rst                 | 166 ++++++++++++++++++-----------
 doc/faq.rst                        |   2 +-
 doc/index.rst                      |   1 +
 doc/models.rst                     |   4 +-
 doc/noise.rst                      |  58 ++++++++++
 doc/quickstart.rst                 |  38 +++----
 doc/usage.rst                      |  10 +-
 prospect/data/observation.py       |   3 +-
 prospect/likelihood/__init__.py    |   2 +-
 prospect/likelihood/noise_model.py |  16 +--
 tests/test_eline.py                |   3 +-
 11 files changed, 200 insertions(+), 103 deletions(-)
 create mode 100644 doc/noise.rst

diff --git a/doc/dataformat.rst b/doc/dataformat.rst
index ab5ac7be..bbbacfaf 100644
--- a/doc/dataformat.rst
+++ b/doc/dataformat.rst
@@ -1,84 +1,116 @@
 Data Formats
 ============
 
-The ``obs`` Dictionary & Data Units
+
+The `Observation` class
 -----------------------------------
 
-|Codename| expects the data in the form of a dictionary, preferably returned by
-a :py:meth:`build_obs` function (see below). This dictionary should have (at
-least) the following keys and values:
-
-``"wavelength"``
-    The wavelength vector for the spectrum, ndarray.
-    Units are vacuum Angstroms.
-    The model spectrum will be computed for each element of this vector.
-    Set to ``None`` if you have no spectrum.
-    If fitting observed frame photometry as well,
-    then these should be observed frame wavelengths.
-
-``"spectrum"``
-    The flux vector for the spectrum,
-    ndarray of same length as the wavelength vector.
-    If absolute spectrophotometry is available,
-    the units of this spectrum should be Janskies divided by 3631 (i.e. maggies).
-    Also the ``rescale_spectrum`` run parameter should be False.
-
-``"unc"``
-    The uncertainty vector (sigma), in same units as ``"spectrum"``,
-    ndarray of same length as the wavelength vector.
-
-``"mask"``
-   A boolean array of same length as the wavelength vector,
-   where ``False`` elements are ignored in the likelihood calculation.
-
-``"filters"``
-   A sequence of `sedpy <https://github.com/bd-j/sedpy>`_ filter objects or filter names,
-   used to calculate model magnitudes.
-
-``"maggies"``
-    An array of photometric flux densities, same length as ``"filters"``. The
-    units are *maggies*. Maggies are a linear flux density unit defined as
-    :math:`{\rm maggie} = 10^{-0.4 \, m_{AB}}` where :math:`m_{AB}` is the AB apparent
-    magnitude. That is, 1 maggie is the flux density in Janskys divided by 3631.
-    Set to ``None`` if you have no photometric data.
-
-``"maggies_unc"``
-    An array of photometric flux uncertainties, same length as ``"filters"``,
-    that gives the photometric uncertainties in units of *maggies*
-
-``"phot_mask"``
-    Like ``"mask"``, a boolean array, used to mask the
-    photometric data during the likelihood calculation.
-    Elements with ``False`` values are ignored in the likelihood calculation.
-
-If you do not have spectral or photometric data, you can set ``"wavelength":
-None`` or ``"maggies": None`` respectively. Feel free to add keys that store
-other metadata, these will be stored on output. However, for ease of storage
-these keys should either be numpy arrays or basic python datatypes that are JSON
-serializable (e.g. strings, ints, and floats and lists, dicts, and tuples
-thereof.)
-
-The method :py:meth:`prospect.utils.obsutils.fix_obs` can be used as a shortcut
-to add any of the missing required keys with their default values and ensure
-that there is data to fit, e.g.
+|Codename| expects the data in the form of list of ``Observations``, preferably
+returned by :py:meth:`build_obs` (see below). Each Observation instance
+corresponds to single dataset, and is basically a namespace that also supports
+dict-like accessing of important attributes.  In addition to holding data and
+uncertainties thereon, they tell prospector what data to predict, contain
+dataset-specific information for how to predict that data, and can even store
+methods for computing likelihoods in the case of complicated, dataset-specific
+noise models. There are two fundamental kinds of data, `Photometry` and
+`Spectrum` that are each subclasses of `Observation`.  They have the following
+attributes, most of which can be also accessed as dictionary keys.
+
+
+- ``wavelength``
+    The wavelength vector for a `Spectrum`` or the effective wavelengths of the
+    filters in a `Photometry` data set, ndarray. Units are vacuum Angstroms.
+    Generally these should be observed frame wavelengths.
+
+- ``flux``
+    The flux vector for a `Spectrum`, or the broadband fluxes for `Photometry`
+    ndarray of same length as the wavelength vector. For `Photometry` the units
+    are *maggies*. Maggies are a linear flux density unit  defined as
+    :math:`{\rm maggie} = 10^{-0.4 \, m_{AB}}` where :math:`m_{AB}` is the AB
+    apparent magnitude. That is, 1 maggie is the flux density in Janskys divided
+    by 3631. If absolute spectrophotometry is available, the units for a
+    `Spectrum`` should also be maggies, otherwise photometry must be present and
+    a calibration vector must be supplied or fit.
+
+- ``uncertainty``
+    The uncertainty vector (sigma), in same units as ``flux``, ndarray of same
+    length as the wavelength vector.
+
+- ``mask``
+   A boolean array of same length as the wavelength vector, where ``False``
+   elements are ignored in the likelihood calculation.
+
+- ``filters``
+   For a `Photometry`, this is a list of strings corresponding to filter names
+   in `sedpy <https://github.com/bd-j/sedpy>`_
+
+
+In addition to these attributes, several additional aspects of an observation
+are used to help predict data or to compute likelihoods.  The latter is
+particularly important in the case of complicated noise models, including outlier
+models, jitter terms, or covariant noise.
+
+- ``name``
+  A string that can be used to identify the dataset.  This can be useful for
+  dataset-specfic parameters.
+
+- ``resolution``
+   For a `Spectrum` this defines the instrumental resolution.  Analagously to
+   the ``filters`` attribute for `Photometry`, this knowledge is used to
+   accurately predict the model in the space of the data.
+
+- ``noise`` A :py:class:`NoiseModel` instance.  By default this implements a
+  simple chi-square calculation of independent noise, but it can be
+  complexified.
+
+
+Example
+-------
+
+For a single observation, you might do something like:
+
+.. code-block:: python
+
+        def build_obs(N):
+            from prospect.data import Spectrum
+            # dummy observation dictionary with just a spectrum
+            N = 1000
+            spec = Spectrum(wavelength=np.linspace(3000, 5000, N), flux=np.zeros(N), uncertainty=np.ones(N))
+            # ensure that this is a valid observation for fitting
+            spec = spec.rectify()
+            observations = [spec]
+
+            return observations
+
+Note that `build_obs` returns a *list* even if there is only one dataset.
+
+
+Converting from old style obs dictionaries
+------------------------------------------
+
+A tool exists to convert old combined observation dictionaries to a list of
+`Observation` instances:
 
 .. code-block:: python
 
-        from prospect.utils.obsutils import fix_obs
+        from prospect.data import from_oldstyle
         # dummy observation dictionary with just a spectrum
         N = 1000
-        obs = dict(wavelength=np.linspace(3000, 5000, N), spectrum=np.zeros(N), unc=np.ones(N))
-        obs = fix_obs(obs)
-        assert "mask" in obs.keys()
+        obs = dict(wavelength=np.linspace(3000, 5000, N), spectrum=np.zeros(N), unc=np.ones(N),
+                   filters=[f"sdss_{b}0" for b in "ugriz"], maggies=np.zeros(5), maggies_unc=np.ones(5))
+        # ensure that this is a valid observation for fitting
+        spec, phot = from_oldstyle(obs)
+        print(spec.ndata, phot.filternames, phot.wavelength, phot.flux)
+
 
-It is recommended to use this method at the end of any `build_obs` function.
 
 The :py:meth:`build_obs` function
 ---------------------------------
 
 The :py:meth:`build_obs` function in the parameter file is written by the user.
 It should take a dictionary of command line arguments as keyword arguments. It
-should return an ``obs`` dictionary described above.
+should return a list of :py:class:`prospect.data.Observation` instances,
+described above.
 
 Other than that, the contents can be anything. Within this function you might
 open and read FITS files, ascii tables, HDF5 files, or query SQL databases. You
@@ -90,7 +122,11 @@ The point of this function is that you don't have to *externally* convert your
 data format to be what |Codename| expects and keep another version of files
 lying around: the conversion happens *within* the code itself. Again, the only
 requirement is that the function can take a ``run_params`` dictionary as keyword
-arguments and that it return an ``obs`` dictionary as described below.
+arguments and that it return :py:class:`prospect.data.Observation` instances, as
+ described above.  Each observation instance should correspond to a particular
+ dataset (e.g. a broadband photomtric SED, the spectrum from a particular
+ instrument, or the spectrum from a particular night) that shares instrumental
+ and, more importantly, calibration parameters.
 
 
 .. |Codename| replace:: Prospector
diff --git a/doc/faq.rst b/doc/faq.rst
index 47b50daa..3dbbfad8 100644
--- a/doc/faq.rst
+++ b/doc/faq.rst
@@ -56,7 +56,7 @@ There are several extra considerations that come up when fitting spectroscopy
       Prospector includes methods for FFT based smoothing of the spectra,
       assuming a gaussian LSF (in either wavelength or velocity space). There is
       also the possibility of FFT based smoothing for wavelength dependent
-      gaussian dispersion (i.e. sigma_lambda = f(lambda) with f possibly a
+      Gaussian dispersion (i.e. sigma_lambda = f(lambda) with f possibly a
       polynomial of lambda). In practice the smoothed spectra will be a
       combination of the library resolution plus whatever FFT smoothing is
       applied. Hopefully this can be made to match your actual data resolution,
diff --git a/doc/index.rst b/doc/index.rst
index 376bfbc2..a6817275 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -33,6 +33,7 @@ Prospector allows you to:
    models
    sfhs
    nebular
+   noise
    output
    ref
 
diff --git a/doc/models.rst b/doc/models.rst
index 89c06f9f..4104b01e 100644
--- a/doc/models.rst
+++ b/doc/models.rst
@@ -190,8 +190,8 @@ inspect the free and fixed parameters in a given set, you can do something like
         # This dictionary can be updated or modified, to expand the model.
         model_params.update(TemplateLibrary["nebular"])
 		# Instantiate a model object
-		from prospect.models import SedModel
-		model = SedModel(model_params)
+		from prospect.models import SpecModel
+		model = SpecModel(model_params)
 
 
 The ``build_model()`` Method
diff --git a/doc/noise.rst b/doc/noise.rst
new file mode 100644
index 00000000..5e0ac575
--- /dev/null
+++ b/doc/noise.rst
@@ -0,0 +1,58 @@
+Noise Modeling
+============
+
+The noise model for each dataset is used to define the likelihood function,
+given the observed data and the model prediction.  As such, each dataset or
+``Observation`` is assigned its own noise model.  By default this is the basic
+:math:`\chi^2` noise model.  Complications are described below
+
+
+Outliers
+--------
+
+For outlier modeling we follow `hogg10 <https://arxiv.org/abs/1008.4686>`_
+
+The key parameters of this noise model are the fraction of datapoints in a given
+dataset that are outliers, and the typical variance of the outliers.  Each
+dataset might have a different outlier parameters, and so we need to find a way
+to identify which outlier model parameter belongs with which dataset.  This can
+be done when the noise model is assigned to a dataset.  For example, if we had a
+single photometric dataset and a single spectroscopic dataset, with outlier
+model parameters for each given by ``("f_outlier_phot", "nsigma_outlier_phot")``
+and ``("f_outlier_spec", "nsigma_outlier_spec")``  respectively (this is the
+default parameter set available as a template) then we could associate these
+parameter with each dataset as follows:
+
+.. code-block:: python
+
+    from prospect.data import Photometry, Spectrum
+    from prospect.likelihood import NoiseModel
+    filternames = [f"sdss_{b}0" for b in "ugriz"]
+    N = len(fnames)
+    pdat = Photometry(filters=filternames, flux=np.zeros(N), uncertainty=np.ones(N),
+                      noise=NoiseModel(frac_out_name="f_outlier_phot",
+                                       nsigma_out_name="nsigma_outlier_phot"))
+    N = 1000
+    sdat = Spectrum(wavelength=np.linspace(4e3, 7e3, N), np.zeros(N), np.ones(N),
+                    noise=NoiseModel(frac_out_name="f_outlier_spec",
+                                     nsigma_out_name="nsigma_outlier_spec"))
+
+This can be combined with other Noise models, as long as they have diagonal
+(1-dimensional) covariance matices.
+
+
+Jitter
+------
+
+
+
+Correlated Noise
+----------------
+
+
+KDE Noise
+---------
+
+
+
+.. |Codename| replace:: Prospector
diff --git a/doc/quickstart.rst b/doc/quickstart.rst
index 773d6b2d..2181b976 100644
--- a/doc/quickstart.rst
+++ b/doc/quickstart.rst
@@ -35,25 +35,32 @@ get spectral data so we know the redshift.
     shdus = SDSS.get_spectra(plate=2101, mjd=53858, fiberID=220)[0]
     assert int(shdus[2].data["SpecObjID"][0]) == cat[0]["specObjID"]
 
-Now we will put this data in a dictionary with format expected by prospector. We
-convert the magnitudes to maggies, convert the magnitude errors to flux
-uncertainties (including a noise floor), and load the filter transmission curves
-using `sedpy`. We'll store the redshift here as well for convenience.  Note that
-for this example we do *not* attempt to fit the spectrum at the same time.
+Now we will put this data in the format expected by prospector. We convert the
+magnitudes to maggies, convert the magnitude errors to flux uncertainties
+(including a noise floor), and load the filter transmission curves using
+`sedpy`. We'll store the redshift here as well for convenience.  Note that for
+this example we do *not* attempt to fit the spectrum at the same time, though we
+include an empty Spectrum data set to force a prediction of the full spectrum.
 
 .. code:: python
 
     from sedpy.observate import load_filters
-    from prospect.utils.obsutils import fix_obs
+    from prospect.data import Photometry, Spectrum
 
     filters = load_filters([f"sdss_{b}0" for b in bands])
     maggies = np.array([10**(-0.4 * cat[0][f"cModelMag_{b}"]) for b in bands])
     magerr = np.array([cat[0][f"cModelMagErr_{b}"] for b in bands])
     magerr = np.clip(magerr, 0.05, np.inf)
 
-    obs = dict(wavelength=None, spectrum=None, unc=None, redshift=shdus[2].data[0]["z"],
-               maggies=maggies, maggies_unc=magerr * maggies / 1.086, filters=filters)
-    obs = fix_obs(obs)
+    pdat = Photometry(filters=filters, flux=maggies, uncertainty=magerr*maggies/1.086)
+    sdat = Spectrum(wavelength=None, flux=None, uncertainty=None)
+    observations = [sdat, pdat]
+    for obs in observations:
+        obs.redshift = shdus[2].data[0]["z"]
+
+In principle we could also add noise models for the spectral and photometric
+data (e.g. to fit for the photometric noise floor), but we'll make the default
+assumption of iid Gaussian noise for the moment.
 
 
 Build a Model
@@ -77,13 +84,6 @@ should be replaced or adjusted depending on your particular science question.
     assert len(model.free_params) == 5
     print(model)
 
-In principle we could also add noise models for the spectral and photometric
-data, but we'll make the default assumption of independent Gaussian noise for the moment.
-
-.. code:: python
-
-    noise_model = (None, None)
-
 
 Get a 'Source'
 --------------
@@ -112,7 +112,7 @@ the free parameters.
 
     current_parameters = ",".join([f"{p}={v}" for p, v in zip(model.free_params, model.theta)])
     print(current_parameters)
-    spec, phot, mfrac = model.predict(model.theta, obs=obs, sps=sps)
+    (spec, phot), mfrac = model.predict(model.theta, observations, sps=sps)
     print(phot / obs["maggies"])
 
 
@@ -128,8 +128,8 @@ minutes.
 .. code:: python
 
     from prospect.fitting import lnprobfn, fit_model
-    fitting_kwargs = dict(nlive_init=400, nested_method="rwalk", nested_target_n_effective=1000, nested_dlogz_init=0.05)
-    output = fit_model(obs, model, sps, optimize=False, dynesty=True, lnprobfn=lnprobfn, noise=noise_model, **fitting_kwargs)
+    fitting_kwargs = dict(nlive_init=400, nested_method="rwalk", nested_target_n_effective=10000, nested_dlogz_init=0.05)
+    output = fit_model(obs, model, sps, optimize=False, dynesty=True, lnprobfn=lnprobfn, **fitting_kwargs)
     result, duration = output["sampling"]
 
 The ``result`` is a dictionary with keys giving the Monte Carlo samples of
diff --git a/doc/usage.rst b/doc/usage.rst
index ed52092e..feb9b7c9 100644
--- a/doc/usage.rst
+++ b/doc/usage.rst
@@ -100,7 +100,7 @@ The required methods in a **parameter file** for building the data and model are
 
 1. :py:meth:`build_obs`:
    This function will take the command line arguments dictionary as keyword arguments
-   and returns on obs dictionary (see :doc:`dataformat` .)
+   and returns a list of `Observation` instances (see :doc:`dataformat` .)
 
 2. :py:meth:`build_model`:
    This function will take the command line arguments dictionary dictionary as keyword arguments
@@ -115,9 +115,11 @@ The required methods in a **parameter file** for building the data and model are
     building code and as such has a large memory footprint.
 
 4.  :py:meth:`build_noise`:
-    This function should return a :py:class:`NoiseModel` object for the spectroscopy and/or
-    photometry. Either or both can be ``None`` (the default)  in which case the likelihood
-    will not include covariant noise or jitter and is equivalent to basic :math:`\chi^2`.
+    This function, if present, should add a :py:class:`NoiseModel` object to the
+    spectroscopy and/or photometry. If not present the likelihood will not
+    include covariant noise or jitter and is equivalent to basic :math:`\chi^2`.
+
+
 
 Using MPI
 ---------
diff --git a/prospect/data/observation.py b/prospect/data/observation.py
index 85936802..9b9e053d 100644
--- a/prospect/data/observation.py
+++ b/prospect/data/observation.py
@@ -94,7 +94,7 @@ def rectify(self, for_fitting=False):
                      (np.isfinite(self.uncertainty)) &
                      (self.uncertainty > 0))
 
-        assert self.ndof == 0, f"{self.__repr__()} has no valid data to fit: check the sign of the masks."
+        assert self.ndof > 0, f"{self.__repr__()} has no valid data to fit: check the sign of the masks."
         assert hasattr(self, "noise")
 
     def render(self, wavelength, spectrum):
@@ -116,6 +116,7 @@ def ndata(self):
     def serialize(self):
         obs = vars(self)
         serial = json.dumps(obs, cls=NumpyEncoder)
+        return serial
 
 
 class Photometry(Observation):
diff --git a/prospect/likelihood/__init__.py b/prospect/likelihood/__init__.py
index e29b349e..5cf69c3a 100644
--- a/prospect/likelihood/__init__.py
+++ b/prospect/likelihood/__init__.py
@@ -1,5 +1,5 @@
 from .likelihood import *
 from .noise_model import *
 
-__all__ = ["lnlike_spec", "lnlike_phot", "NoiseModel", "NoiseModelKDE"] 
+__all__ = ["lnlike_spec", "lnlike_phot", "NoiseModel", "NoiseModelCov", "NoiseModelKDE"]
 
diff --git a/prospect/likelihood/noise_model.py b/prospect/likelihood/noise_model.py
index 1f6b18de..5683cb21 100644
--- a/prospect/likelihood/noise_model.py
+++ b/prospect/likelihood/noise_model.py
@@ -19,14 +19,14 @@ class NoiseModel:
     f_outlier = 0
     n_sigma_outlier = 50
 
-    def __init__(self, f_outlier_name="f_outlier", n_sigma_name="nsigma_outlier"):
-        self.f_outlier_name = f_outlier_name
-        self.n_sigma_name = n_sigma_name
+    def __init__(self, frac_out_name="f_outlier", nsigma_out_name="nsigma_outlier"):
+        self.frac_out_name = frac_out_name
+        self.nsigma_out_name = nsigma_out_name
         self.kernels = []
 
     def update(self, **params):
-        self.f_outlier = params.get(self.f_outlier_name, 0)
-        self.n_sigma_outlier = params.get(self.n_sigma_name, 50)
+        self.f_outlier = params.get(self.frac_out_name, 0)
+        self.n_sigma_outlier = params.get(self.nsigma_out_name, 50)
         [k.update(**params) for k in self.kernels]
 
     def lnlike(self, pred, obs, vectors={}):
@@ -84,11 +84,11 @@ class NoiseModelCov(NoiseModel):
     """This object allows for 1d or 2d covariance matrices constructed from kernels
     """
 
-    def __init__(self, f_outlier_name="f_outlier", n_sigma_name="nsigma_outlier",
+    def __init__(self, frac_out_name="f_outlier", nsigma_out_name="nsigma_outlier",
                  metric_name='', mask_name='mask', kernels=[], weight_by=[]):
 
-        super().__init__(f_outlier_name=f_outlier_name,
-                         n_sigma_name=n_sigma_name)
+        super().__init__(frac_out_name=frac_out_name,
+                         nsigma_out_name=nsigma_out_name)
         assert len(kernels) == len(weight_by)
         self.kernels = kernels
         self.weight_names = weight_by
diff --git a/tests/test_eline.py b/tests/test_eline.py
index 05197f69..a25f1285 100644
--- a/tests/test_eline.py
+++ b/tests/test_eline.py
@@ -167,13 +167,12 @@ def test_eline_implementation():
     model = SpecModel(model_pars)
     (spec_nolya, phot_nolya), mfrac = model.predict(model.theta, obslist, sps=sps)
     assert np.any((phot - phot_nolya) / phot != 0.0)
-    lint = np.trapz(spec - spec_nolya, obs["wavelength"])
+    lint = np.trapz(spec - spec_nolya, obslist[0]["wavelength"])
     assert lint > 0
 
     # test igoring a line, phot only
     model = SpecModel(model_pars)
     (phot_nolya_2,), mfrac = model.predict(model.theta, [obslist[1]], sps=sps)
-    obs["spectrum"] = obs_spec
     assert np.all(phot_nolya == phot_nolya_2)
 
     #import matplotlib.pyplot as pl

From 115b13253e9a04c5a49cee3c23f3beaaa9d21c94 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 3 May 2022 10:03:38 -0400
Subject: [PATCH 026/132] Remove utils.smoothing, switch to using astro-sedpy
 for smoothing.

---
 doc/requirements.txt             |   2 +-
 prospect/models/sedmodel.py      |   2 +-
 prospect/plotting/sed.py         |   2 +-
 prospect/sources/galaxy_basis.py |   2 +-
 prospect/sources/ssp_basis.py    |   2 +-
 prospect/sources/star_basis.py   |   2 +-
 prospect/utils/smoothing.py      | 669 -------------------------------
 tests/tests_smoothing.py         |   2 +-
 8 files changed, 7 insertions(+), 676 deletions(-)
 delete mode 100644 prospect/utils/smoothing.py

diff --git a/doc/requirements.txt b/doc/requirements.txt
index a2d257eb..ff97cf28 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -3,7 +3,7 @@ scipy >= 1.1.0
 matplotlib >= 3.0
 astropy
 h5py
-astro-sedpy
+astro-sedpy >= 0.3.0
 sphinx-book-theme
 myst-nb
 numpydoc
\ No newline at end of file
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 94d9aba6..98525e45 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -13,11 +13,11 @@
 from scipy.stats import multivariate_normal as mvn
 
 from sedpy.observate import getSED
+from sedpy.smoothing import smoothspec
 
 from .parameters import ProspectorParams
 from ..sources.constants import to_cgs_at_10pc as to_cgs
 from ..sources.constants import cosmo, lightspeed, ckms, jansky_cgs
-from ..utils.smoothing import smoothspec
 
 
 __all__ = ["SpecModel", "PolySpecModel", "SplineSpecModel",
diff --git a/prospect/plotting/sed.py b/prospect/plotting/sed.py
index c0625bab..6a3c12de 100644
--- a/prospect/plotting/sed.py
+++ b/prospect/plotting/sed.py
@@ -3,7 +3,7 @@
 
 import numpy as np
 
-from ..utils.smoothing import smoothspec
+from sedpy.smoothing import smoothspec
 
 __all__ = ["convolve_spec", "to_nufnu"]
 
diff --git a/prospect/sources/galaxy_basis.py b/prospect/sources/galaxy_basis.py
index 6333f2ca..f767d150 100644
--- a/prospect/sources/galaxy_basis.py
+++ b/prospect/sources/galaxy_basis.py
@@ -2,8 +2,8 @@
 import numpy as np
 from copy import deepcopy
 
+from sedpy.smoothing import smoothspec
 from .ssp_basis import SSPBasis
-from ..utils.smoothing import smoothspec
 from .constants import cosmo, lightspeed, jansky_cgs, to_cgs_at_10pc
 
 try:
diff --git a/prospect/sources/ssp_basis.py b/prospect/sources/ssp_basis.py
index 156a2b80..c4b17411 100644
--- a/prospect/sources/ssp_basis.py
+++ b/prospect/sources/ssp_basis.py
@@ -2,7 +2,7 @@
 import numpy as np
 from numpy.polynomial.chebyshev import chebval
 
-from ..utils.smoothing import smoothspec
+from sedpy.smoothing import smoothspec
 from .constants import cosmo, lightspeed, jansky_cgs, to_cgs_at_10pc
 
 try:
diff --git a/prospect/sources/star_basis.py b/prospect/sources/star_basis.py
index abe733ad..7f532d61 100644
--- a/prospect/sources/star_basis.py
+++ b/prospect/sources/star_basis.py
@@ -3,7 +3,7 @@
 from numpy.polynomial.chebyshev import chebval
 from scipy.spatial import Delaunay
 
-from ..utils.smoothing import smoothspec
+from sedpy.smoothing import smoothspec
 from .constants import lightspeed, lsun, jansky_cgs, to_cgs_at_10pc
 
 try:
diff --git a/prospect/utils/smoothing.py b/prospect/utils/smoothing.py
deleted file mode 100644
index dc90ef58..00000000
--- a/prospect/utils/smoothing.py
+++ /dev/null
@@ -1,669 +0,0 @@
-# Spectral smoothing functionality
-# To do:
-# 3) add extra zero-padding for FFT algorithms so they don't go funky at the
-#    edges?
-
-import numpy as np
-from numpy.fft import fft, ifft, fftfreq, rfftfreq
-
-__all__ = ["smoothspec", "smooth_wave", "smooth_vel", "smooth_lsf",
-           "smooth_wave_fft", "smooth_vel_fft", "smooth_fft", "smooth_lsf_fft",
-           "mask_wave", "resample_wave"]
-
-ckms = 2.998e5
-sigma_to_fwhm = 2.355
-
-
-def smoothspec(wave, spec, resolution=None, outwave=None,
-               smoothtype="vel", fftsmooth=True,
-               min_wave_smooth=0, max_wave_smooth=np.inf, **kwargs):
-    """
-    Parameters
-    ----------
-    wave : ndarray of shape ``(N_pix,)``
-        The wavelength vector of the input spectrum.  Assumed Angstroms.
-
-    spec : ndarray of shape ``(N_pix,)``
-        The flux vector of the input spectrum.
-
-    resolution : float
-        The smoothing parameter.  Units depend on ``smoothtype``.
-
-    outwave : ``None`` or ndarray of shape ``(N_pix_out,)``
-        The output wavelength vector.  If ``None`` then the input wavelength
-        vector will be assumed, though if ``min_wave_smooth`` or
-        ``max_wave_smooth`` are also specified, then the output spectrum may
-        have different length than ``spec`` or ``wave``, or the convolution may
-        be strange outside of ``min_wave_smooth`` and ``max_wave_smooth``.
-        Basically, always set ``outwave`` to be safe.
-
-    smoothtype : string, optional, default: "vel"
-        The type of smoothing to perform.  One of:
-
-        + ``"vel"`` - velocity smoothing, ``resolution`` units are in km/s
-          (dispersion not FWHM)
-        + ``"R"`` - resolution smoothing, ``resolution`` is in units of
-          :math:`\lambda/ \sigma_\lambda` (where :math:`\sigma_\lambda` is
-          dispersion, not FWHM)
-        + ``"lambda"`` - wavelength smoothing.  ``resolution`` is in units of
-          Angstroms
-        + ``"lsf"`` - line-spread function.  Use an aribitrary line spread
-          function, which can be given as a vector the same length as ``wave``
-          that gives the dispersion (in AA) at each wavelength.  Alternatively,
-          if ``resolution`` is ``None`` then a line-spread function must be
-          present as an additional ``lsf`` keyword.  In this case all additional
-          keywords as well as the ``wave`` vector will be passed to this ``lsf``
-          function.
-
-    fftsmooth : bool, optional, default: True
-        Switch to use FFTs to do the smoothing, usually resulting in massive
-        speedups of all algorithms.  However, edge effects may be present.
-
-    min_wave_smooth : float, optional default: 0
-        The minimum wavelength of the input vector to consider when smoothing
-        the spectrum.  If ``None`` then it is determined from the output
-        wavelength vector and padded by some multiple of the desired resolution.
-
-    max_wave_smooth : float, optional, default: inf
-        The maximum wavelength of the input vector to consider when smoothing
-        the spectrum.  If None then it is determined from the output wavelength
-        vector and padded by some multiple of the desired resolution.
-
-    inres : float, optional
-        If given, this parameter specifies the resolution of the input.  This
-        resolution is subtracted in quadrature from the target output resolution
-        before the kernel is formed.
-
-        In certain cases this can be used to properly switch from resolution
-        that is constant in velocity to one that is constant in wavelength,
-        taking into account the wavelength dependence of the input resolution
-        when defined in terms of lambda.  This is possible iff:
-        * ``fftsmooth`` is False
-        * ``smoothtype`` is ``"lambda"``
-        * The optional ``in_vel`` parameter is supplied and True.
-
-        The units of ``inres`` should be the same as the units of
-        ``resolution``, except in the case of switching from velocity to
-        wavelength resolution, in which case the units of ``inres`` should be
-        in units of lambda/sigma_lambda.
-
-    in_vel : float (optional)
-        If supplied and True, the ``inres`` parameter is assumed to be in units
-        of lambda/sigma_lambda. This parameter is ignored **unless** the
-        ``smoothtype`` is ``"lambda"`` and ``fftsmooth`` is False.
-
-    Returns
-    -------
-    flux : ndarray of shape ``(N_pix_out,)``
-        The smoothed spectrum on the `outwave` grid, ndarray.
-    """
-    if smoothtype == 'vel':
-        linear = False
-        units = 'km/s'
-        sigma = resolution
-        fwhm = sigma * sigma_to_fwhm
-        if sigma == 0.0:
-            Rsigma = np.infty
-            R = np.infty
-        else:
-            Rsigma = ckms / sigma
-            R = ckms / fwhm
-        width = Rsigma
-        assert np.size(sigma) == 1, "`resolution` must be scalar for `smoothtype`='vel'"
-
-    elif smoothtype == 'R':
-        linear = False
-        units = 'km/s'
-        Rsigma = resolution
-        sigma = ckms / Rsigma
-        fwhm = sigma * sigma_to_fwhm
-        R = ckms / fwhm
-        width = Rsigma
-        assert np.size(sigma) == 1, "`resolution` must be scalar for `smoothtype`='R'"
-        # convert inres from Rsigma to sigma (km/s)
-        try:
-            kwargs['inres'] = ckms / kwargs['inres']
-        except(KeyError):
-            pass
-
-    elif smoothtype == 'lambda':
-        linear = True
-        units = 'AA'
-        sigma = resolution
-        fwhm = sigma * sigma_to_fwhm
-        Rsigma = None
-        R = None
-        width = sigma
-        assert np.size(sigma) == 1, "`resolution` must be scalar for `smoothtype`='lambda'"
-
-    elif smoothtype == 'lsf':
-        linear = True
-        width = 100
-        sigma = resolution
-
-    else:
-        raise ValueError("smoothtype {} is not valid".format(smoothtype))
-
-    # Mask the input spectrum depending on outwave or the wave_smooth kwargs
-    mask = mask_wave(wave, width=width, outwave=outwave, linear=linear,
-                     wlo=min_wave_smooth, whi=max_wave_smooth, **kwargs)
-    w = wave[mask]
-    s = spec[mask]
-    if outwave is None:
-        outwave = wave
-
-    # Choose the smoothing method
-    if smoothtype == 'lsf':
-        if fftsmooth:
-            smooth_method = smooth_lsf_fft
-            if sigma is not None:
-                # mask the resolution vector
-                sigma = resolution[mask]
-        else:
-            smooth_method = smooth_lsf
-            if sigma is not None:
-                # convert to resolution on the output wavelength grid
-                sigma = np.interp(outwave, wave, resolution)
-    elif linear:
-        if fftsmooth:
-            smooth_method = smooth_wave_fft
-        else:
-            smooth_method = smooth_wave
-    else:
-        if fftsmooth:
-            smooth_method = smooth_vel_fft
-        else:
-            smooth_method = smooth_vel
-
-    # Actually do the smoothing and return
-    return smooth_method(w, s, outwave, sigma, **kwargs)
-
-
-def smooth_vel(wave, spec, outwave, sigma, nsigma=10, inres=0, **extras):
-    """Smooth a spectrum in velocity space.  This is insanely slow, but general
-    and correct.
-
-    :param wave:
-        Wavelength vector of the input spectrum.
-
-    :param spec:
-        Flux vector of the input spectrum.
-
-    :param outwave:
-        Desired output wavelength vector.
-
-    :param sigma:
-        Desired velocity resolution (km/s), *not* FWHM.
-
-    :param nsigma:
-        Number of sigma away from the output wavelength to consider in the
-        integral.  If less than zero, all wavelengths are used.  Setting this
-        to some positive number decreses the scaling constant in the O(N_out *
-        N_in) algorithm used here.
-
-    :param inres:
-        The velocity resolution of the input spectrum (km/s), *not* FWHM.
-    """
-    sigma_eff_sq = sigma**2 - inres**2
-    if np.any(sigma_eff_sq) < 0.0:
-        raise ValueError("Desired velocity resolution smaller than the value"
-                         "possible for this input spectrum.".format(inres))
-    # sigma_eff is in units of sigma_lambda / lambda
-    sigma_eff = np.sqrt(sigma_eff_sq) / ckms
-
-    lnwave = np.log(wave)
-    flux = np.zeros(len(outwave))
-    for i, w in enumerate(outwave):
-        x = (np.log(w) - lnwave) / sigma_eff
-        if nsigma > 0:
-            good = np.abs(x) < nsigma
-            x = x[good]
-            _spec = spec[good]
-        else:
-            _spec = spec
-        f = np.exp(-0.5 * x**2)
-        flux[i] = np.trapz(f * _spec, x) / np.trapz(f, x)
-    return flux
-
-
-def smooth_vel_fft(wavelength, spectrum, outwave, sigma_out, inres=0.0,
-                   **extras):
-    """Smooth a spectrum in velocity space, using FFTs. This is fast, but makes
-    some assumptions about the form of the input spectrum and can have some
-    issues at the ends of the spectrum depending on how it is padded.
-
-    :param wavelength:
-        Wavelength vector of the input spectrum. An assertion error will result
-        if this is not a regular grid in wavelength.
-
-    :param spectrum:
-        Flux vector of the input spectrum.
-
-    :param outwave:
-        Desired output wavelength vector.
-
-    :param sigma_out:
-        Desired velocity resolution (km/s), *not* FWHM.  Scalar or length 1 array.
-
-    :param inres:
-        The velocity resolution of the input spectrum (km/s), dispersion *not*
-        FWHM.
-    """
-    # The kernel width for the convolution.
-    sigma = np.sqrt(sigma_out**2 - inres**2)
-    if sigma <= 0:
-        return np.interp(outwave, wavelength, spectrum)
-
-    # make length of spectrum a power of 2 by resampling
-    wave, spec = resample_wave(wavelength, spectrum)
-
-    # get grid resolution (*not* the resolution of the input spectrum) and make
-    # sure it's nearly constant.  It should be, by design (see resample_wave)
-    invRgrid = np.diff(np.log(wave))
-    assert invRgrid.max() / invRgrid.min() < 1.05
-    dv = ckms * np.median(invRgrid)
-
-    # Do the convolution
-    spec_conv = smooth_fft(dv, spec, sigma)
-    # interpolate onto output grid
-    if outwave is not None:
-        spec_conv = np.interp(outwave, wave, spec_conv)
-
-    return spec_conv
-
-
-def smooth_wave(wave, spec, outwave, sigma, nsigma=10, inres=0, in_vel=False,
-                **extras):
-    """Smooth a spectrum in wavelength space.  This is insanely slow, but
-    general and correct (except for the treatment of the input resolution if it
-    is velocity)
-
-    :param wave:
-        Wavelength vector of the input spectrum.
-
-    :param spec:
-        Flux vector of the input spectrum.
-
-    :param outwave:
-        Desired output wavelength vector.
-
-    :param sigma:
-        Desired resolution (*not* FWHM) in wavelength units.  This can be a
-        vector of same length as ``wave``, in which case a wavelength dependent
-        broadening is calculated
-
-    :param nsigma: (optional, default=10)
-        Number of sigma away from the output wavelength to consider in the
-        integral.  If less than zero, all wavelengths are used.  Setting this
-        to some positive number decreses the scaling constant in the O(N_out *
-        N_in) algorithm used here.
-
-    :param inres: (optional, default: 0.0)
-        Resolution of the input, in either wavelength units or
-        lambda/dlambda (c/v).  Ignored if <= 0.
-
-    :param in_vel: (optional, default: False)
-        If True, the input spectrum has been smoothed in velocity
-        space, and ``inres`` is assumed to be in lambda/dlambda.
-
-    :returns flux:
-        The output smoothed flux vector, same length as ``outwave``.
-    """
-    # sigma_eff is in angstroms
-    if inres <= 0:
-        sigma_eff_sq = sigma**2
-    elif in_vel:
-        # Make an approximate correction for the intrinsic wavelength
-        # dependent dispersion.  This sort of maybe works.
-        sigma_eff_sq = sigma**2 - (wave / inres)**2
-    else:
-        sigma_eff_sq = sigma**2 - inres**2
-    if np.any(sigma_eff_sq < 0):
-        raise ValueError("Desired wavelength sigma is lower than the value "
-                         "possible for this input spectrum.")
-
-    sigma_eff = np.sqrt(sigma_eff_sq)
-    flux = np.zeros(len(outwave))
-    for i, w in enumerate(outwave):
-        x = (wave - w) / sigma_eff
-        if nsigma > 0:
-            good = np.abs(x) < nsigma
-            x = x[good]
-            _spec = spec[good]
-        else:
-            _spec = spec
-        f = np.exp(-0.5 * x**2)
-        flux[i] = np.trapz(f * _spec, x) / np.trapz(f, x)
-    return flux
-
-
-def smooth_wave_fft(wavelength, spectrum, outwave, sigma_out=1.0,
-                    inres=0.0, **extras):
-    """Smooth a spectrum in wavelength space, using FFTs.  This is fast, but
-    makes some assumptions about the input spectrum, and can have some
-    issues at the ends of the spectrum depending on how it is padded.
-
-    :param wavelength:
-        Wavelength vector of the input spectrum.
-
-    :param spectrum:
-        Flux vector of the input spectrum.
-
-    :param outwave:
-        Desired output wavelength vector.
-
-    :param sigma:
-        Desired resolution (*not* FWHM) in wavelength units.
-
-    :param inres:
-        Resolution of the input, in wavelength units (dispersion not FWHM).
-
-    :returns flux:
-        The output smoothed flux vector, same length as ``outwave``.
-    """
-    # restrict wavelength range (for speed)
-    # should also make nearest power of 2
-    wave, spec = resample_wave(wavelength, spectrum, linear=True)
-
-    # The kernel width for the convolution.
-    sigma = np.sqrt(sigma_out**2 - inres**2)
-    if sigma < 0:
-        return np.interp(wave, outwave, flux)
-
-    # get grid resolution (*not* the resolution of the input spectrum) and make
-    # sure it's nearly constant.  Should be by design (see resample_wave)
-    Rgrid = np.diff(wave)
-    assert Rgrid.max() / Rgrid.min() < 1.05
-    dw = np.median(Rgrid)
-
-    # Do the convolution
-    spec_conv = smooth_fft(dw, spec, sigma)
-    # interpolate onto output grid
-    if outwave is not None:
-        spec_conv = np.interp(outwave, wave, spec_conv)
-    return spec_conv
-
-
-def smooth_lsf(wave, spec, outwave, sigma=None, lsf=None, return_kernel=False,
-               **kwargs):
-    """Broaden a spectrum using a wavelength dependent line spread function.
-    This function is only approximate because it doesn't actually do the
-    integration over pixels, so for sparsely sampled points you'll have
-    problems.  This function needs to be checked and possibly rewritten.
-
-    :param wave:
-        Input wavelengths.  ndarray of shape (nin,)
-
-    :param spec:
-        Input spectrum.  ndarray of same shape as ``wave``.
-
-    :param outwave:
-        Output wavelengths, ndarray of shape (nout,)
-
-    :param sigma: (optional, default: None)
-        The dispersion (not FWHM) as a function of wavelength that you want to
-        apply to the input spectrum.  ``None`` or ndarray of same length as
-        ``outwave``.  If ``None`` then the wavelength dependent dispersion will be
-        calculated from the function supplied with the ``lsf`` keyward.
-
-    :param lsf:
-        A function that returns the gaussian dispersion at each wavelength.
-        This is assumed to be in sigma, not FWHM.
-
-    :param kwargs:
-        Passed to the function supplied in the ``lsf`` keyword.
-
-    :param return_kernel: (optional, default: False)
-        If True, return the kernel used to broaden the spectrum as ndarray of
-        shape (nout, nin).
-
-    :returns newspec:
-        The broadened spectrum, same length as ``outwave``.
-    """
-    if (lsf is None) and (sigma is None):
-        return np.interp(outwave, wave, spec)
-    dw = np.gradient(wave)
-    if sigma is None:
-        sigma = lsf(outwave, **kwargs)
-    kernel = outwave[:, None] - wave[None, :]
-    kernel = (1 / (sigma * np.sqrt(np.pi * 2))[:, None] *
-              np.exp(-kernel**2 / (2 * sigma[:, None]**2)) *
-              dw[None, :])
-    # should this be axis=0 or axis=1?
-    kernel = kernel / kernel.sum(axis=1)[:, None]
-    newspec = np.dot(kernel, spec)
-    # kernel /= np.trapz(kernel, wave, axis=1)[:, None]
-    # newspec = np.trapz(kernel * spec[None, :], wave, axis=1)
-    if return_kernel:
-        return newspec, kernel
-    return newspec
-
-
-def smooth_lsf_fft(wave, spec, outwave, sigma=None, lsf=None, pix_per_sigma=2,
-                   eps=0.25, preserve_all_input_frequencies=False, **kwargs):
-    """Smooth a spectrum by a wavelength dependent line-spread function, using
-    FFTs.
-
-    :param wave:
-        Wavelength vector of the input spectrum.
-
-    :param spectrum:
-        Flux vector of the input spectrum.
-
-    :param outwave:
-        Desired output wavelength vector.
-
-    :param sigma: (optional)
-        Dispersion (in same units as ``wave``) as a function `wave`.  ndarray
-        of same length as ``wave``.  If not given, sigma will be computed from
-        the function provided by the ``lsf`` keyword.
-
-    :param lsf: (optional)
-        Function used to calculate the dispersion as a function of wavelength.
-        Must be able to take as an argument the ``wave`` vector and any extra
-        keyword arguments and return the dispersion (in the same units as the
-        input wavelength vector) at every value of ``wave``.  If not provided
-        then ``sigma`` must be specified.
-
-    :param pix_per_sigma: (optional, default: 2)
-        Number of pixels per sigma of the smoothed spectrum to use in
-        intermediate interpolation and FFT steps. Increasing this number will
-        increase the accuracy of the output (to a point), and the run-time, by
-        preserving all high-frequency information in the input spectrum.
-
-    :param preserve_all_input_frequencies: (default: False)
-        This is a switch to use a very dense sampling of the input spectrum
-        that preserves all input frequencies.  It can significantly increase
-        the call time for often modest gains...
-
-    :param eps: (optional)
-        Deprecated.
-
-    :param **kwargs:
-        All additional keywords are passed to the function supplied to the
-        ``lsf`` keyword, if present.
-
-    :returns flux:
-        The input spectrum smoothed by the wavelength dependent line-spread
-        function.  Same length as ``outwave``.
-    """
-    # This is sigma vs lambda
-    if sigma is None:
-        sigma = lsf(wave, **kwargs)
-
-    # Now we need the CDF of 1/sigma, which provides the relationship between x and lambda
-    # does dw go in numerator or denominator?
-    # I think numerator but should be tested
-    dw = np.gradient(wave)
-    cdf = np.cumsum(dw / sigma)
-    cdf /= cdf.max()
-
-    # Now we create an evenly sampled grid in the x coordinate on the interval [0,1]
-    # and convert that to lambda using the cdf.
-    # This should result in some power of two x points, for FFT efficiency
-
-    # Furthermore, the number of points should be high enough that the
-    # resolution is critically sampled.  And we want to know what the
-    # resolution is in this new coordinate.
-    # There are two possible ways to do this
-
-    # 1) Choose a point ~halfway in the spectrum
-    # half = len(wave) / 2
-    # Now get the x coordinates of a point eps*sigma redder and bluer
-    # wave_eps = eps * np.array([-1, 1]) * sigma[halpha]
-    # x_h_eps = np.interp(wave[half] + wave_eps, wave, cdf)
-    # Take the differences to get dx and dsigma and ratio to get x per sigma
-    # x_per_sigma = np.diff(x_h_eps) / (2.0 * eps) #x_h_epsilon - x_h
-
-    # 2) Get for all points (slower?):
-    sigma_per_pixel = (dw / sigma)
-    x_per_pixel = np.gradient(cdf)
-    x_per_sigma = np.nanmedian(x_per_pixel / sigma_per_pixel)
-    N = pix_per_sigma / x_per_sigma
-
-    # Alternatively, just use the smallest dx of the input, divided by two for safety
-    # Assumes the input spectrum is critically sampled.
-    # And does not actually give x_per_sigma, so that has to be determined anyway
-    if preserve_all_input_frequencies:
-        # preserve more information in the input spectrum, even when way higher
-        # frequency than the resolution of the output.  Leads to slightly more
-        # accurate output, but with a substantial time hit
-        N = max(N, 1.0 / np.nanmin(x_per_pixel))
-
-    # Now find the smallest power of two that divides the interval (0, 1) into
-    # segments that are smaller than dx
-    nx = int(2**np.ceil(np.log2(N)))
-
-    # now evenly sample in the x coordinate
-    x = np.linspace(0, 1, nx)
-    dx = 1.0 / nx
-
-    # And now we get the spectrum at the lambda coordinates of the even grid in x
-    lam = np.interp(x, cdf, wave)
-    newspec = np.interp(lam, wave, spec)
-
-    # And now we convolve.
-    # If we did not know sigma in terms of x we could estimate it here
-    # from the resulting sigma(lamda(x)) / dlambda(x):
-    # dlam = np.gradient(lam)
-    # sigma_x = np.median(lsf(lam, **kwargs) / dlam)
-    # But the following just uses the fact that we know x_per_sigma (duh).
-    spec_conv = smooth_fft(dx, newspec, x_per_sigma)
-
-    # and interpolate back to the output wavelength grid.
-    return np.interp(outwave, lam, spec_conv)
-
-
-def smooth_fft(dx, spec, sigma):
-    """Basic math for FFT convolution with a gaussian kernel.
-
-    :param dx:
-        The wavelength or velocity spacing, same units as sigma
-
-    :param sigma:
-        The width of the gaussian kernel, same units as dx
-
-    :param spec:
-        The spectrum flux vector
-    """
-    # The Fourier coordinate
-    ss = rfftfreq(len(spec), d=dx)
-    # Make the fourier space taper; just the analytical fft of a gaussian
-    taper = np.exp(-2 * (np.pi ** 2) * (sigma ** 2) * (ss ** 2))
-    ss[0] = 0.01  # hack
-    # Fourier transform the spectrum
-    spec_ff = np.fft.rfft(spec)
-    # Multiply in fourier space
-    ff_tapered = spec_ff * taper
-    # Fourier transform back
-    spec_conv = np.fft.irfft(ff_tapered)
-    return spec_conv
-
-
-def mask_wave(wavelength, width=1, wlo=0, whi=np.inf, outwave=None,
-              nsigma_pad=20.0, linear=False, **extras):
-    """Restrict wavelength range (for speed) but include some padding based on
-    the desired resolution.
-    """
-    # Base wavelength limits
-    if outwave is not None:
-        wlim = np.array([outwave.min(), outwave.max()])
-    else:
-        wlim = np.squeeze(np.array([wlo, whi]))
-    # Pad by nsigma * sigma_wave
-    if linear:
-        wlim += nsigma_pad * width * np.array([-1, 1])
-    else:
-        wlim *= (1 + nsigma_pad / width * np.array([-1, 1]))
-    mask = (wavelength > wlim[0]) & (wavelength < wlim[1])
-    return mask
-
-
-def resample_wave(wavelength, spectrum, linear=False):
-    """Resample spectrum, so that the number of elements is the next highest
-    power of two.  This uses np.interp.  Note that if the input wavelength grid
-    did not critically sample the spectrum then there is no gaurantee the
-    output wavelength grid will.
-    """
-    wmin, wmax = wavelength.min(), wavelength.max()
-    nw = len(wavelength)
-    nnew = int(2.0**(np.ceil(np.log2(nw))))
-    if linear:
-        Rgrid = np.diff(wavelength)  # in same units as ``wavelength``
-        w = np.linspace(wmin, wmax, nnew)
-    else:
-        Rgrid = np.diff(np.log(wavelength))  # actually 1/R
-        lnlam = np.linspace(np.log(wmin), np.log(wmax), nnew)
-        w = np.exp(lnlam)
-    # Make sure the resolution really is nearly constant
-    #assert Rgrid.max() / Rgrid.min() < 1.05
-    s = np.interp(w, wavelength, spectrum)
-    return w, s
-
-
-def subtract_input_resolution(res_in, res_target, smoothtype_in, smoothtype_target, wave=None):
-    """Subtract the input resolution (in quadrature) from a target output
-    resolution to get the width of the kernel that will convolve the input to
-    the output.  Assumes all convolutions are with gaussians.
-    """
-    if smoothtype_in == "R":
-        width_in = 1.0 / res_in
-    else:
-        width_in = res_in
-    if smoothtype_target == "R":
-        width_target = 1.0 / res_target
-    else:
-        width_target = res_target
-
-    if smoothtype_in == smoothtype_target:
-        dwidth_sq = width_target**2 - width_in**2
-
-    elif (smoothtype_in == "vel") & (smoothype_target == "lambda"):
-        dwidth_sq = width_target**2 - (wave * width_in / ckms)**2
-
-    elif (smoothtype_in == "R") & (smoothype_target == "lambda"):
-        dwidth_sq = width_target**2 - (wave * width_in)**2
-
-    elif (smoothtype_in == "lambda") & (smoothtype_target == "vel"):
-        dwidth_sq = width_target**2 - (ckms * width_in / wave)**2
-
-    elif (smoothtype_in == "lambda") & (smoothtype_target == "R"):
-        dwidth_sq = width_target**2 - (width_in / wave)**2
-
-    elif (smoothtype_in == "R") & (smoothtype_target == "vel"):
-        print("srsly?")
-        return None
-    elif (smoothtype_in == "vel") & (smoothtype_target == "R"):
-        print("srsly?")
-        return None
-
-    if np.any(dwidth_sq <= 0):
-        print("Warning:  Desired resolution is better than input resolution")
-        dwidth_sq = np.clip(dwidth_sq, 0, np.inf)
-
-    if smoothtype_target == "R":
-        return 1.0 / np.sqrt(dwidth_sq)
-    else:
-        return np.sqrt(dwidth_sq)
-
-    return delta_width
diff --git a/tests/tests_smoothing.py b/tests/tests_smoothing.py
index 9ea92f13..59742339 100644
--- a/tests/tests_smoothing.py
+++ b/tests/tests_smoothing.py
@@ -6,7 +6,7 @@
 # TODO: have some tests that do not require a python-fsps install
 import numpy as np
 import matplotlib.pyplot as pl
-from prospect.utils.smoothing import smooth_fft, smooth_wave_fft, smooth_lsf_fft, smoothspec
+from sedpy.smoothing import smooth_fft, smooth_wave_fft, smooth_lsf_fft, smoothspec
 
 
 def lsf(wave, wave0=5000, a=5e-5, b=1e-7, c=1.0, **extras):

From fc68b5e4534196a0df3b134bdce17537194ab493 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 4 May 2022 09:47:09 -0400
Subject: [PATCH 027/132] Updating demos and docs for new Observation class.

---
 demo/demo_mock_params.py                  | 142 +++-----
 demo/demo_params.py                       | 111 ++----
 demo/tutorial.rst                         |  46 +--
 doc/usage.rst                             |  42 ++-
 misc/diagnostics.py                       | 418 ----------------------
 misc/fdot.py                              |  30 --
 {misc => tests/misc}/test_compsp.py       |   0
 {misc => tests/misc}/test_sft.py          |   0
 {misc => tests/misc}/test_stepsfh.py      |   0
 {misc => tests/misc}/timing_smoothspec.py |   0
 {misc => tests/misc}/timings_pyfsps.py    |   0
 {misc => tests/misc}/ztest.py             |   0
 12 files changed, 139 insertions(+), 650 deletions(-)
 delete mode 100644 misc/diagnostics.py
 delete mode 100644 misc/fdot.py
 rename {misc => tests/misc}/test_compsp.py (100%)
 rename {misc => tests/misc}/test_sft.py (100%)
 rename {misc => tests/misc}/test_stepsfh.py (100%)
 rename {misc => tests/misc}/timing_smoothspec.py (100%)
 rename {misc => tests/misc}/timings_pyfsps.py (100%)
 rename {misc => tests/misc}/ztest.py (100%)

diff --git a/demo/demo_mock_params.py b/demo/demo_mock_params.py
index b1d927c0..1647ff3a 100644
--- a/demo/demo_mock_params.py
+++ b/demo/demo_mock_params.py
@@ -18,56 +18,9 @@
 spitzer = ['spitzer_irac_ch'+n for n in '1234']
 
 
-# --------------
-# RUN_PARAMS
-# When running as a script with argparsing, these are ignored.  Kept here for backwards compatibility.
-# --------------
-
-run_params = {'verbose': True,
-              'debug': False,
-              'outfile': 'output/demo_mock',
-              'output_pickles': False,
-              # Optimization parameters
-              'do_powell': False,
-              'ftol': 0.5e-5, 'maxfev': 5000,
-              'do_levenberg': True,
-              'nmin': 10,
-              # emcee Fitter parameters
-              'nwalkers': 64,
-              'nburn': [32, 32, 64],
-              'niter': 256,
-              'interval': 0.25,
-              'initial_disp': 0.1,
-              # dynesty Fitter parameters
-              'nested_bound': 'multi',  # bounding method
-              'nested_sample': 'unif',  # sampling method
-              'nested_nlive_init': 100,
-              'nested_nlive_batch': 100,
-              'nested_bootstrap': 0,
-              'nested_dlogz_init': 0.05,
-              'nested_weight_kwargs': {"pfrac": 1.0},
-              'nested_target_n_effective': 10000,
-              # Mock data parameters
-              'snr': 20.0,
-              'add_noise': False,
-              'filterset': galex + sdss + twomass,
-              # Input mock model parameters
-              'mass': 1e10,
-              'logzsol': -0.5,
-              'tage': 12.,
-              'tau': 3.,
-              'dust2': 0.3,
-              'zred': 0.1,
-              'add_neb': False,
-              # SPS parameters
-              'zcontinuous': 1,
-              }
-
-
-# --------------
+# ----------------
 # Model Definition
-# --------------
-
+# ----------------
 def build_model(zred=0.0, add_neb=True, **extras):
     """Instantiate and return a ProspectorParams model subclass.
 
@@ -116,12 +69,12 @@ def build_model(zred=0.0, add_neb=True, **extras):
     # --- Set initial values ---
     model_params["zred"]["init"] = zred
 
-    return sedmodel.SedModel(model_params)
+    return sedmodel.SpecModel(model_params)
+
 
 # ------------------
 # Observational Data
 # ------------------
-
 def build_obs(snr=10.0, filterset=["sdss_g0", "sdss_r0"],
               add_noise=True, **kwargs):
     """Make a mock dataset.  Feel free to add more complicated kwargs, and put
@@ -139,57 +92,53 @@ def build_obs(snr=10.0, filterset=["sdss_g0", "sdss_r0"],
     :param add_noise: (optional, boolean, default: True)
         If True, add a realization of the noise to the mock spectrum
     """
-    from prospect.utils.obsutils import fix_obs
+    from prospect.data.observation import Photometry, Spectrum
 
     # We'll put the mock data in this dictionary, just as we would for real
     # data.  But we need to know which bands (and wavelengths if doing
     # spectroscopy) in which to generate mock data.
-    mock = {}
-    mock['wavelength'] = None  # No spectrum
-    mock['spectrum'] = None    # No spectrum
-    mock['filters'] = load_filters(filterset)
+    smock = Spectrum()  # no spectrum
+    pmock = Photometry(filters=filterset)
 
     # We need the models to make a mock
     sps = build_sps(**kwargs)
-    mod = build_model(**kwargs)
+    mock_model = build_model(**kwargs)
 
     # Now we get the mock params from the kwargs dict
     params = {}
-    for p in mod.params.keys():
+    for p in mock_model.params.keys():
         if p in kwargs:
             params[p] = np.atleast_1d(kwargs[p])
 
-    # And build the mock
-    mod.params.update(params)
-    spec, phot, _ = mod.mean_model(mod.theta, mock, sps=sps)
+    # And build the mock spectrum and photometry
+    mock_model.params.update(params)
+    mock_theta = mock_model.theta
+    (spec, phot), _ = mock_model.predict(mock_theta, [smock, pmock], sps=sps)
 
     # Now store some ancillary, helpful info;
     # this information is not required to run a fit.
-    mock['true_spectrum'] = spec.copy()
-    mock['true_maggies'] = phot.copy()
-    mock['mock_params'] = deepcopy(mod.params)
-    mock['mock_snr'] = snr
-    mock["phot_wave"] = np.array([f.wave_effective for f in mock["filters"]])
+    mock_info = dict(true_spectrum=spec.copy(), true_phot=phot.copy(),
+                     mock_params=deepcopy(mock_model.params), mock_theta=mock_theta.copy(),
+                     mock_snr=snr, mock_filters=filterset)
 
     # And store the photometry, adding noise if desired
+    pmock.flux = phot.copy()
     pnoise_sigma = phot / snr
+    pmock.uncertainty = pnoise_sigma
     if add_noise:
         pnoise = np.random.normal(0, 1, len(phot)) * pnoise_sigma
-        mock['maggies'] = phot + pnoise
-    else:
-        mock['maggies'] = phot.copy()
-    mock['maggies_unc'] = pnoise_sigma
-    mock['phot_mask'] = np.ones(len(phot), dtype=bool)
+        pmock.flux += pnoise
+        mock_info["noise_realization"] = pnoise
 
-    # This ensures all required keys are present
-    mock = fix_obs(mock)
+    # This ensures all required keys are present for fitting
+    pmock.rectify()
+
+    return [smock, pmock], mock_info
 
-    return mock
 
 # --------------
 # SPS Object
 # --------------
-
 def build_sps(zcontinuous=1, **extras):
     """Instantiate and return the Stellar Population Synthesis object.
 
@@ -207,21 +156,28 @@ def build_sps(zcontinuous=1, **extras):
                        compute_vega_mags=False)
     return sps
 
+
 # -----------------
-# Noise Model
+# Noise Modeling?
 # ------------------
+def build_noise(observations, **extras):
+    # use the defaults
+    return observations
 
-def build_noise(**extras):
-    return None, None
 
 # -----------
 # Everything
 # ------------
+def build_all(config):
+
+    observations, mock_info = build_obs(**config)
+    observations = build_noise(observations, **config)
+    model = build_model(**config)
+    sps = build_sps(**config)
 
-def build_all(**kwargs):
+    config["mock_info"] = mock_info
 
-    return (build_obs(**kwargs), build_model(**kwargs),
-            build_sps(**kwargs), build_noise(**kwargs))
+    return (observations, model, sps)
 
 
 if __name__ == '__main__':
@@ -251,27 +207,33 @@ def build_all(**kwargs):
     parser.add_argument('--mass', type=float, default=1e10,
                         help="Stellar mass of the mock; solar masses formed")
 
+    # --- Configure ---
     args = parser.parse_args()
-    run_params = vars(args)
-    obs, model, sps, noise = build_all(**run_params)
-
-    run_params["sps_libraries"] = sps.ssp.libraries
-    run_params["param_file"] = __file__
+    config = vars(args)
+    config["param_file"] = __file__
 
+    # --- Get fitting ingredients ---
+    obs, model, sps = build_all(config)
+    config["sps_libraries"] = sps.ssp.libraries
     print(model)
 
     if args.debug:
         sys.exit()
 
-    #hfile = setup_h5(model=model, obs=obs, **run_params)
-    hfile = "{0}_{1}_mcmc.h5".format(args.outfile, int(time.time()))
-    output = fit_model(obs, model, sps, noise, **run_params)
+    # --- Set up output ---
+    ts = time.strftime("%y%b%d-%H.%M", time.localtime())
+    hfile = f"{args.outfile}_{ts}_result.h5"
+
+    #  --- Run the actual fit ---
+    output = fit_model(obs, model, sps, **config)
 
+    print("writing to {}".format(hfile))
     writer.write_hdf5(hfile, run_params, model, obs,
                       output["sampling"][0], output["optimization"][0],
                       tsample=output["sampling"][1],
                       toptimize=output["optimization"][1],
-                      sps=sps)
+                      sps=sps
+                      )
 
     try:
         hfile.close()
diff --git a/demo/demo_params.py b/demo/demo_params.py
index 09102465..b4d8a769 100644
--- a/demo/demo_params.py
+++ b/demo/demo_params.py
@@ -8,46 +8,6 @@
 from prospect.io import write_results as writer
 
 
-# --------------
-# RUN_PARAMS
-# When running as a script with argparsing, these are ignored.  Kept here for backwards compatibility.
-# --------------
-
-run_params = {'verbose': True,
-              'debug': False,
-              'outfile': 'demo_galphot',
-              'output_pickles': False,
-              # Optimization parameters
-              'do_powell': False,
-              'ftol': 0.5e-5, 'maxfev': 5000,
-              'do_levenberg': True,
-              'nmin': 10,
-              # emcee fitting parameters
-              'nwalkers': 128,
-              'nburn': [16, 32, 64],
-              'niter': 512,
-              'interval': 0.25,
-              'initial_disp': 0.1,
-              # dynesty Fitter parameters
-              'nested_bound': 'multi',  # bounding method
-              'nested_sample': 'unif',  # sampling method
-              'nested_nlive_init': 100,
-              'nested_nlive_batch': 100,
-              'nested_bootstrap': 0,
-              'nested_dlogz_init': 0.05,
-              'nested_weight_kwargs': {"pfrac": 1.0},
-              'nested_target_n_effective': 10000,
-              # Obs data parameters
-              'objid': 0,
-              'phottable': 'demo_photometry.dat',
-              'luminosity_distance': 1e-5,  # in Mpc
-              # Model parameters
-              'add_neb': False,
-              'add_duste': False,
-              # SPS parameters
-              'zcontinuous': 1,
-              }
-
 # --------------
 # Model Definition
 # --------------
@@ -91,7 +51,7 @@ def build_model(object_redshift=0.0, fixed_metallicity=None, add_duste=False,
     # controlled by the "zred" parameter and a WMAP9 cosmology.
     if luminosity_distance > 0:
         model_params["lumdist"] = {"N": 1, "isfree": False,
-                                   "init": luminosity_distance, "units":"Mpc"}
+                                   "init": luminosity_distance, "units": "Mpc"}
 
     # Adjust model initial values (only important for optimization or emcee)
     model_params["dust2"]["init"] = 0.1
@@ -135,7 +95,7 @@ def build_model(object_redshift=0.0, fixed_metallicity=None, add_duste=False,
         model_params.update(TemplateLibrary["nebular"])
 
     # Now instantiate the model using this new dictionary of parameter specifications
-    model = sedmodel.SedModel(model_params)
+    model = sedmodel.SpecModel(model_params)
 
     return model
 
@@ -188,7 +148,7 @@ def build_obs(objid=0, phottable='demo_photometry.dat',
     # import astropy.io.fits as pyfits
     # catalog = pyfits.getdata(phottable)
 
-    from prospect.utils.obsutils import fix_obs
+    from prospect.data.observation import Photometry, Spectrum
 
     # Here we will read in an ascii catalog of magnitudes as a numpy structured
     # array
@@ -214,28 +174,22 @@ def build_obs(objid=0, phottable='demo_photometry.dat',
 
     # Build output dictionary.
     obs = {}
-    # This is a list of sedpy filter objects.    See the
-    # sedpy.observate.load_filters command for more details on its syntax.
-    obs['filters'] = load_filters(filternames)
     # This is a list of maggies, converted from mags.  It should have the same
-    # order as `filters` above.
-    obs['maggies'] = np.squeeze(10**(-mags/2.5))
-    # HACK.  You should use real flux uncertainties
-    obs['maggies_unc'] = obs['maggies'] * 0.07
-    # Here we mask out any NaNs or infs
-    obs['phot_mask'] = np.isfinite(np.squeeze(mags))
-    # We have no spectrum.
-    obs['wavelength'] = None
-    obs['spectrum'] = None
+    # order as `filternames` above.
+    maggies = np.squeeze(10**(-mags/2.5))
+    pdat = Photometry(filters=filternames, flux=maggies,
+                      uncertainty=maggies * 0.07, mask=np.isfinite(maggies))
+    # We have no spectral data, but we still want to see the predicted spectrum
+    sdat = Spectrum()
 
     # Add unessential bonus info.  This will be stored in output
-    #obs['dmod'] = catalog[ind]['dmod']
-    obs['objid'] = objid
+    pdat.distance_modulus = dm
+    pdat.objid = objid
 
-    # This ensures all required keys are present and adds some extra useful info
-    obs = fix_obs(obs)
+    # This ensures all required keys are present
+    pdat.rectify()
 
-    return obs
+    return [sdat, pdat]
 
 # --------------
 # SPS Object
@@ -251,24 +205,28 @@ def build_sps(zcontinuous=1, compute_vega_mags=False, **extras):
 # Noise Model
 # ------------------
 
-def build_noise(**extras):
-    return None, None
+def build_noise(observations, **extras):
+    # use the defaults
+    return observations
 
 # -----------
 # Everything
 # ------------
 
 def build_all(**kwargs):
+    observations = build_obs(**kwargs)
+    observations = build_noise(observations, **kwargs)
+    model = build_model(**kwargs)
+    sps = build_sps(**kwargs)
 
-    return (build_obs(**kwargs), build_model(**kwargs),
-            build_sps(**kwargs), build_noise(**kwargs))
+    return (observations, model, sps)
 
 
 if __name__ == '__main__':
 
-    # - Parser with default arguments -
+    # --- Parser with default arguments ---
     parser = prospect_args.get_parser()
-    # - Add custom arguments -
+    # --- Add custom arguments ---
     parser.add_argument('--object_redshift', type=float, default=0.0,
                         help=("Redshift for the model"))
     parser.add_argument('--add_neb', action="store_true",
@@ -283,30 +241,33 @@ def build_all(**kwargs):
     parser.add_argument('--objid', type=int, default=0,
                         help="zero-index row number in the table to fit.")
 
+    # --- Configure ---
     args = parser.parse_args()
-    run_params = vars(args)
-    obs, model, sps, noise = build_all(**run_params)
-
-    run_params["sps_libraries"] = sps.ssp.libraries
-    run_params["param_file"] = __file__
+    config = vars(args)
+    config["param_file"] = __file__
 
+    # --- Get fitting ingredients ---
+    obs, model, sps = build_all(**config)
+    config["sps_libraries"] = sps.ssp.libraries
     print(model)
 
     if args.debug:
         sys.exit()
 
-    #hfile = setup_h5(model=model, obs=obs, **run_params)
+    # --- Set up output ---
     ts = time.strftime("%y%b%d-%H.%M", time.localtime())
-    hfile = "{0}_{1}_result.h5".format(args.outfile, ts)
+    hfile = f"{args.outfile}_{ts}_result.h5"
 
-    output = fit_model(obs, model, sps, noise, **run_params)
+    #  --- Run the actual fit ---
+    output = fit_model(obs, model, sps, **config)
 
     print("writing to {}".format(hfile))
     writer.write_hdf5(hfile, run_params, model, obs,
                       output["sampling"][0], output["optimization"][0],
                       tsample=output["sampling"][1],
                       toptimize=output["optimization"][1],
-                      sps=sps)
+                      sps=sps
+                      )
 
     try:
         hfile.close()
diff --git a/demo/tutorial.rst b/demo/tutorial.rst
index 7d724805..dff8a13b 100644
--- a/demo/tutorial.rst
+++ b/demo/tutorial.rst
@@ -40,19 +40,20 @@ The executable portion of the parameter file that comes after the ``if __name__
 == "__main__"`` line is run when the parameter file is called. Here the possible
 command line arguments and their default values are defined, including any
 custom arguments that you might add. In this example we have added several
-command line arguments that control how the data is read and how the The
-supplied command line arguments are then parsed and placed in a dictionary. This
-dictionary is passed to all the ingredient building methods (described below),
-which return the data dictionary and necessary model objects. The data
-dictionary and model objects are passed to a function that runs the prospector
-fit (:py:func:`prospect.fitting.fit_model`). Finally, the fit results are
-written to an output file.
+command line arguments that control how the data is read and how the model is
+built. The supplied command line arguments are then parsed and placed in a
+**configuration** dictionary. This dictionary is passed to all the ingredient
+building methods (described below), which return the required
+:py:class:`Observation` objects and necessary model objects. The data and model
+objects are passed to a function that runs the prospector fit
+(:py:func:`prospect.fitting.fit_model`). Finally, the fit results are written to
+an output file.
 
 
 **Building the fit ingredients: build_model**
 
 Several methods must be defined in the parameter file to build the ingredients
-for the fit. The purpose of these functions and their required output are
+for the fit. The purpose of these methods and their required output are
 described here. You will want to modify some of these for your specific model
 and data. Note that each of these functions will be passed a dictionary of
 command line arguments. These command line arguments, including any you add to
@@ -65,7 +66,7 @@ First, the :py:func:`build_model` function is where the model that we will fit
 will be constructed. The specific model that you choose to construct depends on
 your data and your scientific question.
 
-We have to specify a dictionary or list of model parameter specifications (see
+We have to specify a dictionary of model parameter specifications (see
 :doc:`models`). Each specification is a dictionary that describes a single
 parameter. We can build the model by adjusting predefined sets of model
 parameter specifications, stored in the
@@ -103,17 +104,18 @@ specifications. Since ``model_params`` is a dictionary (of dictionaries), you
 can update it with other parameter set dictionaries from the
 :py:class:`TemplateLibrary`.
 
-Finally, the :py:func:`build_model` function takes the ``model_params`` dictionary or list that you build and
-uses it to instantiate a :py:class:`SedModel` object.
+Finally, the :py:func:`build_model` function takes the ``model_params``
+dictionary that you build and uses it to instantiate a :py:class:`SedModel`
+object.
 
 .. code-block:: python
 
-		from prospect.models import SedModel
+		from prospect.models import SpecModel
 		model_params = TemplateLibrary["parametric_sfh"]
 		# Turn on nebular emission and add associated parameters
 		model_params.update(TemplateLibrary["nebular"])
 		model_params["gas_logu"]["isfree"] = True
-		model = SedModel(model_params)
+		model = SpecModel(model_params)
 		print(model)
 
 
@@ -128,25 +130,25 @@ nebular and/or dust emission parameters are added to the model.
 
 **Building the fit ingredients: build_obs**
 
-The next thing to look at is the :py:func:`build_obs` function.
-This is where you take the data from whatever format you have and
-put it into the dictionary format required by |Codename| for a single object.
-This means you will have to modify this function heavily for your own use.
-But it also means you can use your existing data formats.
+The next thing to look at is the :py:func:`build_obs` function. This is where
+you take the data from whatever format you have and put it into the format
+required by |Codename| for a single object. This means you will have to modify
+this function heavily for your own use. But it also means you can use your
+existing data formats.
 
 Right now, the :py:func:`build_obs` function just reads ascii data from a file,
 picks out a row (corresponding to the photometry of a single galaxy), and then
-makes a dictionary using data in that row. You'll note that both the datafile
+makes a set of :py:class:`Observation`s using data in that row. You'll note that both the datafile
 name and the object number are keyword arguments to this function. That means
 they can be set at execution time on the command line, by also including those
-variables in the ``run_params`` dictionary. We'll see an example later.
+variables in the configuration dictionary. We'll see an example later.
 
 When you write your own :py:func:`build_obs` function, you can add all sorts of
 keyword arguments that control its output (for example, an object name or ID
 number that can be used to choose or find a single object in your data file).
 You can also import helper functions and modules. These can be either things
 like astropy, h5py, and sqlite or your own project specific modules and
-functions. As long as the output dictionary is in the right format (see
+functions. As long as the output data is in the right format (see
 dataformat.rst), the body of this function can do anything.
 
 **Building the fit ingredients: the rest**
@@ -337,7 +339,7 @@ chain.
 
         # Get the modeled spectra and photometry.
         # These have the same shape as the obs['spectrum'] and obs['maggies'] arrays.
-        spec, phot, mfrac = model.predict(theta, obs=res['obs'], sps=sps)
+        (spec, phot), mfrac = model.predict(theta, obs=res['obs'], sps=sps)
         # mfrac is the ratio of the surviving stellar mass to the formed mass (the ``"mass"`` parameter).
 
         # Plot the model SED
diff --git a/doc/usage.rst b/doc/usage.rst
index feb9b7c9..950f0931 100644
--- a/doc/usage.rst
+++ b/doc/usage.rst
@@ -42,31 +42,43 @@ writes output.
             from prospect.io import write_results as writer
 		    from prospect import prospect_args
 
-            # Get the default argument parser
+            # --- Get the default argument parser ---
             parser = prospect_args.get_parser()
             # Add custom arguments that controll the build methods
             parser.add_argument("--custom_argument_1", ...)
-            # Parse the supplied arguments, convert to a dictionary, and add this file for logging purposes
+
+            # --- Configure ---
             args = parser.parse_args()
-            run_params = vars(args)
-            run_params["param_file"] = __file__
+            config = vars(args)
+            config["param_file"] = __file__
 
-            # build the fit ingredients
-            obs, model, sps, noise = build_all(**run_params)
-            run_params["sps_libraries"] = sps.ssp.libraries
+            # --- Get fitting ingredients ---
+            obs, model, sps = build_all(**config)
+            config["sps_libraries"] = sps.ssp.libraries
+            print(model)
+
+            if args.debug:
+                sys.exit()
 
-            # Set up an output file name and run the fit
+            # --- Set up output ---
             ts = time.strftime("%y%b%d-%H.%M", time.localtime())
-            hfile = "{0}_{1}_mcmc.h5".format(args.outfile, ts)
-            output = fit_model(obs, model, sps, noise, **run_params)
+            hfile = f"{args.outfile}_{ts}_result.h5"
 
-            # Write results to output file
+            #  --- Run the actual fit ---
+            output = fit_model(obs, model, sps, **config)
+
+            print("writing to {}".format(hfile))
             writer.write_hdf5(hfile, run_params, model, obs,
-                              output["sampling"][0], output["optimization"][0],
-                              tsample=output["sampling"][1],
-                              toptimize=output["optimization"][1],
-                              sps=sps)
+                                output["sampling"][0], output["optimization"][0],
+                                tsample=output["sampling"][1],
+                                toptimize=output["optimization"][1],
+                                sps=sps
+                                )
 
+            try:
+                hfile.close()
+            except(AttributeError):
+                pass
 
 
 Command Line Options and Custom Arguments
diff --git a/misc/diagnostics.py b/misc/diagnostics.py
deleted file mode 100644
index 2e1c70d6..00000000
--- a/misc/diagnostics.py
+++ /dev/null
@@ -1,418 +0,0 @@
-#Take the results from MCMC fitting of clusters
-# and make diagnostic plots, or derive predictions for
-# observables, etc..
-
-import numpy as np
-import matplotlib.pyplot as pl
-import triangle
-import pickle
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from StringIO import StringIO
-
-
-def diagnostic_plots(sample_file, sps, model_file=None,
-                     powell_file=None, inmod=None,
-                     showpars=None,
-                     nspec=5, thin=10, start=0, outname=None):
-    """
-    Plots a number of diagnostics.  These include:
-        spectrum -
-            the observed spectrum, the spectra produced from a given number of samples of the
-            posterior parameter space, the spectrum produced from marginalized means of each
-            parameter, the spectrum at the initial position from Powell minimization, and the
-            applied calibration model.
-        spectrum_blue -
-            same as above but for the blue region of the spectrum                       
-        sed -
-            as for spectrum, but f_nu at the effective wavelength of the
-            filters is shown instead.
-        stars -
-            just the stellar  dust model for samples of the posterior.
-        spectrum_residuals -
-            plots of spectrum residuals for a given number of samples of the posterior
-        sed_residuals -
-            broadband photometry residuals, in units of f_nu
-        x_vs_step -
-            the evolution of the walkers in each parameter as a function of iteration
-        lnp_vs_step -
-            the evolution of the walkers in likelihood
-        triangle  -
-                a corner plot of parameter covariances    
-    """
-
-    #read results and set up model
-    if outname is None:
-        outname = sample_file#''.join(sample_file.split('.')[:-1])
-    sample_results, pr, model = read_pickles(sample_file, model_file=model_file,
-                                             powell_file=powell_file, inmod=inmod)
-    for k, v in model.params.iteritems():
-        try:
-            sps.params[k] = v
-        except KeyError:
-            pass
-
-    ## Plot spectra and SEDs
-    ##
-    #rindex = model_obs(sample_results, sps, photflag=0, outname=outname, nsample=nspec,
-    #                   wlo=3400, whi =10e3, start=start)
-    #_ = model_obs(sample_results, sps, photflag=0, outname=outname, rindex=rindex,
-    #             wlo=3600, whi=4450, extraname='_blue', start=start)
-    #_ = model_obs(sample_results, sps, photflag=1, outname=outname, nsample=15,
-    #              wlo=2500, whi=8.5e3, start=start)
-
-    #stellar_pop(sample_results, sps, outname=outname, nsample=nspec,
-    #              wlo=3500, whi=9.5e3, start=start,
-    #              alpha = 0.5, color = 'green')
-    
-    ## Plot spectral and SED residuals
-    ##
-    #residuals(sample_results, sps, photflag=0, outname=outname, nsample=nspec,
-    #          linewidth=0.5, alpha=0.3, color='blue', marker=None, start=start, rindex=rindex)
-    #residuals(sample_results, sps, photflag=1, outname = outname, nsample = 15,
-    #          linewidth=0.5, alpha=0.3, color='blue', marker='o', start=start, rindex=rindex)
-    
-    ## Plot parameters versus step
-    ##
-    param_evol(sample_results, outname=outname, showpars=showpars)
-    
-    ## Plot lnprob vs step (with a zoom-in)
-    ##
-    pl.figure()
-    pl.clf()
-    nwalk = sample_results['lnprobability'].shape[0]
-    for j in range(nwalk):
-        pl.plot(sample_results['lnprobability'][j,:])
-        pl.ylabel('lnP')
-        pl.xlabel('step #')
-    pl.savefig('{0}.lnP_vs_step.png'.format(outname))
-    pl.close()
-    #yl = sample_results['lnprobability'].max() + np.array([-3.0 * sample_results['lnprobability'][:,-1].std(), 10])
-    #pl.ylim(yl[0], yl[1])
-    #pl.savefig('{0}.lnP_vs_step_zoom.png'.format(outname))
-    #pl.close()
-    
-    ## Triangle plot
-    ##
-    subtriangle(sample_results, outname=outname,
-                showpars=showpars,
-                start=start, thin=thin)
-        
-    return outname, sample_results, model, pr
-
-
-def model_comp(theta, model, sps, photflag=0, inlog=True):
-    """
-    Generate and return various components of the total model for a
-    given set of parameters
-    """
-    obs, _, _ = obsdict(model.obs, photflag=photflag)
-    mask = obs['mask']
-    mu = model.mean_model(theta, sps=sps)[photflag][mask]
-    spec = obs['spectrum'][mask]
-    wave = obs['wavelength'][mask]
-    
-    if photflag == 0:
-        cal = model.calibration()[mask]
-        try:
-            #model.gp.sigma = obs['unc'][mask]/mu
-            s = model.params['gp_jitter']
-            a = model.params['gp_amplitude']
-            l = model.params['gp_length']
-            model.gp.factor(s, a, l, check_finite = False, force=True)
-            if inlog:
-                mu = np.log(mu)
-                delta = model.gp.predict(spec - mu - cal)
-            else:
-                delta = model.gp.predict(spec - mu*cal)
-        except:
-            delta = 0
-    else:
-        mask = np.ones(len(obs['wavelength']), dtype= bool)
-        cal = np.ones(len(obs['wavelength']))
-        delta = np.zeros(len(obs['wavelength']))
-        
-    return mu, cal, delta, mask, wave
-
-
-def model_obs(sample_results, sps, photflag=0, outname=None,
-              start=0, rindex =None, nsample=10,
-              wlo=3500, whi=9e3, extraname=''):
-
-    """
-    Plot the observed spectrum and overlay samples of the model
-    posterior, including different components of that model.
-    """
-    
-    title = ['Spectrum', 'SED (photometry)']
-    start = np.min([start, sample_results['chain'].shape[1]])
-    flatchain = sample_results['chain'][:,start:,:]
-    flatchain = flatchain.reshape(flatchain.shape[0] * flatchain.shape[1],
-                                  flatchain.shape[2])
-    
-    # draw samples
-    if rindex is None:
-        rindex = np.random.uniform(0, flatchain.shape[0], nsample).astype( int )
-    else:
-        nsample = len(rindex)
-    # set up the observation dictionary for spectrum or SED
-    obs, outn, marker = obsdict(sample_results, photflag)
-
-    # set up plot window and plot data
-    pl.figure()
-    pl.axhline( 0, linestyle = ':', color ='black') 
-    pl.plot(obs['wavelength'], obs['spectrum'],
-            marker=marker, linewidth=0.5,
-            color='blue', label='observed')
-    
-    # plot the minimization result
-    theta = sample_results['initial_center']
-    ypred, res, cal, mask, spop = model_components(theta, sample_results, obs, sps, photflag=photflag)
-    pl.plot(obs['wavelength'][mask], ypred + res,
-            marker=marker, alpha=0.5, linewidth=0.3,
-            color='cyan', label='minimization result')
-    
-    # loop over drawn samples and plot the model components
-    label = ['full model', 'calib.', 'GP']
-    for i in range(nsample):
-        theta = flatchain[rindex[i],:]
-        ypred, res, cal, mask, spop = model_components(theta, sample_results, obs, sps, photflag=photflag)
-        
-        pl.plot(obs['wavelength'][mask], np.zeros(mask.sum()) + res,
-                linewidth=0.5, alpha=0.5, color='red', label=label[2])
-        pl.plot(obs['wavelength'], cal * sample_results['model'].params.get('linescale', 1.0),
-                linewidth=0.5, color='magenta', label=label[1])
-        pl.plot(obs['wavelength'][mask], ypred + res,
-                marker=marker, alpha=0.5 , color='green', label=label[0])
-        label = 3 * [None]
-        
-    pl.legend(loc=0, fontsize='small')
-    pl.xlim(wlo, whi)
-    pl.xlabel(r'$\AA$')
-    pl.ylabel('Rate')
-    pl.title(title[photflag])
-    if outname is not None:
-        pl.savefig('{0}.{1}{2}.png'.format(outname, outn, extraname), dpi=300)
-        pl.close()
-    return rindex
-
-def stellar_pop(sample_results, sps, outname=None, normalize_by=None,
-                start=0, rindex=None, nsample=10,
-                wlo=3500, whi=9e3, extraname='', **kwargs):
-    """
-    Plot samples of the posterior for just the stellar population and
-    dust model.
-    """
-    start = np.min([start, sample_results['chain'].shape[1]])
-    flatchain = sample_results['chain'][:,start:,:]
-    flatchain = flatchain.reshape(flatchain.shape[0] * flatchain.shape[1],
-                                  flatchain.shape[2])
-    # draw samples
-    if rindex is None:
-        rindex = np.random.uniform(0, flatchain.shape[0], nsample).astype( int )
-    # set up the observation dictionary for spectrum or SED
-    obs, outn, marker = obsdict(sample_results, 0)
-
-    # set up plot window 
-    pl.figure()
-    pl.axhline( 0, linestyle=':', color='black')
-    
-    # loop over drawn samples and plot the model components
-    label = ['Stars & Dust']
-    xl = ''
-    for i in range(nsample):
-        theta = flatchain[rindex[i],:]
-        ypred, res, cal, mask, spop = model_components(theta, sample_results, obs, sps, photflag=0)
-        if normalize_by is not None:
-            spop /= spop[normalize_by]
-            xl = '/C'
-        pl.plot(obs['wavelength'], spop,
-                label = label[0], **kwargs)
-        label = 3 * [None]
-        
-    pl.legend(loc = 0, fontsize = 'small')
-    pl.xlim(wlo, whi)
-    pl.xlabel(r'$\AA$')
-    pl.ylabel(r'L$_\lambda {0}$ (L$_\odot/\AA$)'.format(xl))
-    if outname is not None:
-        pl.savefig('{0}.{1}{2}.png'.format(outname, 'stars', extraname), dpi=300)
-        pl.close()
-
-
-def residuals(sample_results, sps, photflag=0, outname=None,
-              nsample=5, rindex=None, start=0,
-              wlo=3600, whi=7500, **kwargs):
-    """
-    Plot residuals of the observations from samples of the model
-    posterior.  This is done in terms of relative, uncertainty
-    normalized, and absolute residuals.  Extra keywords are passed to
-    plot().
-    """
-    
-    start = np.min([start, sample_results['chain'].shape[1]])
-    flatchain = sample_results['chain'][:,start:,:]
-    flatchain = flatchain.reshape(flatchain.shape[0] * flatchain.shape[1],
-                                  flatchain.shape[2])
-    # draw samples
-    if rindex is None:
-        rindex = np.random.uniform(0, flatchain.shape[0], nsample).astype( int )
-    nsample = len(rindex)
-        
-    # set up the observation dictionary for spectrum or SED
-    obs, outn, marker = obsdict(sample_results, photflag)
-            
-    # set up plot window
-    fig, axes = pl.subplots(3,1)
-    # draw guidelines
-    [a.axhline( int(i==0), linestyle=':', color='black') for i,a in enumerate(axes)]
-    axes[0].set_ylabel('obs/model')
-    axes[0].set_ylim(0.5,1.5)
-    axes[0].set_xticklabels([])
-    axes[1].set_ylabel(r'(obs-model)/$\sigma$')
-    axes[1].set_ylim(-10,10)
-    axes[1].set_xticklabels([])
-    axes[2].set_ylabel(r'(obs-model)')
-    axes[2].set_xlabel(r'$\AA$')
-    
-    # loop over the drawn samples
-    for i in range(nsample):
-        theta = flatchain[rindex[i],:]
-        ypred, res, cal, mask, spop = model_components(theta, sample_results, obs, sps, photflag=photflag)
-        wave, ospec, mod = obs['wavelength'][mask],  obs['spectrum'][mask], (ypred + res)
-        axes[0].plot(wave, ospec / mod, **kwargs)
-        axes[1].plot(wave, (ospec - mod) / obs['unc'][mask], **kwargs)
-        axes[2].plot(wave, (ospec - mod), **kwargs)
-        
-    if photflag == 0:
-        [a.set_xlim(wlo,whi) for a in axes]
-
-    fig.subplots_adjust(hspace =0)
-    if outname is not None:
-        fig.savefig('{0}.{1}_residuals.png'.format(outname, outn), dpi=300)
-        pl.close()
-        
-def obsdict(inobs, photflag):
-    """
-    Return a dictionary of observational data, generated depending on
-    whether you're matching photometry or spectroscopy.
-    """
-    obs = inobs.copy()
-    if photflag == 0:
-        outn = 'spectrum'
-        marker = None
-    elif photflag == 1:
-        outn = 'sed'
-        marker = 'o'
-        obs['wavelength'] = np.array([f.wave_effective for f in obs['filters']])
-        obs['spectrum'] = 10**(0-0.4 * obs['mags'])
-        obs['unc'] = obs['mags_unc'] * obs['spectrum']
-        obs['mask'] = obs['mags_unc'] > 0
-        
-    return obs, outn, marker
-        
-def param_evol(sample_results, outname=None, showpars=None, start=0):
-    """
-    Plot the evolution of each parameter value with iteration #, for
-    each chain.
-    """
-    
-    chain = sample_results['chain'][:,start:,:]
-    nwalk = chain.shape[0]
-    parnames = np.array(theta_labels(sample_results['model'].theta_desc))
-
-    #restrict to desired parameters
-    if showpars is not None:
-        ind_show = np.array([p in showpars for p in parnames], dtype= bool)
-        parnames = parnames[ind_show]
-        chain = chain[:,:,ind_show]
-
-    #set up plot windows
-    ndim = len(parnames)
-    nx = int(np.floor(np.sqrt(ndim)))
-    ny = int(np.ceil(ndim*1.0/nx))
-    sz = np.array([nx,ny])
-    factor = 3.0           # size of one side of one panel
-    lbdim = 0.2 * factor   # size of left/bottom margin
-    trdim = 0.2 * factor   # size of top/right margin
-    whspace = 0.05*factor         # w/hspace size
-    plotdim = factor * sz + factor *(sz-1)* whspace
-    dim = lbdim + plotdim + trdim
-    
-    fig, axes = pl.subplots(nx, ny, figsize = (dim[1], dim[0]))
-    lb = lbdim / dim
-    tr = (lbdim + plotdim) / dim
-    fig.subplots_adjust(left=lb[1], bottom=lb[0], right=tr[1], top=tr[0],
-                        wspace=whspace, hspace=whspace)
-
-    #sequentially plot the chains in each parameter
-    for i in range(ndim):
-        ax = axes.flatten()[i]
-        for j in range(nwalk):
-            ax.plot(chain[j,:,i])
-        ax.set_title(parnames[i])
-    if outname is not None:
-        fig.savefig('{0}.x_vs_step.png'.format(outname))
-        pl.close()
-
-def theta_labels(desc):
-    """
-    Using the theta_desc parameter dictionary, return a list of the model
-    parameter names that has the same aorder as the sampling chain array
-    """
-    label, index = [], []
-    for p in desc.keys():
-        nt = desc[p]['N']
-        name = p
-        if p is 'amplitudes':
-            name = 'A'
-        if nt is 1:
-            label.append(name)
-            index.append(desc[p]['i0'])
-        else:
-            for i in xrange(nt):
-                label.append(name+'{0}'.format(i+1))
-                index.append(desc[p]['i0']+i)
-
-    return [l for (i,l) in sorted(zip(index,label))]
-
-def sample_photometry(sample_results, sps, filterlist,
-                      start=0, wthin=16, tthin=10):
-
-    chain, model = sample_results['chain'], sample_results['model']
-    for k, v in model.sps_fixed_params.iteritems():
-        sps.params[k] = v
-    model.filters = filterlist
-    nwalkers, nt, ndim = chain.shape
-    wit = range(0,nwalkers,wthin) #walkers to use
-    tit = range(start, nt, thin) #time steps to use
-    phot = np.zeros( len(wit), len(tit), len(filterlist)) #build storage
-    for i in wit:
-        for j in tit:
-            s, p, m = model.model(chain[i,j,:], sps=sps)
-            phot[i,j,:] = p
-            #mass[i,j] = m
-    return phot, wit, tit
-
-## All this because scipy changed
-# the name of one class, which shouldn't even be a class.
-
-renametable = {
-    'Result': 'OptimizeResult',
-    }
-
-def mapname(name):
-    if name in renametable:
-        return renametable[name]
-    return name
-
-def mapped_load_global(self):
-    module = mapname(self.readline()[:-1])
-    name = mapname(self.readline()[:-1])
-    klass = self.find_class(module, name)
-    self.append(klass)
-
-def load(file):
-    unpickler = pickle.Unpickler(file)
-    unpickler.dispatch[pickle.GLOBAL] = mapped_load_global
-    return unpickler.load()
diff --git a/misc/fdot.py b/misc/fdot.py
deleted file mode 100644
index 672c796f..00000000
--- a/misc/fdot.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# script to calculate the fractional change in SSP flux as a function
-# of time.
-import matplotlib.pyplot as pl
-import numpy as np
-import fsps
-sps = fsps.StellarPopulation(zcontinuous=0)
-
-# compile all metallicities
-for i, z in enumerate(sps.zlegend):
-    w, s = sps.get_spectrum(zmet=i+1)
-spec, mass, lbol = sps.all_ssp_spec(peraa=True)
-
-
-wmin, wmax, amin, amax, zmet = 1.5e3, 2e4, 0.01, 10, 4
-
-ages = 10**(sps.ssp_ages-9)
-waves = sps.wavelengths
-
-gwave = (waves < wmax) & (waves > wmin)
-gage = (ages < amax) & (ages > amin)
-
-fdot = np.diff(spec, axis=1)
-fbar = (spec[:,:-1,:] + spec[:,1:,:])/2.0
-
-pl.imshow(np.squeeze((fdot/fbar)[np.ix_(gwave, gage, [zmet])]),
-          interpolation='nearest', aspect='auto')
-
-
-
-
diff --git a/misc/test_compsp.py b/tests/misc/test_compsp.py
similarity index 100%
rename from misc/test_compsp.py
rename to tests/misc/test_compsp.py
diff --git a/misc/test_sft.py b/tests/misc/test_sft.py
similarity index 100%
rename from misc/test_sft.py
rename to tests/misc/test_sft.py
diff --git a/misc/test_stepsfh.py b/tests/misc/test_stepsfh.py
similarity index 100%
rename from misc/test_stepsfh.py
rename to tests/misc/test_stepsfh.py
diff --git a/misc/timing_smoothspec.py b/tests/misc/timing_smoothspec.py
similarity index 100%
rename from misc/timing_smoothspec.py
rename to tests/misc/timing_smoothspec.py
diff --git a/misc/timings_pyfsps.py b/tests/misc/timings_pyfsps.py
similarity index 100%
rename from misc/timings_pyfsps.py
rename to tests/misc/timings_pyfsps.py
diff --git a/misc/ztest.py b/tests/misc/ztest.py
similarity index 100%
rename from misc/ztest.py
rename to tests/misc/ztest.py

From ea31213f4f23993503f27479586258a77e744801 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 18 Jun 2022 11:34:07 -0400
Subject: [PATCH 028/132] Observation class updates.   Observation object
 methods to convert to structures, fits, h5, etc.   Better docstrings.   New
 Observation.Lines subclass.   Fix import error in sedmodel.

---
 doc/quickstart.rst           |   3 +-
 prospect/data/observation.py | 151 ++++++++++++++++++++++++++++++++---
 prospect/models/__init__.py  |   3 +-
 3 files changed, 142 insertions(+), 15 deletions(-)

diff --git a/doc/quickstart.rst b/doc/quickstart.rst
index 2181b976..d544fd75 100644
--- a/doc/quickstart.rst
+++ b/doc/quickstart.rst
@@ -52,7 +52,8 @@ include an empty Spectrum data set to force a prediction of the full spectrum.
     magerr = np.array([cat[0][f"cModelMagErr_{b}"] for b in bands])
     magerr = np.clip(magerr, 0.05, np.inf)
 
-    pdat = Photometry(filters=filters, flux=maggies, uncertainty=magerr*maggies/1.086)
+    pdat = Photometry(filters=filters, flux=maggies, uncertainty=magerr*maggies/1.086,
+                      name=f'sdss_phot_specobjID{cat[0]["specObjID"]}')
     sdat = Spectrum(wavelength=None, flux=None, uncertainty=None)
     observations = [sdat, pdat]
     for obs in observations:
diff --git a/prospect/data/observation.py b/prospect/data/observation.py
index 9b9e053d..ac301e52 100644
--- a/prospect/data/observation.py
+++ b/prospect/data/observation.py
@@ -14,6 +14,7 @@
 
 
 class NumpyEncoder(json.JSONEncoder):
+
     def default(self, obj):
         if isinstance(obj, np.ndarray):
             return obj.tolist()
@@ -36,6 +37,8 @@ class Observation:
 
     logify_spectrum = False
     alias = {}
+    meta = ["kind", "name"]
+    data = ["wavelength", "flux", "uncertainty", "mask"]
 
     def __init__(self,
                  flux=None,
@@ -46,8 +49,8 @@ def __init__(self,
                  **kwargs
                  ):
 
-        self.flux = flux
-        self.uncertainty = uncertainty
+        self.flux = np.array(flux)
+        self.uncertainty = np.array(uncertainty)
         self.mask = mask
         self.noise = noise
         self.name = name
@@ -73,30 +76,38 @@ def from_oldstyle(self, **kwargs):
             if k in kwargs:
                 setattr(self, v, kwargs[k])
 
-    def rectify(self, for_fitting=False):
+    def rectify(self):
         """Make sure required attributes for fitting are present and have the
         appropriate sizes.  Also auto-masks non-finite data or negative
         uncertainties.
         """
+        if self.flux is None:
+            print(f"{self.__repr__} has no data")
+            return
 
         assert self.wavelength.ndim == 1, "`wavelength` is not 1-d array"
         assert self.ndata > 0, "no wavelength points supplied!"
-        assert self.flux is not None, " No data."
         assert self.uncertainty is not None, "No uncertainties."
         assert len(self.wavelength) == len(self.flux), "Flux array not same shape as wavelength."
         assert len(self.wavelength) == len(self.uncertainty), "Uncertainty array not same shape as wavelength."
 
-        # make mask array with automatic filters
-        marr = np.zeros(self.ndata, dtype=bool)
-        marr[self.mask] = True
-        self.mask = (marr &
-                     (np.isfinite(self.flux)) &
-                     (np.isfinite(self.uncertainty)) &
-                     (self.uncertainty > 0))
+        self._automask()
 
         assert self.ndof > 0, f"{self.__repr__()} has no valid data to fit: check the sign of the masks."
         assert hasattr(self, "noise")
 
+    def _automask(self):
+        # make mask array with automatic filters
+        marr = np.zeros(self.ndata, dtype=bool)
+        marr[self.mask] = True
+        if self.flux is not None:
+            self.mask = (marr &
+                         (np.isfinite(self.flux)) &
+                         (np.isfinite(self.uncertainty)) &
+                         (self.uncertainty > 0))
+        else:
+            self.mask = marr
+
     def render(self, wavelength, spectrum):
         raise(NotImplementedError)
 
@@ -113,11 +124,52 @@ def ndata(self):
         else:
             return len(self.wavelength)
 
-    def serialize(self):
-        obs = vars(self)
+    def to_json(self):
+        obs = {m: getattr(self, m) for m in self.meta + self.data}
         serial = json.dumps(obs, cls=NumpyEncoder)
         return serial
 
+    def to_struct(self, data_dtype=np.float32):
+        """Convert data to a structured array
+        """
+        self._automask()
+        dtype = np.dtype([(c, data_dtype) for c in self.data])
+        struct = np.zeros(self.ndata, dtype=dtype)
+        for c in self.data:
+            data = getattr(self, c)
+            try:
+                struct[c] = data
+            except(ValueError):
+                pass
+        return struct
+
+    def to_fits(self, filename=""):
+        """
+        """
+        from astropy.io import fits
+        hdus = fits.HDUList([fits.PrimaryHDU(),
+                             fits.BinTableHDU(self.to_struct())])
+        meta = {m: getattr(self, m) for m in self.meta}
+        if "filternames" in meta:
+            meta["filters"] = ",".join(meta["filternames"])
+        for k, v in meta.items():
+            try:
+                for hdu in hdus:
+                    hdu.header[k] = v
+            except(ValueError):
+                pass
+        if filename:
+            hdus.writeto(filename, overwrite=True)
+            hdus.close()
+
+    def to_h5_dataset(self, handle):
+        dset = handle.create_dataset(self.name, data=self.to_struct())
+        for m in self.meta:
+            try:
+                dset.attr[m] = getattr(self, m)
+            except:
+                pass
+
 
 class Photometry(Observation):
 
@@ -126,9 +178,25 @@ class Photometry(Observation):
                  maggies_unc="uncertainty",
                  filters="filters",
                  phot_mask="mask")
+    meta = ["kind", "name", "filternames"]
 
     def __init__(self, filters=[], name="PhotA", **kwargs):
+        """On Observation object that holds photometric data
+
+        Parameters
+        ----------
+        filters : list of strings or list of `sedpy.observate.Filter` instances
+            The names or instances of Filters to use
 
+        flux : iterable of floats
+            The flux through the filters, in units of maggies
+
+        uncertainty : iterable of floats
+            The uncertainty on the flux
+
+        name : string, optional
+            The name for this set of data
+        """
         if type(filters[0]) is str:
             self.filternames = filters
         else:
@@ -160,6 +228,9 @@ class Spectrum(Observation):
                  wavelength="wavelength",
                  mask="mask")
 
+    data = ["wavelength", "flux", "uncertainty", "mask",
+            "resolution", "calibration"]
+
     def __init__(self,
                  wavelength=None,
                  resolution=None,
@@ -170,6 +241,15 @@ def __init__(self,
         """
         Parameters
         ----------
+        wavelength : iterable of floats
+            The wavelength of each flux measurement, in vacuum AA
+
+        flux : iterable of floats
+            The flux at each wavelength, in units of maggies, same length as ``wavelength``
+
+        uncertainty : iterable of floats
+            The uncertainty on the flux
+
         resolution : (optional, default: None)
             Instrumental resolution at each wavelength point in units of km/s
             dispersion (:math:`= c \, \sigma_\lambda / \lambda = c \, \FWHM_\lambda / 2.355 / \lambda = c / (2.355 \, R_\lambda)`
@@ -226,6 +306,51 @@ def to_oldstyle(self):
         return obs
 
 
+class Lines(Spectrum):
+
+    kind = "spectrum"
+    alias = dict(spectrum="flux",
+                 unc="uncertainty",
+                 wavelength="wavelength",
+                 mask="mask",
+                 line_inds="line_ind")
+
+    data = ["wavelength", "flux", "uncertainty", "mask",
+            "resolution", "calibration", "line_ind"]
+
+    def __init__(self,
+                 line_ind=None,
+                 name="SpecA",
+                 **kwargs):
+
+        """
+        Parameters
+        ----------
+        line_ind : iterable of int
+            The index of the lines in the FSPS spectral line array.
+
+        wavelength : iterable of floats
+            The wavelength of each flux measurement, in vacuum AA
+
+        flux : iterable of floats
+            The flux at each wavelength, in units of maggies, same length as ``wavelength``
+
+        uncertainty : iterable of floats
+            The uncertainty on the flux
+
+        resolution : (optional, default: None)
+            Instrumental resolution at each wavelength point in units of km/s
+            dispersion (:math:`= c \, \sigma_\lambda / \lambda = c \, \FWHM_\lambda / 2.355 / \lambda = c / (2.355 \, R_\lambda)`
+            where :math:`c=2.998e5 {\rm km}/{\rm s}`
+
+        :param calibration:
+            not sure yet ....
+        """
+        super(Lines, self).__init__(name=name, **kwargs)
+        assert (line_ind is not None), "You must identify the lines by their index in the FSPS emission line array"
+        self.line_ind = np.array(line_ind).as_type(int)
+
+
 def from_oldstyle(obs, **kwargs):
     """Convert from an oldstyle dictionary to a list of observations
     """
diff --git a/prospect/models/__init__.py b/prospect/models/__init__.py
index 59d362c9..c263ee34 100644
--- a/prospect/models/__init__.py
+++ b/prospect/models/__init__.py
@@ -5,7 +5,8 @@
 specifications.
 """
 
-from .sedmodel import ProspectorParams, SedModel, SpecModel
+
+from .sedmodel import ProspectorParams, SpecModel
 from .sedmodel import PolySpecModel, SplineSpecModel
 from .sedmodel import AGNSpecModel, LineSpecModel
 

From 6e16e2db727eb950df9b0081f97ef956b928620b Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 18 Jun 2022 18:26:28 -0400
Subject: [PATCH 029/132] Starting on io simplification.   Includes option to
 try to pickle model params.

---
 .github/workflows/tests.yml  |   2 +-
 prospect/io/read_results.py  | 114 +----------
 prospect/io/write_results.py | 379 ++++++++++-------------------------
 prospect/models/sedmodel.py  |   2 +-
 tests/test_predict.py        |  42 ++--
 5 files changed, 133 insertions(+), 406 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index beb1b179..c91d1434 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -36,6 +36,6 @@ jobs:
         env:
           SPS_HOME: ${{ github.workspace }}/fsps
       - name: Run tests
-        run: python -m pytest --durations=0 --maxfail=1 -vs tests/
+        run: python -m pytest --durations=0 --maxfail=1 -W ignore::DeprecationWarning --ignore tests/misc/ -vs tests/
         env:
           SPS_HOME: ${{ github.workspace }}/fsps
diff --git a/prospect/io/read_results.py b/prospect/io/read_results.py
index 119e4e1f..71508841 100644
--- a/prospect/io/read_results.py
+++ b/prospect/io/read_results.py
@@ -69,34 +69,17 @@ def results_from(filename, model_file=None, dangerous=True, **kwargs):
 
     """
     # Read the basic chain, parameter, and run_params info
-    if filename.split('.')[-1] == 'h5':
-        res = read_hdf5(filename, **kwargs)
-        if "_mcmc.h5" in filename:
-            mf_default = filename.replace('_mcmc.h5', '_model')
-        else:
-            mf_default = "x"
-    else:
-        with open(filename, 'rb') as rf:
-            res = pickle.load(rf)
-        mf_default = filename.replace('_mcmc', '_model')
+    res = read_hdf5(filename, **kwargs)
 
-    # Now try to read the model object itself from a pickle
-    if model_file is None:
-        mname = mf_default
-    else:
-        mname = model_file
+    # Now try to instantiate the model object from the paramfile
     param_file = (res['run_params'].get('param_file', ''),
                   res.get("paramfile_text", ''))
-    model, powell_results = read_model(mname, param_file=param_file,
-                                       dangerous=dangerous, **kwargs)
     if dangerous:
         try:
             model = get_model(res)
         except:
             model = None
     res['model'] = model
-    if powell_results is not None:
-        res["powell_results"] = powell_results
 
     return res, res["obs"], model
 
@@ -153,56 +136,6 @@ def emcee_restarter(restart_from="", niter=32, **kwargs):
     return obs, model, sps, noise, run_params
 
 
-def read_model(model_file, param_file=('', ''), dangerous=False, **extras):
-    """Read the model pickle.  This can be difficult if there are user defined
-    functions that have to be loaded dynamically.  In that case, import the
-    string version of the paramfile and *then* try to unpickle the model
-    object.
-
-    :param model_file:
-        String, name and path to the model pickle.
-
-    :param dangerous: (default: False)
-        If True, try to import the given paramfile.
-
-    :param param_file:
-        2-element tuple.  The first element is the name of the paramfile, which
-        will be used to set the name of the imported module.  The second
-        element is the param_file contents as a string.  The code in this
-        string will be imported.
-    """
-    model = powell_results = None
-    if os.path.exists(model_file):
-        try:
-            with open(model_file, 'rb') as mf:
-                mod = pickle.load(mf)
-        except(AttributeError):
-            # Here one can deal with module and class names that changed
-            with open(model_file, 'rb') as mf:
-                mod = load(mf)
-        except(ImportError, KeyError):
-            # here we load the parameter file as a module using the stored
-            # source string.  Obviously this is dangerous as it will execute
-            # whatever is in the stored source string.  But it can be used to
-            # recover functions (especially dependcy functions) that are user
-            # defined
-            path, filename = os.path.split(param_file[0])
-            modname = filename.replace('.py', '')
-            if dangerous:
-                user_module = import_module_from_string(param_file[1], modname)
-            with open(model_file, 'rb') as mf:
-                mod = pickle.load(mf)
-
-        model = mod['model']
-
-        for k, v in list(model.theta_index.items()):
-            if type(v) is tuple:
-                model.theta_index[k] = slice(*v)
-        powell_results = mod['powell']
-
-    return model, powell_results
-
-
 def read_hdf5(filename, **extras):
     """Read an HDF5 file (with a specific format) into a dictionary of results.
 
@@ -260,21 +193,10 @@ def read_hdf5(filename, **extras):
             res['rstate'] = unpick(res['rstate'])
         except:
             pass
-        #try:
-        #    mp = [names_to_functions(p.copy()) for p in res['model_params']]
-        #    res['model_params'] = mp
-        #except:
-        #    pass
 
     return res
 
 
-def read_pickles(filename, **kwargs):
-    """Alias for backwards compatability. Calls `results_from()`.
-    """
-    return results_from(filename, **kwargs)
-
-
 def get_sps(res):
     """This gets exactly the SPS object used in the fiting (modulo any
     changes to FSPS itself).
@@ -461,12 +383,6 @@ def traceplot(results, showpars=None, start=0, chains=slice(None),
     return fig
 
 
-def param_evol(results, **kwargs):
-    """Backwards compatability
-    """
-    return traceplot(results, **kwargs)
-
-
 def subcorner(results, showpars=None, truths=None,
               start=0, thin=1, chains=slice(None),
               logify=["mass", "tau"], **kwargs):
@@ -553,12 +469,6 @@ def subcorner(results, showpars=None, truths=None,
     return fig
 
 
-def subtriangle(results, **kwargs):
-    """Backwards compatability
-    """
-    return subcorner(results, **kwargs)
-
-
 def compare_paramfile(res, filename):
     """Compare the runtime parameter file text stored in the `res` dictionary
     to the text of some existing file with fully qualified path `filename`.
@@ -573,23 +483,3 @@ def compare_paramfile(res, filename):
     bbl = json.loads(b)
     bb = bbl.split('\n')
     pprint([l for l in unified_diff(aa, bb)])
-
-
-def names_to_functions(p):
-    """Replace names of functions (or pickles of objects) in a parameter
-    description with the actual functions (or pickles).
-    """
-    from importlib import import_module
-    for k, v in list(p.items()):
-        try:
-            m = import_module(v[1])
-            f = m.__dict__[v[0]]
-        except:
-            try:
-                f = pickle.loads(v)
-            except:
-                f = v
-
-        p[k] = f
-
-    return p
diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index d8d7a7bc..765e41b3 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -15,7 +15,7 @@
     _has_h5py_ = False
 
 
-__all__ = ["githash", "write_pickles", "write_hdf5",
+__all__ = ["githash", "write_hdf5",
            "chain_to_struct"]
 
 
@@ -28,17 +28,6 @@ def pick(obj):
     return np.void(pickle.dumps(obj, 0))
 
 
-#def run_command(cmd):
-#    """Open a child process, and return its exit status and stdout.
-#    """
-#    import subprocess
-#    child = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE,
-#                             stdin=subprocess.PIPE, stdout=subprocess.PIPE)
-#    out = [s for s in child.stdout]
-#    w = child.wait()
-#    return os.WEXITSTATUS(w), out
-
-
 def githash(**extras):
     """Pull out the git hash history for Prospector here.
     """
@@ -62,10 +51,14 @@ def paramfile_string(param_file=None, **extras):
     return pstr
 
 
-def write_hdf5(hfile, run_params, model, obs, sampler=None,
-               optimize_result_list=None, tsample=0.0, toptimize=0.0,
-               sampling_initial_center=[], sps=None, write_model_params=True,
-               **extras):
+
+def write_hdf5(hfile, run_params, model, obs,
+               sampler=None,
+               optimize_result_list=None,
+               tsample=0.0, toptimize=0.0,
+               sampling_initial_center=[],
+               write_model_params=True,
+               sps=None, **extras):
     """Write output and information to an HDF5 file object (or
     group).
 
@@ -94,55 +87,38 @@ def write_hdf5(hfile, run_params, model, obs, sampler=None,
         If a `prospect.sources.SSPBasis` object is supplied, it will be used to
         generate and store
     """
-
-    if not _has_h5py_:
-        warnings.warn("HDF5 file could not be opened, as h5py could not be imported.")
-        return
-
     # If ``hfile`` is not a file object, assume it is a filename and open
     if type(hfile) is str:
-        # Check for existence of file, modify name if it already exists
-        if os.path.exists(hfile):
-            import time
-            time_string = time.strftime("%y%b%d-%H.%M", time.localtime())
-            print("Appending current time ({0}) to output file ".format(time_string) + \
-                  "in order to guarantee a unique name.")
-            name, ext = os.path.splitext(hfile)
-            hfile = name+'_{0}'.format(time_string)+ext
-            print("New output filename: {0}".format(hfile))
-
-        hf = h5py.File(hfile, "a")
+        hf = h5py.File(hfile, "w")
     else:
         hf = hfile
 
     # ----------------------
     # Sampling info
-    try:
-        # emcee
-        a = sampler.acceptance_fraction
-        write_emcee_h5(hf, sampler, model, sampling_initial_center, tsample)
-    except(AttributeError):
-        # dynesty or nestle
-        if sampler is None:
-            sdat = hf.create_group('sampling')
-        elif 'eff' in sampler:
-            write_dynesty_h5(hf, sampler, model, tsample)
-        else:
-            write_nestle_h5(hf, sampler, model, tsample)
+    if run_params.get("emcee", False):
+        chain, extras = emcee_to_struct(sampler, model)
+    elif run_params.get("dynesty", False):
+        chain, extras = dynesty_to_struct(sampler, model)
+    else:
+        chain, extras = None, None
+    write_sampling_h5(hf, chain, extras)
+    hf.flush()
+
+    # ----------------------
+    # High level parameter and version info
+    meta = metadata(run_params, model, write_model_params=write_model_params)
+    for k, v in meta.items():
+        hf.attrs[k] = k
+    hf.flush()
 
     # -----------------
     # Optimizer info
+    hf.attrs['optimizer_duration'] = json.dumps(toptimize)
     if optimize_result_list is not None:
         out = optresultlist_to_ndarray(optimize_result_list)
         mgroup = hf.create_group('optimization')
         mdat = mgroup.create_dataset('optimizer_results', data=out)
 
-    # ----------------------
-    # High level parameter and version info
-    write_h5_header(hf, run_params, model, write_model_params=write_model_params)
-    hf.attrs['optimizer_duration'] = json.dumps(toptimize)
-    hf.flush()
-
     # ----------------------
     # Observational data
     write_obs_to_h5(hf, obs)
@@ -170,143 +146,70 @@ def write_hdf5(hfile, run_params, model, obs, sampler=None,
     hf.close()
 
 
-def write_emcee_h5(hf, sampler, model, sampling_initial_center, tsample):
-    """Write emcee information to the provided HDF5 file in the `sampling`
-    group.
-    """
-    try:
-        sdat = hf['sampling']
-    except(KeyError):
-        sdat = hf.create_group('sampling')
-    if 'chain' not in sdat:
-        sdat.create_dataset('chain',
-                            data=sampler.chain)
-        lnp = sampler.lnprobability
-        if ((lnp.shape[0] != lnp.shape[1]) &
-            (lnp.T.shape == sampler.chain.shape[:-1])):
-            # hack to deal with emcee3rc lnprob transposition
-            lnp = lnp.T
-        sdat.create_dataset('lnprobability', data=lnp)
-    sdat.create_dataset('acceptance',
-                        data=sampler.acceptance_fraction)
-    sdat.create_dataset('sampling_initial_center',
-                        data=sampling_initial_center)
-    sdat.create_dataset('initial_theta',
-                        data=model.initial_theta.copy())
-    # JSON Attrs
-    sdat.attrs['rstate'] = pick(sampler.random_state)
-    sdat.attrs['sampling_duration'] = json.dumps(tsample)
-    sdat.attrs['theta_labels'] = json.dumps(list(model.theta_labels()))
+def metadata(run_params, model, write_model_params=True):
+    meta = dict(run_params=run_params,
+                paramfile_text=paramfile_string(**run_params))
+    if write_model_params:
+        from copy import deepcopy
+        meta["model_params"] = deepcopy(model.params)
+    for k, v in list(meta.items()):
+        try:
+            meta[k] = json.dumps(v)
+        except(TypeError):
+            meta[k] = pick(v)
+        except:
+            meta[k] = unserial
 
-    hf.flush()
+    return meta
 
 
-def write_nestle_h5(hf, nestle_out, model, tsample):
-    """Write nestle results to the provided HDF5 file in the `sampling` group.
-    """
-    try:
-        sdat = hf['sampling']
-    except(KeyError):
-        sdat = hf.create_group('sampling')
-    sdat.create_dataset('chain',
-                        data=nestle_out['samples'])
-    sdat.create_dataset('weights',
-                        data=nestle_out['weights'])
-    sdat.create_dataset('lnlikelihood',
-                        data=nestle_out['logl'])
-    sdat.create_dataset('lnprobability',
-                        data=(nestle_out['logl'] +
-                              model.prior_product(nestle_out['samples'])))
-    sdat.create_dataset('logvol',
-                        data=nestle_out['logvol'])
-    sdat.create_dataset('logz',
-                        data=np.atleast_1d(nestle_out['logz']))
-    sdat.create_dataset('logzerr',
-                        data=np.atleast_1d(nestle_out['logzerr']))
-    sdat.create_dataset('h_information',
-                        data=np.atleast_1d(nestle_out['h']))
-
-    # JSON Attrs
-    for p in ['niter', 'ncall']:
-        sdat.attrs[p] = json.dumps(nestle_out[p])
-    sdat.attrs['theta_labels'] = json.dumps(list(model.theta_labels()))
-    sdat.attrs['sampling_duration'] = json.dumps(tsample)
+def emcee_to_struct(sampler, model):
+    # preamble
+    samples = sampler.get_chain(flat=True)
+    lnprior = model.prior_product(samples)
 
-    hf.flush()
+    # chaincat & extras
+    chaincat = chain_to_struct(samples, model=model)
+    extras = dict(weights=None,
+                  lnprobability=sampler.get_log_prob(flat=True),
+                  lnlike=sampler.get_log_prob(flat=True) - lnprior,
+                  acceptance=sampler.acceptance_fraction,
+                  rstate=sampler.random_state)
 
+    return chaincat, extras
 
-def write_dynesty_h5(hf, dynesty_out, model, tsample):
-    """Write nestle results to the provided HDF5 file in the `sampling` group.
-    """
-    try:
-        sdat = hf['sampling']
-    except(KeyError):
-        sdat = hf.create_group('sampling')
 
-    sdat.create_dataset('chain',
-                        data=dynesty_out['samples'])
-    sdat.create_dataset('weights',
-                        data=np.exp(dynesty_out['logwt']-dynesty_out['logz'][-1]))
-    sdat.create_dataset('logvol',
-                        data=dynesty_out['logvol'])
-    sdat.create_dataset('logz',
-                        data=np.atleast_1d(dynesty_out['logz']))
-    sdat.create_dataset('logzerr',
-                        data=np.atleast_1d(dynesty_out['logzerr']))
-    sdat.create_dataset('information',
-                        data=np.atleast_1d(dynesty_out['information']))
-    sdat.create_dataset('lnlikelihood',
-                        data=dynesty_out['logl'])
-    sdat.create_dataset('lnprobability',
-                        data=(dynesty_out['logl'] +
-                              model.prior_product(dynesty_out['samples'])))
-    sdat.create_dataset('efficiency',
-                        data=np.atleast_1d(dynesty_out['eff']))
-    sdat.create_dataset('niter',
-                        data=np.atleast_1d(dynesty_out['niter']))
-    sdat.create_dataset('samples_id',
-                        data=np.atleast_1d(dynesty_out['samples_id']))
-
-    # JSON Attrs
-    sdat.attrs['ncall'] = json.dumps(dynesty_out['ncall'].tolist())
-    sdat.attrs['theta_labels'] = json.dumps(list(model.theta_labels()))
-    sdat.attrs['sampling_duration'] = json.dumps(tsample)
+def dynesty_to_struct(dyout, model):
+    # preamble
+    lnprior = model.prior_product(dyout['samples'])
 
-    hf.flush()
+    # chaincat & extras
+    chaincat = chain_to_struct(dyout["samples"], model=model)
+    extras = dict(weights=np.exp(dyout['logwt']-dyout['logz'][-1]),
+                  lnprobability=dyout['logl'] + lnprior,
+                  lnlike=dyout['logl'],
+                  efficiency=np.atleast_1d(dyout['eff']),
+                  logz=np.atleast_1d(dyout['logz']),
+                  ncall=json.dumps(dyout['ncall'].tolist())
+                 )
+    return chaincat, extras
 
 
-def write_h5_header(hf, run_params, model, write_model_params=True):
-    """Write header information about the run.
-    """
-    serialize = {'run_params': run_params,
-                 'model_params': [functions_to_names(p.copy())
-                                  for p in model.config_list],
-                 'paramfile_text': paramfile_string(**run_params)}
+def write_sampling_h5(hf, chain, extras):
     try:
-        hf.attrs['model_params'] = pick(serialize['model_params'])
-    except:
-        serialize['model_params'] = None
-
-    if not write_model_params:
-        serialize = {'run_params': run_params,
-                     'model_params': None,
-                     'paramfile_text': paramfile_string(**run_params)}
+        sdat = hf['sampling']
+    except(KeyError):
+        sdat = hf.create_group('sampling')
 
-    for k, v in list(serialize.items()):
+    sdat.create_dataset('chain', data=chain)
+    for k, v in extras.items():
         try:
-            hf.attrs[k] = json.dumps(v)  #, cls=NumpyEncoder)
-        except(TypeError):
-            # Should this fall back to pickle.dumps?
-            hf.attrs[k] = pick(v)
-            warnings.warn("Could not JSON serialize {}, pickled instead".format(k),
-                          RuntimeWarning)
+            sdat.create_dataset(k, data=v)
         except:
-            hf.attrs[k] = unserial
-            warnings.warn("Could not serialize {}".format(k), RuntimeWarning)
-    hf.flush()
+            sdat.attrs[k] = v
 
 
-def write_obs_to_h5(hf, obs):
+def write_obs_to_h5(hf, obslist):
     """Write observational data to the hdf5 file
     """
     try:
@@ -314,25 +217,8 @@ def write_obs_to_h5(hf, obs):
     except(ValueError):
         # We already have an 'obs' group
         return
-    for k, v in list(obs.items()):
-        if k == 'filters':
-            try:
-                v = [f.name for f in v]
-            except:
-                pass
-        if isinstance(v, np.ndarray):
-            odat.create_dataset(k, data=v)
-        else:
-            try:
-                odat.attrs[k] = json.dumps(v)  #, cls=NumpyEncoder)
-            except(TypeError):
-                # Should this fall back to pickle.dumps?
-                odat.attrs[k] = pick(v)
-                warnings.warn("Could not JSON serialize {}, pickled instead".format(k))
-            except:
-                odat.attrs[k] = unserial
-                warnings.warn("Could not serialize {}".format(k))
-
+    for obs in obslist:
+        obs.to_h5_dataset(odat)
     hf.flush()
 
 
@@ -348,18 +234,28 @@ def optresultlist_to_ndarray(results):
     return out
 
 
-def chain_to_struct(chain, model=None, names=None):
+def chain_to_struct(chain, model=None, names=None, **extras):
     """Given a (flat)chain (or parameter dictionary) and a model, convert the
     chain to a structured array
 
-    :param chain:
-        A chain, ndarry of shape (nsamples, ndim) or a dictionary of
-        parameters, values of which are numpy datatypes.
+    Parameters
+    ----------
+    chain : ndarry of shape (nsamples, ndim)
+        A chain or a dictionary of parameters, values of which are numpy
+        datatypes.
 
-    :param model:
-        A ProspectorParams instance
+    model : A ProspectorParams instance
+
+    names : list of strings
 
-    :returns struct:
+    extras : optional
+        Extra keyword arguments are assumed to be 1d ndarrays of type np.float64
+        and shape (nsamples,) that will be added as additional fields of the
+        output structure
+
+    Returns
+    -------
+    struct :
         A structured ndarray of parameter values.
     """
     indict = type(chain) == dict
@@ -377,6 +273,8 @@ def chain_to_struct(chain, model=None, names=None):
     else:
         dt = [(str(p), "<f8", (1,)) for p in names]
 
+    dt += [(str(k), "<f8") for k in extras.keys()]
+
     struct = np.zeros(n, dtype=np.dtype(dt))
     for i, p in enumerate(names):
         if model is not None:
@@ -385,6 +283,12 @@ def chain_to_struct(chain, model=None, names=None):
             inds = slice(i, i+1, None)
         struct[p] = chain[..., inds].reshape(-1, model.params[p].shape[0])
 
+    for k, v in extras.items():
+        try:
+            struct[k] = v
+        except(ValueError, IndexError):
+            pass
+
     return struct
 
 
@@ -395,84 +299,3 @@ def dict_to_struct(indict):
     for i, p in enumerate(indict.keys()):
         struct[p] = indict[p]
     return struct
-
-
-def write_pickles(run_params, model, obs, sampler, powell_results,
-                  outroot=None, tsample=None, toptimize=None,
-                  post_burnin_center=None, post_burnin_prob=None,
-                  sampling_initial_center=None, simpleout=False, **extras):
-    """Write results to two different pickle files.  One (``*_mcmc``) contains
-    only lists, dictionaries, and numpy arrays and is therefore robust to
-    changes in object definitions.  The other (``*_model``) contains the actual
-    model object (and minimization result objects) and is therefore more
-    fragile.
-    """
-
-    if outroot is None:
-        tt = int(time.time())
-        outroot = '{1}_{0}'.format(tt, run_params['outfile'])
-    bgh = githash(**run_params)
-    paramfile_text = paramfile_string(**run_params)
-
-    write_model_pickle(outroot + '_model', model, bgh=bgh, powell=powell_results,
-                       paramfile_text=paramfile_text)
-
-    if simpleout and _has_h5py_:
-        return
-
-    # write out a simple chain as a pickle.  This isn't really necessary since
-    # the hd5 usually works
-    results = {}
-
-    # Useful global info and parameters
-    results['run_params'] = run_params
-    results['obs'] = obs
-    results['model_params'] = [functions_to_names(p.copy()) for p in model.config_list]
-    results['theta_labels'] = list(model.theta_labels())
-
-    # Parameter value at variopus phases
-    results['initial_theta'] = model.initial_theta
-    results['sampling_initial_center'] = sampling_initial_center
-    results['post_burnin_center'] = post_burnin_center
-    results['post_burnin_prob'] = post_burnin_prob
-
-    # Chain and ancillary sampling info
-    results['chain'] = sampler.chain
-    results['lnprobability'] = sampler.lnprobability
-    results['acceptance'] = sampler.acceptance_fraction
-    results['rstate'] = sampler.random_state
-    results['sampling_duration'] = tsample
-    results['optimizer_duration'] = toptimize
-
-    results['prospector_version'] = bgh
-    results['paramfile_text'] = paramfile_text
-
-    with open(outroot + '_mcmc', "wb") as out:
-        pickle.dump(results, out)
-
-
-def write_model_pickle(outname, model, bgh=None, powell=None, **kwargs):
-    model_store = {}
-    model_store['powell'] = powell
-    model_store['model'] = model
-    model_store['prospector_version'] = bgh
-    for k, v in kwargs.items():
-        try:
-            model_store[k] = v
-        except:
-            pass
-    with open(outname, "wb") as out:
-        pickle.dump(model_store, out)
-
-
-def functions_to_names(p):
-    """Replace prior and dust functions (or objects) with the names of those
-    functions (or pickles).
-    """
-    for k, v in list(p.items()):
-        if callable(v):
-            try:
-                p[k] = [v.__name__, v.__module__]
-            except(AttributeError):
-                p[k] = pickle.dumps(v, protocol=2)
-    return p
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 98525e45..bb16073e 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -39,8 +39,8 @@ class SpecModel(ProspectorParams):
     def __init__(self, *args, **kwargs):
 
         super().__init__(*args, **kwargs)
-        self.init_eline_info()
 
+        self.init_eline_info()
         self.parse_elines()
 
     def _available_parameters(self):
diff --git a/tests/test_predict.py b/tests/test_predict.py
index 48f36a3a..dacbc93b 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -4,12 +4,20 @@
 import sys
 import numpy as np
 
+import pytest
+
 from sedpy.observate import load_filters
 from prospect.sources import CSPSpecBasis
 from prospect.models import SpecModel, templates
 from prospect.data import Spectrum, Photometry
 
 
+@pytest.fixture(scope="module")
+def build_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
 def build_model(add_neb=False):
     model_params = templates.TemplateLibrary["parametric_sfh"]
     if add_neb:
@@ -39,23 +47,28 @@ def build_obs(multispec=True):
     return obslist
 
 
-def build_sps():
-    sps = CSPSpecBasis(zcontinuous=1)
-    return sps
+@pytest.mark.skip(reason="not ready")
+def xtest_prediction_nodata(build_sps):
+    sobs, pobs = build_obs(multispec=False)
+    pobs.flux = None
+    pobs.uncertainty = None
+    pred, mfrac = model.predict(model.theta, observations=[pobs], sps=sps)
+
 
+def test_multispec(build_sps):
+    sps = build_sps
 
-def test_multispec():
     obslist_single = build_obs(multispec=False)
-    obslist = build_obs()
+    obslist_multi = build_obs(multispec=True)
     model = build_model(add_neb=True)
-    sps = build_sps()
 
-    predictions_single, mfrac = model.predict(model.theta, observations=obslist_single, sps=sps)
-    predictions, mfrac = model.predict(model.theta, observations=obslist, sps=sps)
+    preds_single, mfrac = model.predict(model.theta, observations=obslist_single, sps=sps)
+    preds_multi, mfrac = model.predict(model.theta, observations=obslist_multi, sps=sps)
+
+    assert len(preds_single) == 2
+    assert len(preds_multi) == 3
+    assert np.allclose(preds_single[-1], preds_multi[-1])
 
-    assert len(predictions_single) == 2
-    assert len(predictions) == 3
-    assert np.allclose(predictions_single[-1], predictions[-1])
     # TODO: turn this plot into an actual test
     #import matplotlib.pyplot as pl
     #fig, ax = pl.subplots()
@@ -67,14 +80,15 @@ def test_multispec():
     #        ax.plot(o.wavelength, p)
 
 
-def lnlike_testing():
-
+def lnlike_testing(build_sps):
     # testing lnprobfn
+
+    sps = build_sps
     observations = build_obs()
     model = build_model(add_neb=True)
+
     from prospect.likelihood.likelihood import compute_lnlike
     from prospect.fitting import lnprobfn
-
     lnp = lnprobfn(model.theta, model=model, observations=obslist, sps=sps)
 
     #%timeit model.prior_product(model.theta)

From 5c89c9d8eb12d142cec06946a2d961486d075c29 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 18 Jun 2022 19:39:17 -0400
Subject: [PATCH 030/132] explicitly set output wavelength to sps when no input
 wavelength; assume FilterSet; require sedpy >= 0.3

---
 prospect/models/sedmodel.py | 28 ++++++++++++++++------------
 requirements.txt            |  2 +-
 tests/test_predict.py       | 16 +++++++++++-----
 3 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index bb16073e..eaf2cd81 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -126,7 +126,7 @@ def predict_obs(self, obs):
         if obs.kind == "spectrum":
             prediction = self.predict_spec(obs)
         elif obs.kind == "photometry":
-            prediction = self.predict_phot(obs["filters"])
+            prediction = self.predict_phot(obs.filterset)
         return prediction
 
     def predict_spec(self, obs, **extras):
@@ -169,17 +169,20 @@ def predict_spec(self, obs, **extras):
             including multiplication by the calibration vector.
             ndarray of shape ``(nwave,)`` in units of maggies.
         """
-        self._outwave = obs['wavelength']
-
         # redshift model wavelength
         obs_wave = self.observed_wave(self._wave, do_wavecal=False)
 
+        # get output wavelength vector
+        self._outwave = obs.wavelength
+        if self._outwave is None:
+            self._outwave = obs_wave
+
         # Set up for emission lines
         self.cache_eline_parameters(obs)
 
         # --- smooth and put on output wavelength grid ---
         # physical smoothing
-        smooth_spec = self.smoothspec(obs_wave, self._norm_spec)
+        smooth_spec = self.velocity_smoothing(obs_wave, self._norm_spec)
         # instrumental smoothing (accounting for library resolution)
         smooth_spec = obs.instrumental_smoothing(self._outwave, smooth_spec,
                                                  libres=self._library_resolution)
@@ -213,7 +216,7 @@ def predict_spec(self, obs, **extras):
 
         return calibrated_spec
 
-    def predict_phot(self, filters):
+    def predict_phot(self, filterset):
         """Generate a prediction for the observed photometry.  This method assumes
         that the parameters have been set and that the following attributes are
         present and correct:
@@ -239,11 +242,11 @@ def predict_phot(self, filters):
         # generate photometry w/o emission lines
         obs_wave = self.observed_wave(self._wave, do_wavecal=False)
         flambda = self._norm_spec * lightspeed / obs_wave**2 * (3631*jansky_cgs)
-        phot = np.atleast_1d(getSED(obs_wave, flambda, filters, linear_flux=True))
+        phot = np.atleast_1d(getSED(obs_wave, flambda, filterset, linear_flux=True))
 
         # generate emission-line photometry
         if (self._want_lines & self._need_lines):
-            phot += self.nebline_photometry(filters)
+            phot += self.nebline_photometry(filterset)
 
         return phot
 
@@ -289,7 +292,7 @@ def _need_lines(self):
     def _want_lines(self):
         return bool(self.params.get('add_neb_emission', False))
 
-    def nebline_photometry(self, filters, elams=None, elums=None):
+    def nebline_photometry(self, filterset, elams=None, elums=None):
         """Compute the emission line contribution to photometry.  This requires
         several cached attributes:
           + ``_ewave_obs``
@@ -320,11 +323,11 @@ def nebline_photometry(self, filters, elams=None, elums=None):
             elums = self._eline_lum[self._use_eline] * self.line_norm
 
         # loop over filters
-        flux = np.zeros(len(filters))
+        flux = np.zeros(len(filterset))
         try:
             # TODO: Since in this case filters are on a grid, there should be a
             # faster way to look up the transmission than the later loop
-            flist = filters.filters
+            flist = filterset.filters
         except(AttributeError):
             flist = filters
         for i, filt in enumerate(flist):
@@ -578,12 +581,13 @@ def get_eline_gaussians(self, lineidx=slice(None), wave=None):
 
         return eline_gaussians
 
-    def smoothspec(self, wave, spec):
+    def velocity_smoothing(self, wave, spec):
         """Smooth the spectrum.  See :py:func:`prospect.utils.smoothing.smoothspec`
         for details.
         """
         sigma = self.params.get("sigma_smooth", 100)
-        outspec = smoothspec(wave, spec, sigma, outwave=self._outwave, **self.params)
+        outspec = smoothspec(wave, spec, sigma, outwave=self._outwave,
+                             smoothtype="vel", fft=True)
 
         return outspec
 
diff --git a/requirements.txt b/requirements.txt
index 8947ebd2..0226c015 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,5 +2,5 @@ numpy >= 1.14.2
 scipy >= 1.1.0
 astropy
 h5py
-astro-sedpy
+astro-sedpy >= 0.3.0
 six
\ No newline at end of file
diff --git a/tests/test_predict.py b/tests/test_predict.py
index dacbc93b..2d36db8e 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -12,7 +12,7 @@
 from prospect.data import Spectrum, Photometry
 
 
-@pytest.fixture(scope="module")
+#@pytest.fixture(scope="module")
 def build_sps():
     sps = CSPSpecBasis(zcontinuous=1)
     return sps
@@ -47,12 +47,18 @@ def build_obs(multispec=True):
     return obslist
 
 
-@pytest.mark.skip(reason="not ready")
-def xtest_prediction_nodata(build_sps):
+#@pytest.mark.skip(reason="not ready")
+def test_prediction_nodata(build_sps):
+    sps = build_sps
+    model = build_model(add_neb=True)
     sobs, pobs = build_obs(multispec=False)
     pobs.flux = None
     pobs.uncertainty = None
-    pred, mfrac = model.predict(model.theta, observations=[pobs], sps=sps)
+    sobs.wavelength = None
+    sobs.flux = None
+    sobs.uncertainty = None
+    pred, mfrac = model.predict(model.theta, observations=[sobs, pobs], sps=sps)
+    assert len(pred[0]) == len(sps.wavelengths)
 
 
 def test_multispec(build_sps):
@@ -94,4 +100,4 @@ def lnlike_testing(build_sps):
     #%timeit model.prior_product(model.theta)
     #%timeit predictions, x = model.predict(model.theta + np.random.uniform(0, 3) * arr, observations=obslist, sps=sps)
     #%timeit lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs in zip(predictions, observations)]
-    #%timeit lnp = lnprobfn(model.theta + np.random.uniform(0, 3) * arr, model=model, observations=obslist, sps=sps)
\ No newline at end of file
+    #%timeit lnp = lnprobfn(model.theta + np.random.uniform(0, 3) * arr, model=model, observations=obslist, sps=sps)

From 4e0017fcd9542b8dc51184382f3747e1020e63b7 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 18 Jun 2022 19:57:33 -0400
Subject: [PATCH 031/132] Fix bugs and tests; allow use of list of Filters or
 FilterSet.

---
 prospect/data/observation.py | 17 +++++++++++++----
 prospect/models/sedmodel.py  | 20 +++++---------------
 tests/test_eline.py          | 34 +++++++++++++++++++++-------------
 tests/test_predict.py        |  4 ++--
 4 files changed, 41 insertions(+), 34 deletions(-)

diff --git a/prospect/data/observation.py b/prospect/data/observation.py
index ac301e52..f82ce886 100644
--- a/prospect/data/observation.py
+++ b/prospect/data/observation.py
@@ -197,6 +197,16 @@ def __init__(self, filters=[], name="PhotA", **kwargs):
         name : string, optional
             The name for this set of data
         """
+        self.set_filters(filters)
+        super(Photometry, self).__init__(name=name, **kwargs)
+
+    def set_filters(self, filters):
+        if not filters:
+            self.filters = filters
+            self.filternames = []
+            self.filterset = None
+            return
+
         if type(filters[0]) is str:
             self.filternames = filters
         else:
@@ -206,8 +216,6 @@ def __init__(self, filters=[], name="PhotA", **kwargs):
         # filters on the gridded resolution
         self.filters = [f for f in self.filterset.filters]
 
-        super(Photometry, self).__init__(name=name, **kwargs)
-
     @property
     def wavelength(self):
         return np.array([f.wave_effective for f in self.filters])
@@ -354,7 +362,8 @@ def __init__(self,
 def from_oldstyle(obs, **kwargs):
     """Convert from an oldstyle dictionary to a list of observations
     """
-    obslist = [Spectrum(**obs), Photometry(**obs)]
+    spec, phot = Spectrum(**obs), Photometry(**obs)
+    #phot.set_filters(phot.filters)
     #[o.rectify() for o in obslist]
 
-    return obslist
+    return [spec, phot]
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index eaf2cd81..4124449f 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -236,7 +236,7 @@ def predict_phot(self, filterset):
             ndarray of shape ``(len(filters),)``, in units of maggies.
             If ``filters`` is None, this returns 0.0
         """
-        if filters is None:
+        if filterset is None:
             return 0.0
 
         # generate photometry w/o emission lines
@@ -329,7 +329,7 @@ def nebline_photometry(self, filterset, elams=None, elums=None):
             # faster way to look up the transmission than the later loop
             flist = filterset.filters
         except(AttributeError):
-            flist = filters
+            flist = filterset
         for i, filt in enumerate(flist):
             # calculate transmission at line wavelengths
             trans = np.interp(elams, filt.wavelength, filt.transmission,
@@ -616,7 +616,7 @@ def wave_to_x(self, wavelength=None, mask=slice(None), **extras):
     def spec_calibration(self, **kwargs):
         return np.ones_like(self._outwave)
 
-    def absolute_rest_maggies(self, filters):
+    def absolute_rest_maggies(self, filterset):
         """Return absolute rest-frame maggies (=10**(-0.4*M)) of the last
         computed spectrum.
 
@@ -638,28 +638,18 @@ def absolute_rest_maggies(self, filters):
         fmaggies = self._norm_spec / (1 + self._zred) * (ld / 10)**2
         # convert to erg/s/cm^2/AA for sedpy and get absolute magnitudes
         flambda = fmaggies * lightspeed / self._wave**2 * (3631*jansky_cgs)
-        abs_rest_maggies = 10**(-0.4 * np.atleast_1d(getSED(self._wave, flambda, filters)))
-        # TODO: below is faster for sedpy > 0.2.0
-        #abs_rest_maggies = np.atleast_1d(getSED(self._wave, flambda, filters, linear_flux=True))
+        abs_rest_maggies = np.atleast_1d(getSED(self._wave, flambda, filterset, linear_flux=True))
 
         # add emission lines
         if bool(self.params.get('nebemlineinspec', False)) is False:
             eline_z = self.params.get("eline_delta_zred", 0.0)
             elams = (1 + eline_z) * self._eline_wave
             elums = self._eline_lum * self.flux_norm() / (1 + self._zred) * (3631*jansky_cgs) * (ld / 10)**2
-            emaggies = self.nebline_photometry(filters, elams=elams, elums=elums)
+            emaggies = self.nebline_photometry(filterset, elams=elams, elums=elums)
             abs_rest_maggies += emaggies
 
         return abs_rest_maggies
 
-    def mean_model(self, theta, obs, sps=None, sigma=None, **extras):
-        """Legacy wrapper around predict()
-        """
-        from ..utils.observation import from_oldstyle
-        obslist = from_oldstyle(obs)
-        predictions, mfrac = self.predict(theta, obslist, sps=sps, sigma_spec=sigma, **extras)
-        return predictions[0], predictions[1], mfrac
-
 
 class PolySpecModel(SpecModel):
 
diff --git a/tests/test_eline.py b/tests/test_eline.py
index a25f1285..64c409c1 100644
--- a/tests/test_eline.py
+++ b/tests/test_eline.py
@@ -3,16 +3,22 @@
 
 import numpy as np
 
+import pytest
+
 from sedpy import observate
 
-from prospect import prospect_args
 from prospect.data import Photometry, Spectrum, from_oldstyle
 from prospect.models.templates import TemplateLibrary
 from prospect.models.sedmodel import SpecModel
-
 from prospect.sources import CSPSpecBasis
 
 
+@pytest.fixture
+def get_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
 # test nebular line specification
 def test_eline_parsing():
     model_pars = TemplateLibrary["parametric_sfh"]
@@ -53,7 +59,7 @@ def test_eline_parsing():
     assert model._fit_eline.sum() == (len(model._use_eline) - len(fix_lines))
 
 
-def test_nebline_phot_addition():
+def test_nebline_phot_addition(get_sps):
     fnames = [f"sdss_{b}0" for b in "ugriz"]
     filts = observate.load_filters(fnames)
 
@@ -61,9 +67,10 @@ def test_nebline_phot_addition():
                wavelength=np.linspace(3000, 9000, 1000),
                spectrum=np.ones(1000),
                unc=np.ones(1000)*0.1)
-    obslist = from_oldstyle(obs)
+    sdat, pdat = from_oldstyle(obs)
+    obslist = [sdat, pdat]
 
-    sps = CSPSpecBasis(zcontinuous=1)
+    sps = get_sps
 
     # Make emission lines more prominent
     zred = 1.0
@@ -88,11 +95,11 @@ def test_nebline_phot_addition():
     p1n = m1.nebline_photometry(filts)
     assert np.any(p1n / p1[1] > 0.05)
 
-    # make sure you got the same answer
-    assert np.all(np.abs(p1 - p2) / p1 < 1e-3)
+    # make sure you got the same-ish answer
+    assert np.all((np.abs(p1 - p2) / p1) < 1e-2)
 
 
-def test_filtersets():
+def test_filtersets(get_sps):
     """This test no longer relevant.....
     """
     fnames = [f"sdss_{b}0" for b in "ugriz"]
@@ -102,9 +109,10 @@ def test_filtersets():
                spectrum=np.ones(1000),
                unc=np.ones(1000)*0.1,
                filters=fnames)
-    obslist = from_oldstyle(obs)
+    sdat, pdat = from_oldstyle(obs)
+    obslist = [sdat, pdat]
 
-    sps = CSPSpecBasis(zcontinuous=1)
+    sps = get_sps
 
     # Make emission lines more prominent
     zred = 0.5
@@ -128,7 +136,7 @@ def test_filtersets():
         # make sure some of the filters are affected by lines
         # ( nebular flux > 10% of total flux)
         if i == 1:
-            nebphot = model.nebline_photometry(flist)
+            nebphot = model.nebline_photometry(pdat.filterset)
             assert np.any(nebphot / pset > 0.1)
 
         # make sure photometry is consistent
@@ -136,7 +144,7 @@ def test_filtersets():
         # We always use filtersets now
 
 
-def test_eline_implementation():
+def test_eline_implementation(get_sps):
 
     test_eline_parsing()
 
@@ -156,7 +164,7 @@ def test_eline_implementation():
     model_pars["zred"]["init"] = 4
     model = SpecModel(model_pars)
 
-    sps = CSPSpecBasis(zcontinuous=1)
+    sps = get_sps
 
     # generate with all fixed lines added
     (spec, phot), mfrac = model.predict(model.theta, obslist, sps=sps)
diff --git a/tests/test_predict.py b/tests/test_predict.py
index 2d36db8e..73ff5c16 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -12,7 +12,7 @@
 from prospect.data import Spectrum, Photometry
 
 
-#@pytest.fixture(scope="module")
+@pytest.fixture(scope="module")
 def build_sps():
     sps = CSPSpecBasis(zcontinuous=1)
     return sps
@@ -47,7 +47,6 @@ def build_obs(multispec=True):
     return obslist
 
 
-#@pytest.mark.skip(reason="not ready")
 def test_prediction_nodata(build_sps):
     sps = build_sps
     model = build_model(add_neb=True)
@@ -59,6 +58,7 @@ def test_prediction_nodata(build_sps):
     sobs.uncertainty = None
     pred, mfrac = model.predict(model.theta, observations=[sobs, pobs], sps=sps)
     assert len(pred[0]) == len(sps.wavelengths)
+    assert len(pred[1]) == len(pobs.filterset)
 
 
 def test_multispec(build_sps):

From 0a9c61dc3210b5c9cc29aa1d35db4d17248a1966 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 27 Jul 2022 15:30:20 -0400
Subject: [PATCH 032/132] Simplification of prospect.sources

Moves the SSPBasis and FastStepBasis to galaxy_basis module.
Removes the ssp_basis, dust_basis, and boneyard modules.
Removes the get_spectrum method from SSPBasis and subclasses; this is handled by SpecModel
Remove various multicomponent hacks.
---
 prospect/sources/__init__.py     |  12 +-
 prospect/sources/boneyard.py     | 487 -------------------------------
 prospect/sources/dust_basis.py   | 104 -------
 prospect/sources/galaxy_basis.py | 395 ++++++++++++++-----------
 prospect/sources/ssp_basis.py    | 403 -------------------------
 5 files changed, 232 insertions(+), 1169 deletions(-)
 delete mode 100644 prospect/sources/boneyard.py
 delete mode 100644 prospect/sources/dust_basis.py
 delete mode 100644 prospect/sources/ssp_basis.py

diff --git a/prospect/sources/__init__.py b/prospect/sources/__init__.py
index 7f7bd353..e4bccd8c 100644
--- a/prospect/sources/__init__.py
+++ b/prospect/sources/__init__.py
@@ -1,12 +1,4 @@
 from .galaxy_basis import *
-from .ssp_basis import *
-from .star_basis import *
-from .dust_basis import *
-from .boneyard import StepSFHBasis
 
-__all__ = ["to_cgs",
-           "CSPSpecBasis", "MultiComponentCSPBasis",
-           "FastSSPBasis", "SSPBasis",
-           "FastStepBasis", "StepSFHBasis",
-           "StarBasis", "BigStarBasis",
-           "BlackBodyDustBasis"]
+__all__ = ["CSPSpecBasis", "SSPBasis",
+           "FastStepBasis"]
diff --git a/prospect/sources/boneyard.py b/prospect/sources/boneyard.py
deleted file mode 100644
index e090771a..00000000
--- a/prospect/sources/boneyard.py
+++ /dev/null
@@ -1,487 +0,0 @@
-import numpy as np
-from scipy.special import expi, gammainc
-
-from .ssp_basis import SSPBasis
-
-
-__all__ = ["CSPBasis", "StepSFHBasis", "CompositeSFH", "LinearSFHBasis"]
-
-# change base
-from .constants import loge
-
-
-class CSPBasis(object):
-    """
-    A class for composite stellar populations, which can be composed from
-    multiple versions of parameterized SFHs.  Deprecated, Use CSPSpecBasis instead.
-    """
-    def __init__(self, compute_vega_mags=False, zcontinuous=1, vactoair_flag=False, **kwargs):
-
-        # This is a StellarPopulation object from fsps
-        self.csp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
-                                          zcontinuous=zcontinuous,
-                                          vactoair_flag=vactoair_flag)
-        self.params = {}
-
-    def get_spectrum(self, outwave=None, filters=None, peraa=False, **params):
-        """Given a theta vector, generate spectroscopy, photometry and any
-        extras (e.g. stellar mass).
-
-        :param theta:
-            ndarray of parameter values.
-
-        :param sps:
-            A python-fsps StellarPopulation object to be used for
-            generating the SED.
-
-        :returns spec:
-            The restframe spectrum in units of maggies.
-
-        :returns phot:
-            The apparent (redshifted) observed frame maggies in each of the
-            filters.
-
-        :returns extras:
-            A list of the ratio of existing stellar mass to total mass formed
-            for each component, length ncomp.
-        """
-        self.params.update(**params)
-        # Pass the model parameters through to the sps object
-        ncomp = len(self.params['mass'])
-        for ic in range(ncomp):
-            s, p, x = self.one_sed(component_index=ic, filterlist=filters)
-            try:
-                spec += s
-                maggies += p
-                extra += [x]
-            except(NameError):
-                spec, maggies, extra = s, p, [x]
-        # `spec` is now in Lsun/Hz, with the wavelength array being the
-        # observed frame wavelengths.  Flux array (and maggies) have not been
-        # increased by (1+z) due to cosmological redshift
-
-        w = self.ssp.wavelengths
-        if outwave is not None:
-            spec = np.interp(outwave, w, spec)
-        else:
-            outwave = w
-        # Distance dimming and unit conversion
-        zred = self.params.get('zred', 0.0)
-        if (zred == 0) or ('lumdist' in self.params):
-            # Use 10pc for the luminosity distance (or a number provided in the
-            # lumdist key in units of Mpc).  Do not apply cosmological (1+z)
-            # factor to the flux.
-            dfactor = (self.params.get('lumdist', 1e-5) * 1e5)**2
-            a = 1.0
-        else:
-            # Use the comsological luminosity distance implied by this
-            # redshift.  Cosmological (1+z) factor on the flux was already done in one_sed
-            lumdist = cosmo.luminosity_distance(zred).value
-            dfactor = (lumdist * 1e5)**2
-        if peraa:
-            # spectrum will be in erg/s/cm^2/AA
-            spec *= to_cgs / dfactor * lightspeed / outwave**2
-        else:
-            # Spectrum will be in maggies
-            spec *= to_cgs / dfactor / (3631*jansky_cgs)
-
-        # Convert from absolute maggies to apparent maggies
-        maggies /= dfactor
-
-        return spec, maggies, extra
-
-    def one_sed(self, component_index=0, filterlist=[]):
-        """Get the SED of one component for a multicomponent composite SFH.
-        Should set this up to work as an iterator.
-
-        :param component_index:
-            Integer index of the component to calculate the SED for.
-
-        :param filterlist:
-            A list of strings giving the (FSPS) names of the filters onto which
-            the spectrum will be projected.
-
-        :returns spec:
-            The restframe spectrum in units of Lsun/Hz.
-
-        :returns maggies:
-            Broadband fluxes through the filters named in ``filterlist``,
-            ndarray.  Units are observed frame absolute maggies: M = -2.5 *
-            log_{10}(maggies).
-
-        :returns extra:
-            The extra information corresponding to this component.
-        """
-        # Pass the model parameters through to the sps object, and keep track
-        # of the mass of this component
-        mass = 1.0
-        for k, vs in list(self.params.items()):
-            try:
-                v = vs[component_index]
-            except(IndexError, TypeError):
-                v = vs
-            if k in self.csp.params.all_params:
-                self.csp.params[k] = deepcopy(v)
-            if k == 'mass':
-                mass = v
-        # Now get the spectrum.  The spectrum is in units of
-        # Lsun/Hz/per solar mass *formed*, and is restframe
-        w, spec = self.csp.get_spectrum(tage=self.csp.params['tage'], peraa=False)
-        # redshift and get photometry.  Note we are boosting fnu by (1+z) *here*
-        a, b = (1 + self.csp.params['zred']), 0.0
-        wa, sa = w * (a + b), spec * a  # Observed Frame
-        if filterlist is not None:
-            mags = getSED(wa, lightspeed/wa**2 * sa * to_cgs, filterlist)
-            phot = np.atleast_1d(10**(-0.4 * mags))
-        else:
-            phot = 0.0
-
-        # now some mass normalization magic
-        mfrac = self.csp.stellar_mass
-        if np.all(self.params.get('mass_units', 'mstar') == 'mstar'):
-            # Convert input normalization units from per stellar masss to per mass formed
-            mass /= mfrac
-        # Output correct units
-        return mass * sa, mass * phot, mfrac
-
-
-class StepSFHBasis(SSPBasis):
-    """Subclass of SSPBasis that computes SSP weights for piecewise constant
-    SFHs (i.e. a binned SFH).  The parameters for this SFH are:
-
-      * `agebins` - array of shape (nbin, 2) giving the younger and older (in
-        lookback time) edges of each bin.  If `interp_type` is `"linear"',
-        these are assumed to be in years.  Otherwise they are in log10(years)
-
-      * `mass` - array of shape (nbin,) giving the total surviving stellar mass
-        (in solar masses) in each bin, unless the `mass_units` parameter is set
-        to something different `"mstar"`, in which case the units are assumed
-        to be total stellar mass *formed* in each bin.
-
-    The `agebins` parameter *must not be changed* without also setting
-    `self._ages=None`.
-    """
-
-    @property
-    def all_ssp_weights(self):
-        # Cache age bins and relative weights.  This means params['agebins']
-        # *must not change* without also setting _ages = None
-        if getattr(self, '_ages', None) is None:
-            self._ages = self.params['agebins']
-            nbin, nssp = len(self._ages), len(self.logage) + 1
-            self._bin_weights = np.zeros([nbin, nssp])
-            for i, (t1, t2) in enumerate(self._ages):
-                # These *should* sum to one (or zero) for each bin
-                self._bin_weights[i, :] = self.bin_weights(t1, t2)
-
-        # Now normalize the weights in each bin by the mass parameter, and sum
-        # over bins.
-        bin_masses = self.params['mass']
-        if np.all(self.params.get('mass_units', 'mformed') == 'mstar'):
-            # Convert from mstar to mformed for each bin.  We have to do this
-            # here as well as in get_spectrum because the *relative*
-            # normalization in each bin depends on the units, as well as the
-            # overall normalization.
-            bin_masses /= self.bin_mass_fraction
-        w = (bin_masses[:, None] * self._bin_weights).sum(axis=0)
-
-        return w
-
-    @property
-    def bin_mass_fraction(self):
-        """Return the ratio m_star(surviving) / m_formed for each bin.
-        """
-        try:
-            mstar = self.ssp_stellar_masses
-            w = self._bin_weights
-            bin_mfrac = (mstar[None, :] * w).sum(axis=-1) / w.sum(axis=-1)
-            return bin_mfrac
-        except(AttributeError):
-            print('agebin info or ssp masses not chached?')
-            return 1.0
-
-    def bin_weights(self, amin, amax):
-        """Compute normalizations required to get a piecewise constant SFH
-        within an age bin.  This is super complicated and obscured.  The output
-        weights are such that one solar mass will have formed during the bin
-        (i.e. SFR = 1/(amax-amin))
-
-        This computes weights using \int_tmin^tmax dt (\log t_i - \log t) /
-        (\log t_{i+1} - \log t_i) but see sfh.tex for the detailed calculation
-        and the linear time interpolation case.
-        """
-        if self.interp_type == 'linear':
-            sspages = np.insert(10**self.logage, 0, 0)
-            func = constant_linear
-            mass = amax - amin
-        elif self.interp_type == 'logarithmic':
-            sspages = np.insert(self.logage, 0, self.mint_log)
-            func = constant_logarithmic
-            mass = 10**amax - 10**amin
-
-        assert amin >= sspages[0]
-        assert amax <= sspages.max()
-
-        # below could be done by using two separate dt vectors instead of two
-        # age vectors
-        ages = np.array([sspages[:-1], sspages[1:]])
-        dt = np.diff(ages, axis=0)
-        tmin, tmax = np.clip(ages, amin, amax)
-
-        # get contributions from SSP sub-bin to the left and from SSP sub-bin
-        # to the right
-        left, right = (func(ages, tmax) - func(ages, tmin)) / dt
-        # put into full array
-        ww = np.zeros(len(sspages))
-        ww[:-1] += right  # last element has no sub-bin to the right
-        ww[1:] += -left  # need to flip sign
-
-        # normalize to 1 solar mass formed and return
-        return ww / mass
-
-
-class CompositeSFH(SSPBasis):
-    """Subclass of SSPBasis that computes SSP weights for a parameterized SF.
-    The parameters for this SFH are:
-
-      * `sfh_type` - String of "delaytau", "tau", "simha"
-
-      * `tage`, `sf_trunc`,  `sf_slope`, `const`, `fburst`, `tau`
-
-      * `mass` -
-
-    """
-
-    def configure(self):
-        """This reproduces FSPS-like combinations of SFHs.  Note that the
-        *same* parameter set is passed to each component in the combination
-        """
-        sfhs = [self.sfh_type]
-        limits = len(sfhs) * ['regular']
-        if 'simha' in self.sfh_type:
-            sfhs = ['delaytau', 'linear']
-            limits = ['regular', 'simha']
-
-        fnames = ['{0}_{1}'.format(f, self.interp_type) for f in sfhs]
-        lnames = ['{}_limits'.format(f) for f in limits]
-        self.funcs = [globals()[f] for f in fnames]
-        self.limits = [globals()[f] for f in lnames]
-
-        if self.interp_type == 'linear':
-            sspages = np.insert(10**self.logage, 0, 0)
-        elif self.interp_type == 'logarithmic':
-            sspages = np.insert(self.logage, 0, self.mint_log)
-        self.ages = np.array([sspages[:-1], sspages[1:]])
-        self.dt = np.diff(self.ages, axis=0)
-
-    @property
-    def _limits(self):
-        pass
-
-    @property
-    def _funcs(self):
-        pass
-
-    @property
-    def all_ssp_weights(self):
-
-        # Full output weight array.  We keep separate vectors for each
-        # component so we can renormalize after the loop, but for many
-        # components it would be better to renormalize and sum within the loop
-        ww = np.zeros([len(self.funcs), self.ages.shape[-1] + 1])
-
-        # Loop over components.  Note we are sending the same params to every component
-        for i, (limit, func) in enumerate(zip(self.limits, self.funcs)):
-            ww[i, :] = self.ssp_weights(func, limit, self.params)
-
-        # renormalize each component to 1 Msun
-        assert np.all(ww >= 0)
-        wsum = ww.sum(axis=1)
-        # unless truly no SF in the component
-        if 0 in wsum:
-            wsum[wsum == 0] = 1.0
-        ww /= wsum[:, None]
-        # apply relative normalizations
-        ww *= self.normalizations(**self.params)[:, None]
-        # And finally add all components together and renormalize again to
-        # 1Msun and return
-        return ww.sum(axis=0) / ww.sum()
-
-    def ssp_weights(self, integral, limit_function, params, **extras):
-        # build full output weight vector
-        ww = np.zeros(self.ages.shape[-1] + 1)
-        tmin, tmax = limit_function(self.ages, mint_log=self.mint_log,
-                                    interp_type=self.interp_type, **params)
-        left, right = (integral(self.ages, tmax, **params) -
-                       integral(self.ages, tmin, **params)) / self.dt
-        # Put into full array, shifting the `right` terms by 1 element
-        ww[:-1] += right  # last SSP has no sub-bin to the right
-        ww[1:] += -left   # need to flip sign
-
-        # Note that now ww[i,1] = right[1] - left[0], where
-        # left[0] is the integral from tmin,0 to tmax,0 of
-        # SFR(t) * (sspages[0] - t)/(sspages[1] - sspages[0]) and
-        # right[1] is the integral from tmin,1 to tmax,1 of
-        # SFR(t) * (sspages[2] - t)/(sspages[2] - sspages[1])
-        return ww
-
-    def normalizations(self, tage=0., sf_trunc=0, sf_slope=0, const=0,
-                       fburst=0, tau=0., **extras):
-        if (sf_trunc <= 0) or (sf_trunc > tage):
-            Tmax = tage
-        else:
-            Tmax = sf_trunc
-        # Tau models.  SFH=1 -> power=1; SFH=4,5 -> power=2
-        if ('delay' in self.sfh_type) or ('simha' in self.sfh_type):
-            power = 2.
-        else:
-            power = 1.
-        mass_tau = tau * gammainc(power, Tmax/tau)
-
-        if 'simha' not in self.sfh_type:
-            return np.array([mass_tau])
-        # SFR at Tmax
-        sfr_q = (Tmax/tau)**(power-1) * np.exp(-Tmax/tau)
-
-        # linear.  integral of (1 - m * (T - Tmax)) from Tmax to Tzero
-        if sf_slope == 0.:
-            Tz = tage
-        else:
-            Tz = Tmax + 1/np.float64(sf_slope)
-        if (Tz < Tmax) or (Tz > tage) or (not np.isfinite(Tz)):
-            Tz = tage
-        m = sf_slope
-        mass_linear = (Tz - Tmax) - m/2.*(Tz**2 + Tmax**2) + m*Tz*Tmax
-
-        # normalize the linear portion relative to the tau portion
-        norms = np.array([1, mass_linear * sfr_q / mass_tau])
-        norms /= norms.sum()
-        # now add in constant and burst
-        if (const > 0) or (fburst > 0):
-            norms = (1-fburst-const) * norms
-            norms.tolist().extend([const, fburst])
-        return np.array(norms)
-
-
-class LinearSFHBasis(SSPBasis):
-    """Subclass of SSPBasis that computes SSP weights for piecewise linear SFHs
-    (i.e. a linearly interpolated tabular SFH).  The parameters for this SFH
-    are:
-      * `ages` - array of shape (ntab,) giving the lookback time of each
-        tabulated SFR.  If `interp_type` is `"linear"', these are assumed to be
-        in years.  Otherwise they are in log10(years)
-      * `sfr` - array of shape (ntab,) giving the SFR (in Msun/yr)
-      * `logzsol`
-      * `dust2`
-    """
-    def get_galaxy_spectrum(self):
-        raise(NotImplementedError)
-
-
-def regular_limits(ages, tage=0., sf_trunc=0., mint_log=-3,
-                   interp_type='logarithmic', **extras):
-        # get the truncation time in units of lookback time
-        if (sf_trunc <= 0) or (sf_trunc > tage):
-            tq = 0
-        else:
-            tq = tage - sf_trunc
-        if interp_type == 'logarithmic':
-            tq = np.log10(np.max([tq, 10**mint_log]))
-            tage = np.log10(np.max([tage, 10**mint_log]))
-        return np.clip(ages, tq, tage)
-
-
-def simha_limits(ages, tage=0., sf_trunc=0, sf_slope=0., mint_log=-3,
-                 interp_type='logarithmic', **extras):
-        # get the truncation time in units of lookback time
-        if (sf_trunc <= 0) or (sf_trunc > tage):
-            tq = 0
-        else:
-            tq = tage - sf_trunc
-        t0 = tq - 1. / np.float64(sf_slope)
-        if (t0 > tq) or (t0 <= 0) or (not np.isfinite(t0)):
-            t0 = 0.
-        if interp_type == 'logarithmic':
-            tq = np.log10(np.max([tq, 10**mint_log]))
-            t0 = np.log10(np.max([t0, 10**mint_log]))
-        return np.clip(ages, t0, tq)
-
-
-def constant_linear(ages, t, **extras):
-    """Indefinite integral for SFR = 1
-
-    :param ages:
-        Linear age(s) of the SSPs.
-
-    :param t:
-        Linear time at which to evaluate the indefinite integral
-    """
-    return ages * t - t**2 / 2
-
-
-def constant_logarithmic(logages, logt, **extras):
-    """SFR = 1
-    """
-    t = 10**logt
-    return t * (logages - logt + loge)
-
-
-def tau_linear(ages, t, tau=None, **extras):
-    """SFR = e^{(tage-t)/\tau}
-    """
-    return (ages - t + tau) * np.exp(t / tau)
-
-
-def tau_logarithmic(logages, logt, tau=None, **extras):
-    """SFR = e^{(tage-t)/\tau}
-    """
-    tprime = 10**logt / tau
-    return (logages - logt) * np.exp(tprime) + loge * expi(tprime)
-
-
-def delaytau_linear(ages, t, tau=None, tage=None, **extras):
-    """SFR = (tage-t) * e^{(tage-t)/\tau}
-    """
-    bracket = tage * ages - (tage + ages)*(t - tau) + t**2 - 2*t*tau + 2*tau**2
-    return bracket * np.exp(t / tau)
-
-
-def delaytau_logarithmic(logages, logt, tau=None, tage=None, **extras):
-    """SFR = (tage-t) * e^{(tage-t)/\tau}
-    """
-    t = 10**logt
-    tprime = t / tau
-    a = (t - tage - tau) * (logt - logages) - tau * loge
-    b = (tage + tau) * loge
-    return a * np.exp(tprime) + b * expi(tprime)
-
-
-def linear_linear(ages, t, tage=None, sf_trunc=0, sf_slope=0., **extras):
-    """SFR = [1 - sf_slope * (tage-t)]
-    """
-    tq = np.max([0, tage-sf_trunc])
-    k = 1 - sf_slope * tq
-    return k * ages * t + (sf_slope*ages - k) * t**2 / 2 - sf_slope * t**3 / 3
-
-
-def linear_logarithmic(logages, logt, tage=None, sf_trunc=0, sf_slope=0., **extras):
-    """SFR = [1 - sf_slope * (tage-t)]
-    """
-    tq = np.max([0, tage-sf_trunc])
-    t = 10**logt
-    k = 1 - sf_slope * tq
-    term1 = k * t * (logages - logt + loge)
-    term2 = sf_slope * t**2 / 2 * (logages - logt + loge / 2)
-    return term1 + term2
-
-
-def burst_linear(ages, t, tburst=None, **extras):
-    """Burst.  SFR = \delta(t-t_burst)
-    """
-    return ages - tburst
-
-
-def burst_logarithmic(logages, logt, tburst=None, **extras):
-    """Burst.  SFR = \delta(t-t_burst)
-    """
-    return logages - np.log10(tburst)
diff --git a/prospect/sources/dust_basis.py b/prospect/sources/dust_basis.py
deleted file mode 100644
index 8e478bf7..00000000
--- a/prospect/sources/dust_basis.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import numpy as np
-
-try:
-    from sedpy.observate import getSED
-except(ImportError):
-    pass
-
-__all__ = ["BlackBodyDustBasis"]
-
-# cgs constants
-from .constants import lsun, pc, kboltz, hplanck
-lightspeed = 29979245800.0
-
-
-class BlackBodyDustBasis(object):
-    """
-    """
-    def __init__(self, **kwargs):
-        self.dust_parlist = ['mass', 'T', 'beta', 'kappa0', 'lambda0']
-        self.params = {}
-        self.params.update(**kwargs)
-        self.default_wave = np.arange(1000) # in microns
-
-    def get_spectrum(self, outwave=None, filters=None, **params):
-        """Given a params dictionary, generate spectroscopy, photometry and any
-        extras (e.g. stellar mass).
-
-        :param outwave:
-            The output wavelength vector.
-
-        :param filters:
-            A list of sedpy filter objects.
-
-        :param params:
-            Keywords forming the parameter set.
-
-        :returns spec:
-            The restframe spectrum in units of erg/s/cm^2/AA
-
-        :returns phot:
-            The apparent (redshifted) maggies in each of the filters.
-
-        :returns extras:
-            A list of None type objects, only included for consistency with the
-            SedModel class.
-        """
-        self.params.update(**params)
-        if outwave is None:
-            outwave = self.default_wave
-        # Loop over number of MBBs
-        ncomp = len(self.params['mass'])
-        seds = [self.one_sed(icomp=ic, wave=outwave, filters=filters)
-                for ic in range(ncomp)]
-        # sum the components
-        spec = np.sum([s[0] for s in seds], axis=0)
-        maggies = np.sum([s[1] for s in seds], axis=0)
-        extra = [s[2] for s in seds]
-
-        norm = self.normalization()
-        spec, maggies = norm * spec, norm * maggies
-        return spec, maggies, extra
-
-    def one_sed(self, icomp=0, wave=None, filters=None, **extras):
-        """Pull out individual component parameters from the param dictionary
-        and generate spectra for those components
-        """
-        cpars = {}
-        for k in self.dust_parlist:
-            try:
-                cpars[k] = np.squeeze(self.params[k][icomp])
-            except(IndexError, TypeError):
-                cpars[k] = np.squeeze(self.params[k])
-
-        spec = cpars['mass'] * modified_BB(wave, **cpars)
-        phot = 10**(-0.4 * getSED(wave*1e4, spec, filters))
-        return spec, phot, None
-
-    def normalization(self):
-        """This method computes the normalization (due do distance dimming,
-        unit conversions, etc.) based on the content of the params dictionary.
-        """
-        return 1
-
-
-def modified_BB(wave, T=20, beta=2.0, kappa0=1.92, lambda0=350, **extras):
-    """Return a modified blackbody.
-
-    the normalization of the emissivity curve can be given as kappa0 and
-    lambda0 in units of cm^2/g and microns, default = (1.92, 350).  Ouput units
-    are erg/s/micron/g.
-    """
-    term = (lambda0 / wave)**beta
-    return planck(wave, T=T, **extras) * term * kappa0
-
-
-def planck(wave, T=20.0, **extras):
-    """Return planck function B_lambda (erg/s/micron) for a given T (in Kelvin) and
-    wave (in microns)
-    """
-    # Return B_lambda in erg/s/micron
-    w = wave * 1e4 #convert from microns to cm
-    conv = 2 * hplank * lightspeed**2 / w**5 / 1e4
-    denom = (np.exp(hplanck * lightspeed / (kboltz * T)) - 1)
-    return conv / denom
diff --git a/prospect/sources/galaxy_basis.py b/prospect/sources/galaxy_basis.py
index f767d150..da616086 100644
--- a/prospect/sources/galaxy_basis.py
+++ b/prospect/sources/galaxy_basis.py
@@ -2,21 +2,243 @@
 import numpy as np
 from copy import deepcopy
 
-from sedpy.smoothing import smoothspec
-from .ssp_basis import SSPBasis
-from .constants import cosmo, lightspeed, jansky_cgs, to_cgs_at_10pc
-
 try:
     import fsps
-    from sedpy.observate import getSED, vac2air, air2vac
 except(ImportError, RuntimeError):
     pass
 
-__all__ = ["CSPSpecBasis", "MultiComponentCSPBasis",
-           "to_cgs"]
 
+__all__ = ["SSPBasis", "FastStepBasis",
+           "CSPSpecBasis"]
+
+
+class SSPBasis(object):
+
+    """This is a class that wraps the fsps.StellarPopulation object, which is
+    used for producing SSPs.  The ``fsps.StellarPopulation`` object is accessed
+    as ``SSPBasis().ssp``.
+
+    This class allows for the custom calculation of relative SSP weights (by
+    overriding ``all_ssp_weights``) to produce spectra from arbitrary composite
+    SFHs. Alternatively, the entire ``get_galaxy_spectrum`` method can be
+    overridden to produce a galaxy spectrum in some other way, for example
+    taking advantage of weight calculations within FSPS for tabular SFHs or for
+    parameteric SFHs.
+
+    The base implementation here produces an SSP interpolated to the age given
+    by ``tage``, with initial mass given by ``mass``.  However, this is much
+    slower than letting FSPS calculate the weights, as implemented in
+    :py:class:`FastSSPBasis`.
+
+    Furthermore, smoothing, redshifting, and filter projections are handled
+    outside of FSPS, allowing for fast and more flexible algorithms.
+
+    :param reserved_params:
+        These are parameters which have names like the FSPS parameters but will
+        not be passed to the StellarPopulation object because we are overriding
+        their functionality using (hopefully more efficient) custom algorithms.
+    """
+
+    def __init__(self, zcontinuous=1, reserved_params=['tage', 'sigma_smooth'],
+                 interp_type='logarithmic', flux_interp='linear',
+                 mint_log=-3, compute_vega_mags=False,
+                 **kwargs):
+        """
+        :param interp_type: (default: "logarithmic")
+            Specify whether to linearly interpolate the SSPs in log(t) or t.
+            For the latter, set this to "linear".
+
+        :param flux_interp': (default: "linear")
+            Whether to compute the final spectrum as \sum_i w_i f_i or
+            e^{\sum_i w_i ln(f_i)}.  Basically you should always do the former,
+            which is the default.
+
+        :param mint_log: (default: -3)
+            The log of the age (in years) of the youngest SSP.  Note that the
+            SSP at this age is assumed to have the same spectrum as the minimum
+            age SSP avalibale from fsps.  Typically anything less than 4 or so
+            is fine for this parameter, since the integral converges as log(t)
+            -> -inf
+
+        :param reserved_params:
+            These are parameters which have names like the FSPS parameters but
+            will not be passed to the StellarPopulation object because we are
+            overriding their functionality using (hopefully more efficient)
+            custom algorithms.
+        """
+
+        self.interp_type = interp_type
+        self.mint_log = mint_log
+        self.flux_interp = flux_interp
+        self.ssp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
+                                          zcontinuous=zcontinuous)
+        self.ssp.params['sfh'] = 0
+        self.reserved_params = reserved_params
+        self.params = {}
+        self.update(**kwargs)
+
+    def update(self, **params):
+        """Update the parameters, passing the *unreserved* FSPS parameters
+        through to the ``fsps.StellarPopulation`` object.
+
+        :param params:
+            A parameter dictionary.
+        """
+        for k, v in params.items():
+            # try to make parameters scalar
+            try:
+                if (len(v) == 1) and callable(v[0]):
+                    self.params[k] = v[0]
+                else:
+                    self.params[k] = np.squeeze(v)
+            except:
+                self.params[k] = v
+            # Parameters named like FSPS params but that we reserve for use
+            # here.  Do not pass them to FSPS.
+            if k in self.reserved_params:
+                continue
+            # Otherwise if a parameter exists in the FSPS parameter set, pass a
+            # copy of it in.
+            if k in self.ssp.params.all_params:
+                self.ssp.params[k] = deepcopy(v)
+
+        # We use FSPS for SSPs !!ONLY!!
+        # except for FastStepBasis.  And CSPSpecBasis. and...
+        # assert self.ssp.params['sfh'] == 0
+
+    def get_galaxy_spectrum(self, **params):
+        """Update parameters, then get the SSP spectrum
+
+        Returns
+        -------
+        wave : ndarray
+            Restframe avelength in angstroms.
+
+        spectrum : ndarray
+            Spectrum in units of Lsun/Hz per solar mass formed.
+
+        mass_fraction : float
+            Fraction of the formed stellar mass that still exists.
+        """
+        self.update(**params)
+        wave, spec = self.ssp.get_spectrum(tage=float(self.params['tage']), peraa=False)
+        return wave, spec, self.ssp.stellar_mass
+
+    def get_galaxy_elines(self):
+        """Get the wavelengths and specific emission line luminosity of the nebular emission lines
+        predicted by FSPS. These lines are in units of Lsun/solar mass formed.
+        This assumes that `get_galaxy_spectrum` has already been called.
+
+        :returns ewave:
+            The *restframe* wavelengths of the emission lines, AA
+
+        :returns elum:
+            Specific luminosities of the nebular emission lines,
+            Lsun/stellar mass formed
+        """
+        ewave = self.ssp.emline_wavelengths
+        # This allows subclasses to set their own specific emission line
+        # luminosities within other methods, e.g., get_galaxy_spectrum, by
+        # populating the `_specific_line_luminosity` attribute.
+        elum = getattr(self, "_line_specific_luminosity", None)
+
+        if elum is None:
+            elum = self.ssp.emline_luminosity.copy()
+            if elum.ndim > 1:
+                elum = elum[0]
+            if self.ssp.params["sfh"] == 3:
+                # tabular sfh
+                mass = np.sum(self.params.get('mass', 1.0))
+                elum /= mass
+
+        return ewave, elum
+
+    @property
+    def logage(self):
+        return self.ssp.ssp_ages.copy()
+
+    @property
+    def wavelengths(self):
+        return self.ssp.wavelengths.copy()
+
+
+class FastStepBasis(SSPBasis):
+    """Subclass of :py:class:`SSPBasis` that implements a "nonparameteric"
+    (i.e. binned) SFH.  This is accomplished by generating a tabular SFH with
+    the proper form to be passed to FSPS. The key parameters for this SFH are:
+
+      * ``agebins`` - array of shape ``(nbin, 2)`` giving the younger and older
+        (in lookback time) edges of each bin in log10(years)
+
+      * ``mass`` - array of shape ``(nbin,)`` giving the total stellar mass
+        (in solar masses) **formed** in each bin.
+    """
 
-to_cgs = to_cgs_at_10pc
+    def get_galaxy_spectrum(self, **params):
+        """Construct the tabular SFH and feed it to the ``ssp``.
+        """
+        self.update(**params)
+        # --- check to make sure agebins have minimum spacing of 1million yrs ---
+        #       (this can happen in flex models and will crash FSPS)
+        if np.min(np.diff(10**self.params['agebins'])) < 1e6:
+            raise ValueError
+
+        mtot = self.params['mass'].sum()
+        time, sfr, tmax = self.convert_sfh(self.params['agebins'], self.params['mass'])
+        self.ssp.params["sfh"] = 3  # Hack to avoid rewriting the superclass
+        self.ssp.set_tabular_sfh(time, sfr)
+        wave, spec = self.ssp.get_spectrum(tage=tmax, peraa=False)
+        return wave, spec / mtot, self.ssp.stellar_mass / mtot
+
+    def convert_sfh(self, agebins, mformed, epsilon=1e-4, maxage=None):
+        """Given arrays of agebins and formed masses with each bin, calculate a
+        tabular SFH.  The resulting time vector has time points either side of
+        each bin edge with a "closeness" defined by a parameter epsilon.
+
+        :param agebins:
+            An array of bin edges, log(yrs).  This method assumes that the
+            upper edge of one bin is the same as the lower edge of another bin.
+            ndarray of shape ``(nbin, 2)``
+
+        :param mformed:
+            The stellar mass formed in each bin.  ndarray of shape ``(nbin,)``
+
+        :param epsilon: (optional, default 1e-4)
+            A small number used to define the fraction time separation of
+            adjacent points at the bin edges.
+
+        :param maxage: (optional, default: ``None``)
+            A maximum age of stars in the population, in yrs.  If ``None`` then the maximum
+            value of ``agebins`` is used.  Note that an error will occur if maxage
+            < the maximum age in agebins.
+
+        :returns time:
+            The output time array for use with sfh=3, in Gyr.  ndarray of shape (2*N)
+
+        :returns sfr:
+            The output sfr array for use with sfh=3, in M_sun/yr.  ndarray of shape (2*N)
+
+        :returns maxage:
+            The maximum valid age in the returned isochrone.
+        """
+        #### create time vector
+        agebins_yrs = 10**agebins.T
+        dt = agebins_yrs[1, :] - agebins_yrs[0, :]
+        bin_edges = np.unique(agebins_yrs)
+        if maxage is None:
+            maxage = agebins_yrs.max()  # can replace maxage with something else, e.g. tuniv
+        t = np.concatenate((bin_edges * (1.-epsilon), bin_edges * (1+epsilon)))
+        t.sort()
+        t = t[1:-1] # remove older than oldest bin, younger than youngest bin
+        fsps_time = maxage - t
+
+        #### calculate SFR at each t
+        sfr = mformed / dt
+        sfrout = np.zeros_like(t)
+        sfrout[::2] = sfr
+        sfrout[1::2] = sfr  # * (1+epsilon)
+
+        return (fsps_time / 1e9)[::-1], sfrout[::-1], maxage / 1e9
 
 
 class CSPSpecBasis(SSPBasis):
@@ -121,160 +343,3 @@ def get_galaxy_spectrum(self, **params):
 
         return wave, spectrum, mfrac_sum
 
-
-class MultiComponentCSPBasis(CSPSpecBasis):
-
-    """Similar to :py:class`CSPSpecBasis`, a class for combinations of N composite stellar
-    populations (including single-age populations). The number of composite
-    stellar populations is given by the length of the `mass` parameter.
-
-    However, in MultiComponentCSPBasis the SED of the different components are
-    tracked, and in get_spectrum() photometry can be drawn from a given
-    component or from the sum.
-    """
-    
-    def get_galaxy_spectrum(self, **params):
-        """Update parameters, then loop over each component getting a spectrum
-        for each.  Return all the component spectra, plus the sum.
-
-        :param params:
-            A parameter dictionary that gets passed to the ``self.update``
-            method and will generally include physical parameters that control
-            the stellar population and output spectrum or SED, some of which
-            may be vectors for the different componenets
-
-        :returns wave:
-            Wavelength in angstroms.
-
-        :returns spectrum:
-            Spectrum in units of Lsun/Hz/solar masses formed.  ndarray of
-            shape(ncomponent+1, nwave).  The last element is the sum of the
-            previous elements.
-
-        :returns mass_fraction:
-            Fraction of the formed stellar mass that still exists, ndarray of
-            shape (ncomponent+1,)
-        """
-        self.update(**params)
-        spectra = []
-        mass = np.atleast_1d(self.params['mass']).copy()
-        mfrac = np.zeros_like(mass)
-        # Loop over mass components
-        for i, m in enumerate(mass):
-            self.update_component(i)
-            wave, spec = self.ssp.get_spectrum(tage=self.ssp.params['tage'],
-                                               peraa=False)
-            spectra.append(spec)
-            mfrac[i] = (self.ssp.stellar_mass)
-
-        # Convert normalization units from per stellar mass to per mass formed
-        if np.all(self.params.get('mass_units', 'mformed') == 'mstar'):
-            mass /= mfrac
-        spectrum = np.dot(mass, np.array(spectra)) / mass.sum()
-        mfrac_sum = np.dot(mass, mfrac) / mass.sum()
-
-        return wave, np.squeeze(spectra + [spectrum]), np.squeeze(mfrac.tolist() + [mfrac_sum])
-
-    def get_spectrum(self, outwave=None, filters=None, component=-1, **params):
-        """Get a spectrum and SED for the given params, choosing from different
-        possible components.
-
-        :param outwave: (default: None)
-            Desired *vacuum* wavelengths.  Defaults to the values in
-            `sps.wavelength`.
-
-        :param peraa: (default: False)
-            If `True`, return the spectrum in erg/s/cm^2/AA instead of AB
-            maggies.
-
-        :param filters: (default: None)
-            A list of filter objects for which you'd like photometry to be
-            calculated.
-
-        :param component: (optional, default: -1)
-            An optional array where each element gives the index of the
-            component from which to choose the magnitude.  scalar or iterable
-            of same length as `filters`
-
-        :param **params:
-            Optional keywords giving parameter values that will be used to
-            generate the predicted spectrum.
-
-        :returns spec:
-            Observed frame component spectra in AB maggies, unless `peraa=True` in which
-            case the units are erg/s/cm^2/AA.  (ncomp+1, nwave)
-
-        :returns phot:
-            Observed frame photometry in AB maggies, ndarray of shape (ncomp+1, nfilters)
-
-        :returns mass_frac:
-            The ratio of the surviving stellar mass to the total mass formed.
-        """
-
-        # Spectrum in Lsun/Hz per solar mass formed, restframe
-        wave, spectrum, mfrac = self.get_galaxy_spectrum(**params)
-
-        # Redshifting + Wavelength solution
-        # We do it ourselves.
-        a = 1 + self.params.get('zred', 0)
-        af = a
-        b = 0.0
-
-        if 'wavecal_coeffs' in self.params:
-            x = wave - wave.min()
-            x = 2.0 * (x / x.max()) - 1.0
-            c = np.insert(self.params['wavecal_coeffs'], 0, 0)
-            # assume coeeficients give shifts in km/s
-            b = chebval(x, c) / (lightspeed*1e-13)
-
-        wa, sa = wave * (a + b), spectrum * af  # Observed Frame
-        if outwave is None:
-            outwave = wa
-
-        # Observed frame photometry, as absolute maggies
-        if filters is not None:
-            # Magic to only do filter projections for unique filters, and get a
-            # mapping back into this list of unique filters
-            # note that this may scramble order of unique_filters
-            fnames = [f.name for f in filters]
-            unique_names, uinds, filter_ind = np.unique(fnames, return_index=True, return_inverse=True)
-            unique_filters = np.array(filters)[uinds]
-            mags = getSED(wa, lightspeed/wa**2 * sa * to_cgs, unique_filters)
-            phot = np.atleast_1d(10**(-0.4 * mags))
-        else:
-            phot = 0.0
-            filter_ind = 0
-
-        # Distance dimming and unit conversion
-        zred = self.params.get('zred', 0.0)
-        if (zred == 0) or ('lumdist' in self.params):
-            # Use 10pc for the luminosity distance (or a number
-            # provided in the dist key in units of Mpc)
-            dfactor = (self.params.get('lumdist', 1e-5) * 1e5)**2
-        else:
-            lumdist = cosmo.luminosity_distance(zred).value
-            dfactor = (lumdist * 1e5)**2
-
-        # Spectrum will be in maggies
-        sa *= to_cgs / dfactor / (3631*jansky_cgs)
-
-        # Convert from absolute maggies to apparent maggies
-        phot /= dfactor
-
-        # Mass normalization
-        mass = np.atleast_1d(self.params['mass'])
-        mass = np.squeeze(mass.tolist() + [mass.sum()])
-
-        sa = (sa * mass[:, None])
-        phot = (phot * mass[:, None])[component, filter_ind]
-
-        return sa, phot, mfrac
-
-
-def gauss(x, mu, A, sigma):
-    """Lay down mutiple gaussians on the x-axis.
-    """
-    mu, A, sigma = np.atleast_2d(mu), np.atleast_2d(A), np.atleast_2d(sigma)
-    val = (A / (sigma * np.sqrt(np.pi * 2)) *
-           np.exp(-(x[:, None] - mu)**2 / (2 * sigma**2)))
-    return val.sum(axis=-1)
diff --git a/prospect/sources/ssp_basis.py b/prospect/sources/ssp_basis.py
deleted file mode 100644
index c4b17411..00000000
--- a/prospect/sources/ssp_basis.py
+++ /dev/null
@@ -1,403 +0,0 @@
-from copy import deepcopy
-import numpy as np
-from numpy.polynomial.chebyshev import chebval
-
-from sedpy.smoothing import smoothspec
-from .constants import cosmo, lightspeed, jansky_cgs, to_cgs_at_10pc
-
-try:
-    import fsps
-    from sedpy.observate import getSED
-except(ImportError, RuntimeError):
-    pass
-
-__all__ = ["SSPBasis", "FastSSPBasis", "FastStepBasis",
-           "MultiSSPBasis"]
-
-
-to_cgs = to_cgs_at_10pc
-
-
-class SSPBasis(object):
-
-    """This is a class that wraps the fsps.StellarPopulation object, which is
-    used for producing SSPs.  The ``fsps.StellarPopulation`` object is accessed
-    as ``SSPBasis().ssp``.
-
-    This class allows for the custom calculation of relative SSP weights (by
-    overriding ``all_ssp_weights``) to produce spectra from arbitrary composite
-    SFHs. Alternatively, the entire ``get_galaxy_spectrum`` method can be
-    overridden to produce a galaxy spectrum in some other way, for example
-    taking advantage of weight calculations within FSPS for tabular SFHs or for
-    parameteric SFHs.
-
-    The base implementation here produces an SSP interpolated to the age given
-    by ``tage``, with initial mass given by ``mass``.  However, this is much
-    slower than letting FSPS calculate the weights, as implemented in
-    :py:class:`FastSSPBasis`.
-
-    Furthermore, smoothing, redshifting, and filter projections are handled
-    outside of FSPS, allowing for fast and more flexible algorithms.
-
-    :param reserved_params:
-        These are parameters which have names like the FSPS parameters but will
-        not be passed to the StellarPopulation object because we are overriding
-        their functionality using (hopefully more efficient) custom algorithms.
-    """
-
-    def __init__(self, zcontinuous=1, reserved_params=['tage', 'sigma_smooth'],
-                 interp_type='logarithmic', flux_interp='linear',
-                 mint_log=-3, compute_vega_mags=False,
-                 **kwargs):
-        """
-        :param interp_type: (default: "logarithmic")
-            Specify whether to linearly interpolate the SSPs in log(t) or t.
-            For the latter, set this to "linear".
-
-        :param flux_interp': (default: "linear")
-            Whether to compute the final spectrum as \sum_i w_i f_i or
-            e^{\sum_i w_i ln(f_i)}.  Basically you should always do the former,
-            which is the default.
-
-        :param mint_log: (default: -3)
-            The log of the age (in years) of the youngest SSP.  Note that the
-            SSP at this age is assumed to have the same spectrum as the minimum
-            age SSP avalibale from fsps.  Typically anything less than 4 or so
-            is fine for this parameter, since the integral converges as log(t)
-            -> -inf
-
-        :param reserved_params:
-            These are parameters which have names like the FSPS parameters but
-            will not be passed to the StellarPopulation object because we are
-            overriding their functionality using (hopefully more efficient)
-            custom algorithms.
-        """
-
-        self.interp_type = interp_type
-        self.mint_log = mint_log
-        self.flux_interp = flux_interp
-        self.ssp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
-                                          zcontinuous=zcontinuous)
-        self.ssp.params['sfh'] = 0
-        self.reserved_params = reserved_params
-        self.params = {}
-        self.update(**kwargs)
-
-    def update(self, **params):
-        """Update the parameters, passing the *unreserved* FSPS parameters
-        through to the ``fsps.StellarPopulation`` object.
-
-        :param params:
-            A parameter dictionary.
-        """
-        for k, v in params.items():
-            # try to make parameters scalar
-            try:
-                if (len(v) == 1) and callable(v[0]):
-                    self.params[k] = v[0]
-                else:
-                    self.params[k] = np.squeeze(v)
-            except:
-                self.params[k] = v
-            # Parameters named like FSPS params but that we reserve for use
-            # here.  Do not pass them to FSPS.
-            if k in self.reserved_params:
-                continue
-            # Otherwise if a parameter exists in the FSPS parameter set, pass a
-            # copy of it in.
-            if k in self.ssp.params.all_params:
-                self.ssp.params[k] = deepcopy(v)
-
-        # We use FSPS for SSPs !!ONLY!!
-        # except for FastStepBasis.  And CSPSpecBasis. and...
-        # assert self.ssp.params['sfh'] == 0
-
-    def get_galaxy_spectrum(self, **params):
-        """Update parameters, then multiply SSP weights by SSP spectra and
-        stellar masses, and sum.
-
-        :returns wave:
-            Wavelength in angstroms.
-
-        :returns spectrum:
-            Spectrum in units of Lsun/Hz/solar masses formed.
-
-        :returns mass_fraction:
-            Fraction of the formed stellar mass that still exists.
-        """
-        self.update(**params)
-
-        # Get the SSP spectra and masses (caching the latter), adding an extra
-        # mass and spectrum for t=0, using the first SSP spectrum.
-        wave, ssp_spectra = self.ssp.get_spectrum(tage=0, peraa=False)
-        ssp_spectra = np.vstack([ssp_spectra[0, :], ssp_spectra])
-        self.ssp_stellar_masses = np.insert(self.ssp.stellar_mass, 0, 1.0)
-        if self.flux_interp == 'logarithmic':
-            ssp_spectra = np.log(ssp_spectra)
-
-        # Get weighted sum of spectra, adding the t=0 spectrum using the first SSP.
-        weights = self.all_ssp_weights
-        spectrum = np.dot(weights, ssp_spectra) / weights.sum()
-        if self.flux_interp == 'logarithmic':
-            spectrum = np.exp(spectrum)
-
-        # Get the weighted stellar_mass/mformed ratio
-        mass_frac = (self.ssp_stellar_masses * weights).sum() / weights.sum()
-        return wave, spectrum, mass_frac
-
-    def get_galaxy_elines(self):
-        """Get the wavelengths and specific emission line luminosity of the nebular emission lines
-        predicted by FSPS. These lines are in units of Lsun/solar mass formed.
-        This assumes that `get_galaxy_spectrum` has already been called.
-
-        :returns ewave:
-            The *restframe* wavelengths of the emission lines, AA
-
-        :returns elum:
-            Specific luminosities of the nebular emission lines,
-            Lsun/stellar mass formed
-        """
-        ewave = self.ssp.emline_wavelengths
-        # This allows subclasses to set their own specific emission line
-        # luminosities within other methods, e.g., get_galaxy_spectrum, by
-        # populating the `_specific_line_luminosity` attribute.
-        elum = getattr(self, "_line_specific_luminosity", None)
-
-        if elum is None:
-            elum = self.ssp.emline_luminosity.copy()
-            if elum.ndim > 1:
-                elum = elum[0]
-            if self.ssp.params["sfh"] == 3:
-                # tabular sfh
-                mass = np.sum(self.params.get('mass', 1.0))
-                elum /= mass
-
-        return ewave, elum
-
-    def get_spectrum(self, outwave=None, filters=None, peraa=False, **params):
-        """Get a spectrum and SED for the given params.
-
-        :param outwave: (default: None)
-            Desired *vacuum* wavelengths.  Defaults to the values in
-            ``sps.wavelength``.
-
-        :param peraa: (default: False)
-            If `True`, return the spectrum in erg/s/cm^2/AA instead of AB
-            maggies.
-
-        :param filters: (default: None)
-            A list of filter objects for which you'd like photometry to be calculated.
-
-        :param params:
-            Optional keywords giving parameter values that will be used to
-            generate the predicted spectrum.
-
-        :returns spec:
-            Observed frame spectrum in AB maggies, unless ``peraa=True`` in which
-            case the units are erg/s/cm^2/AA.
-
-        :returns phot:
-            Observed frame photometry in AB maggies.
-
-        :returns mass_frac:
-            The ratio of the surviving stellar mass to the total mass formed.
-        """
-        # Spectrum in Lsun/Hz per solar mass formed, restframe
-        wave, spectrum, mfrac = self.get_galaxy_spectrum(**params)
-
-        # Redshifting + Wavelength solution
-        # We do it ourselves.
-        a = 1 + self.params.get('zred', 0)
-        af = a
-        b = 0.0
-
-        if 'wavecal_coeffs' in self.params:
-            x = wave - wave.min()
-            x = 2.0 * (x / x.max()) - 1.0
-            c = np.insert(self.params['wavecal_coeffs'], 0, 0)
-            # assume coeeficients give shifts in km/s
-            b = chebval(x, c) / (lightspeed*1e-13)
-
-        wa, sa = wave * (a + b), spectrum * af  # Observed Frame
-        if outwave is None:
-            outwave = wa
-
-        # Observed frame photometry, as absolute maggies
-        if filters is not None:
-            flambda = lightspeed/wa**2 * sa * to_cgs
-            phot = 10**(-0.4 * np.atleast_1d(getSED(wa, flambda, filters)))
-            # TODO: below is faster for sedpy > 0.2.0
-            #phot = np.atleast_1d(getSED(wa, lightspeed/wa**2 * sa * to_cgs,
-            #                            filters, linear_flux=True))
-        else:
-            phot = 0.0
-
-        # Spectral smoothing.
-        do_smooth = (('sigma_smooth' in self.params) and
-                     ('sigma_smooth' in self.reserved_params))
-        if do_smooth:
-            # We do it ourselves.
-            smspec = self.smoothspec(wa, sa, self.params['sigma_smooth'],
-                                     outwave=outwave, **self.params)
-        elif outwave is not wa:
-            # Just interpolate
-            smspec = np.interp(outwave, wa, sa, left=0, right=0)
-        else:
-            # no interpolation necessary
-            smspec = sa
-
-        # Distance dimming and unit conversion
-        zred = self.params.get('zred', 0.0)
-        if (zred == 0) or ('lumdist' in self.params):
-            # Use 10pc for the luminosity distance (or a number
-            # provided in the dist key in units of Mpc)
-            dfactor = (self.params.get('lumdist', 1e-5) * 1e5)**2
-        else:
-            lumdist = cosmo.luminosity_distance(zred).value
-            dfactor = (lumdist * 1e5)**2
-        if peraa:
-            # spectrum will be in erg/s/cm^2/AA
-            smspec *= to_cgs / dfactor * lightspeed / outwave**2
-        else:
-            # Spectrum will be in maggies
-            smspec *= to_cgs / dfactor / (3631*jansky_cgs)
-
-        # Convert from absolute maggies to apparent maggies
-        phot /= dfactor
-
-        # Mass normalization
-        mass = np.sum(self.params.get('mass', 1.0))
-        if np.all(self.params.get('mass_units', 'mformed') == 'mstar'):
-            # Convert input normalization units from current stellar mass to mass formed
-            mass /= mfrac
-
-        return smspec * mass, phot * mass, mfrac
-
-    @property
-    def all_ssp_weights(self):
-        """Weights for a single age population.  This is a slow way to do this!
-        """
-        if self.interp_type == 'linear':
-            sspages = np.insert(10**self.logage, 0, 0)
-            tb = self.params['tage'] * 1e9
-
-        elif self.interp_type == 'logarithmic':
-            sspages = np.insert(self.logage, 0, self.mint_log)
-            tb = np.log10(self.params['tage']) + 9
-
-        ind = np.searchsorted(sspages, tb)  # index of the higher bracketing lookback time
-        dt = (sspages[ind] - sspages[ind - 1])
-        ww = np.zeros(len(sspages))
-        ww[ind - 1] = (sspages[ind] - tb) / dt
-        ww[ind] = (tb - sspages[ind-1]) / dt
-        return ww
-
-    def smoothspec(self, wave, spec, sigma, outwave=None, **kwargs):
-        outspec = smoothspec(wave, spec, sigma, outwave=outwave, **kwargs)
-        return outspec
-
-    @property
-    def logage(self):
-        return self.ssp.ssp_ages.copy()
-
-    @property
-    def wavelengths(self):
-        return self.ssp.wavelengths.copy()
-
-
-class FastSSPBasis(SSPBasis):
-    """A subclass of :py:class:`SSPBasis` that is a faster way to do SSP models by letting
-    FSPS do the weight calculations.
-    """
-
-    def get_galaxy_spectrum(self, **params):
-        self.update(**params)
-        wave, spec = self.ssp.get_spectrum(tage=float(self.params['tage']), peraa=False)
-        return wave, spec, self.ssp.stellar_mass
-
-
-class FastStepBasis(SSPBasis):
-    """Subclass of :py:class:`SSPBasis` that implements a "nonparameteric"
-    (i.e. binned) SFH.  This is accomplished by generating a tabular SFH with
-    the proper form to be passed to FSPS. The key parameters for this SFH are:
-
-      * ``agebins`` - array of shape ``(nbin, 2)`` giving the younger and older
-        (in lookback time) edges of each bin in log10(years)
-
-      * ``mass`` - array of shape ``(nbin,)`` giving the total stellar mass
-        (in solar masses) **formed** in each bin.
-    """
-
-    def get_galaxy_spectrum(self, **params):
-        """Construct the tabular SFH and feed it to the ``ssp``.
-        """
-        self.update(**params)
-        # --- check to make sure agebins have minimum spacing of 1million yrs ---
-        #       (this can happen in flex models and will crash FSPS)
-        if np.min(np.diff(10**self.params['agebins'])) < 1e6:
-            raise ValueError
-
-        mtot = self.params['mass'].sum()
-        time, sfr, tmax = self.convert_sfh(self.params['agebins'], self.params['mass'])
-        self.ssp.params["sfh"] = 3  # Hack to avoid rewriting the superclass
-        self.ssp.set_tabular_sfh(time, sfr)
-        wave, spec = self.ssp.get_spectrum(tage=tmax, peraa=False)
-        return wave, spec / mtot, self.ssp.stellar_mass / mtot
-
-    def convert_sfh(self, agebins, mformed, epsilon=1e-4, maxage=None):
-        """Given arrays of agebins and formed masses with each bin, calculate a
-        tabular SFH.  The resulting time vector has time points either side of
-        each bin edge with a "closeness" defined by a parameter epsilon.
-
-        :param agebins:
-            An array of bin edges, log(yrs).  This method assumes that the
-            upper edge of one bin is the same as the lower edge of another bin.
-            ndarray of shape ``(nbin, 2)``
-
-        :param mformed:
-            The stellar mass formed in each bin.  ndarray of shape ``(nbin,)``
-
-        :param epsilon: (optional, default 1e-4)
-            A small number used to define the fraction time separation of
-            adjacent points at the bin edges.
-
-        :param maxage: (optional, default: ``None``)
-            A maximum age of stars in the population, in yrs.  If ``None`` then the maximum
-            value of ``agebins`` is used.  Note that an error will occur if maxage
-            < the maximum age in agebins.
-
-        :returns time:
-            The output time array for use with sfh=3, in Gyr.  ndarray of shape (2*N)
-
-        :returns sfr:
-            The output sfr array for use with sfh=3, in M_sun/yr.  ndarray of shape (2*N)
-
-        :returns maxage:
-            The maximum valid age in the returned isochrone.
-        """
-        #### create time vector
-        agebins_yrs = 10**agebins.T
-        dt = agebins_yrs[1, :] - agebins_yrs[0, :]
-        bin_edges = np.unique(agebins_yrs)
-        if maxage is None:
-            maxage = agebins_yrs.max()  # can replace maxage with something else, e.g. tuniv
-        t = np.concatenate((bin_edges * (1.-epsilon), bin_edges * (1+epsilon)))
-        t.sort()
-        t = t[1:-1] # remove older than oldest bin, younger than youngest bin
-        fsps_time = maxage - t
-
-        #### calculate SFR at each t
-        sfr = mformed / dt
-        sfrout = np.zeros_like(t)
-        sfrout[::2] = sfr
-        sfrout[1::2] = sfr  # * (1+epsilon)
-
-        return (fsps_time / 1e9)[::-1], sfrout[::-1], maxage / 1e9
-
-
-class MultiSSPBasis(SSPBasis):
-    """An array of basis spectra with different ages, metallicities, and possibly dust
-    attenuations.
-    """
-    def get_galaxy_spectrum(self):
-        raise(NotImplementedError)

From 81ac17b9ae21d2d6d31026135705633d8d5d81f5 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 29 Nov 2022 13:00:28 +0000
Subject: [PATCH 033/132] replace LineSpec with a method of SpecModel; rename
 get_el() to the more descriptive fit_mle_elines()

---
 prospect/data/observation.py |   2 +-
 prospect/models/sedmodel.py  | 168 +++++++++++------------------------
 2 files changed, 53 insertions(+), 117 deletions(-)

diff --git a/prospect/data/observation.py b/prospect/data/observation.py
index f82ce886..95ae7844 100644
--- a/prospect/data/observation.py
+++ b/prospect/data/observation.py
@@ -316,7 +316,7 @@ def to_oldstyle(self):
 
 class Lines(Spectrum):
 
-    kind = "spectrum"
+    kind = "lines"
     alias = dict(spectrum="flux",
                  unc="uncertainty",
                  wavelength="wavelength",
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 4124449f..de69f253 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -125,6 +125,8 @@ def predict(self, theta, observations=None, sps=None, **extras):
     def predict_obs(self, obs):
         if obs.kind == "spectrum":
             prediction = self.predict_spec(obs)
+        elif obs.kind == "lines":
+            prediction = self.predict_lines(obs)
         elif obs.kind == "photometry":
             prediction = self.predict_phot(obs.filterset)
         return prediction
@@ -152,7 +154,7 @@ def predict_spec(self, obs, **extras):
             spectroscopic calibration factor included.
 
         Numerous quantities related to the emission lines are also cached (see
-        ``cache_eline_parameters()`` and ``fit_el()`` for details.)
+        ``cache_eline_parameters()`` and ``fit_mle_elines()`` for details.)
 
         :param obs:
             An instance of `Spectrum`, containing the output wavelength array,
@@ -208,7 +210,7 @@ def predict_spec(self, obs, **extras):
             # FIXME: do this only if the noise model is non-trivial, and make sure masking is consistent
             #vectors = obs.noise.populate_vectors(obs)
             #sigma_spec = obs.noise.construct_covariance(**vectors)
-            self._fit_eline_spec = self.get_el(obs, calibrated_spec, sigma_spec)
+            self._fit_eline_spec = self.fit_mle_elines(obs, calibrated_spec, sigma_spec)
             calibrated_spec[emask] += self._fit_eline_spec.sum(axis=1)
 
         # --- cache intrinsic spectrum ---
@@ -216,6 +218,52 @@ def predict_spec(self, obs, **extras):
 
         return calibrated_spec
 
+    def predict_lines(self, obs, **extras):
+        """Generate a prediction for the observed nebular line fluxes.  This method assumes
+        that the model parameters have been set and that the following
+        attributes are present and correct
+          + ``_wave`` - The SPS restframe wavelength array
+          + ``_zred`` - Redshift
+          + ``_norm_spec`` - Observed frame spectral fluxes, in units of maggies
+          + ``_eline_wave`` and ``_eline_lum`` - emission line parameters from the SPS model
+        It generates the following attributes
+          + ``_outwave`` - Wavelength grid (observed frame)
+          + ``_speccal`` - Calibration vector
+
+        Numerous quantities related to the emission lines are also cached (see
+        ``cache_eline_parameters()`` and ``fit_mle_elines()`` for details) including
+        ``_predicted_line_inds`` which is the indices of the line that are predicted.
+
+        :param obs:
+            An observation dictionary, containing the keys
+            + ``"wavelength"`` - the observed frame wavelength of the lines.
+            + ``"line_ind"`` - a set of indices identifying the observed lines in
+            the fsps line array
+            Assumed to be the result of :py:meth:`utils.obsutils.rectify_obs`
+
+        :returns spec:
+            The prediction for the observed frame nebular emission line flux these
+            parameters, at the wavelengths specified by ``obs['wavelength']``,
+            ndarray of shape ``(nwave,)`` in units of erg/s/cm^2.
+        """
+        obs_wave = self.observed_wave(self._eline_wave, do_wavecal=False)
+        self._outwave = obs.get('wavelength', obs_wave)
+        assert len(self._outwave) <= len(self.emline_info)
+
+        # --- cache eline parameters ---
+        self.cache_eline_parameters(obs)
+
+        # find the indices of the observed emission lines
+        #dw = np.abs(self._ewave_obs[:, None] - self._outwave[None, :])
+        #self._predicted_line_inds = np.argmin(dw, axis=0)
+        self._predicted_line_inds = obs.get("line_ind")
+        self._speccal = 1.0
+
+        self.line_norm = self.flux_norm() / (1 + self._zred) * (3631*jansky_cgs)
+        elums = self._eline_lum[self._predicted_line_inds] * self.line_norm
+
+        return elums
+
     def predict_phot(self, filterset):
         """Generate a prediction for the observed photometry.  This method assumes
         that the parameters have been set and that the following attributes are
@@ -430,7 +478,7 @@ def parse_elines(self):
             self._use_eline = ~np.isin(self.emline_info["name"],
                                        self.params["elines_to_ignore"])
 
-    def fit_el(self, obs, calibrated_spec, sigma_spec=None):
+    def fit_mle_elines(self, obs, calibrated_spec, sigma_spec=None):
         """Compute the maximum likelihood and, optionally, MAP emission line
         amplitudes for lines that fall within the observed spectral range. Also
         compute and cache the analytic penalty to log-likelihood from
@@ -794,118 +842,6 @@ def obs_to_mask(self, obs):
         return mask, wrange
 
 
-class LineSpecModel(SpecModel):
-
-    """This is a sublcass of SpecModel that predicts emission line fluxes
-    instead of a full spectrum, useful when the continuum is not detected or is
-    otherwise uninformative.
-    """
-
-    def _available_parameters(self):
-        pars = [("linespec_scaling", "This float scales the predicted nebular "
-                 "emission line luminosities, for example to accxount for a "
-                 "(constant in wavelengtrh) slit loss"),
-                ]
-
-        return pars
-
-    def predict_spec(self, obs, **extras):
-        """Generate a prediction for the observed nebular line fluxes.  This method assumes
-        that the model parameters have been set and that the following
-        attributes are present and correct
-          + ``_wave`` - The SPS restframe wavelength array
-          + ``_zred`` - Redshift
-          + ``_norm_spec`` - Observed frame spectral fluxes, in units of maggies
-          + ``_eline_wave`` and ``_eline_lum`` - emission line parameters from the SPS model
-        It generates the following attributes
-          + ``_outwave`` - Wavelength grid (observed frame)
-          + ``_speccal`` - Calibration vector
-
-        Numerous quantities related to the emission lines are also cached (see
-        ``cache_eline_parameters()`` and ``fit_el()`` for details) including
-        ``_predicted_line_inds`` which is the indices of the line that are predicted.
-
-        :param obs:
-            An observation dictionary, containing the keys
-            + ``"wavelength"`` - the observed frame wavelength of the lines.
-            + ``"line_ind"`` - a set of indices identifying the observed lines in
-            the fsps line array
-            Assumed to be the result of :py:meth:`utils.obsutils.rectify_obs`
-
-        :returns spec:
-            The prediction for the observed frame nebular emission line flux these
-            parameters, at the wavelengths specified by ``obs['wavelength']``,
-            ndarray of shape ``(nwave,)`` in units of erg/s/cm^2.
-        """
-        obs_wave = self.observed_wave(self._eline_wave, do_wavecal=False)
-        self._outwave = obs.get('wavelength', obs_wave)
-        assert len(self._outwave) <= len(self.emline_info)
-
-        # --- cache eline parameters ---
-        self.cache_eline_parameters(obs)
-
-        # find the indices of the observed emission lines
-        #dw = np.abs(self._ewave_obs[:, None] - self._outwave[None, :])
-        #self._predicted_line_inds = np.argmin(dw, axis=0)
-        self._predicted_line_inds = obs.get("line_ind")
-        self._speccal = 1.0
-
-        self.line_norm = self.flux_norm() / (1 + self._zred) * (3631*jansky_cgs)
-        self.line_norm *= self.params.get("linespec_scaling", 1.0)
-        elums = self._eline_lum[self._predicted_line_inds] * self.line_norm
-
-        return elums
-
-    def nebline_photometry(self, filters, elams=None, elums=None):
-        """Compute the emission line contribution to photometry.  This requires
-        several cached attributes:
-          + ``_ewave_obs``
-          + ``_eline_lum``
-
-        :param filters:
-            Instance of :py:class:`sedpy.observate.FilterSet` or list of
-            :py:class:`sedpy.observate.Filter` objects
-
-        :param elams: (optional)
-            The emission line wavelength in angstroms.  If not supplied uses the
-            cached ``_ewave_obs`` attribute.
-
-        :param elums: (optional)
-            The emission line flux in erg/s/cm^2.  If not supplied uses  the
-            cached ``_eline_lum`` attribute and applies appropriate distance
-            dimming and unit conversion.
-
-        :returns nebflux:
-            The flux of the emission line through the filters, in units of
-            maggies. ndarray of shape ``(len(filters),)``
-        """
-        if (elams is None) or (elums is None):
-            elams = self._ewave_obs[self._use_eline]
-            # We have to remove the extra (1+z) since this is flux, not a flux density
-            # Also we convert to cgs
-            self.line_norm = self.flux_norm() / (1 + self._zred) * (3631*jansky_cgs)
-            elums = self._eline_lum[self._use_eline] * self.line_norm
-
-        # loop over filters
-        flux = np.zeros(len(filters))
-        try:
-            # TODO: Since in this case filters are on a grid, there should be a
-            # faster way to look up the transmission than the later loop
-            flist = filters.filters
-        except(AttributeError):
-            flist = filters
-        for i, filt in enumerate(flist):
-            # calculate transmission at line wavelengths
-            trans = np.interp(elams, filt.wavelength, filt.transmission,
-                              left=0., right=0.)
-            # include all lines where transmission is non-zero
-            idx = (trans > 0)
-            if True in idx:
-                flux[i] = (trans[idx]*elams[idx]*elums[idx]).sum() / filt.ab_zero_counts
-
-        return flux
-
-
 class AGNSpecModel(SpecModel):
 
     def __init__(self, *args, **kwargs):
@@ -963,7 +899,7 @@ def predict_spec(self, obs, sigma_spec=None, **extras):
             spectroscopic calibration factor included.
 
         Numerous quantities related to the emission lines are also cached (see
-        ``cache_eline_parameters()`` and ``fit_el()`` for details.)
+        ``cache_eline_parameters()`` and ``fit_mle_elines()`` for details.)
 
         :param obs:
             An observation dictionary, containing the output wavelength array,

From 8e9935df2a7357530a5e66852c3dedd702492a96 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 29 Nov 2022 13:14:09 +0000
Subject: [PATCH 034/132] Docstring updates, make env name more flexible in
 install instructions.

---
 conda_install.sh            |  1 -
 prospect/models/sedmodel.py | 23 ++++++++++++++---------
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/conda_install.sh b/conda_install.sh
index 22bd4323..3b9e5f07 100644
--- a/conda_install.sh
+++ b/conda_install.sh
@@ -9,7 +9,6 @@ cd $CODEDIR
 git clone https://github.com/cconroy20/fsps.git
 export SPS_HOME="$PWD/fsps"
 
-# Create and activate environment (named 'prospector')
 git clone https://github.com/bd-j/prospector.git
 cd prospector
 conda env create -f environment.yml -n prospector
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index de69f253..243557db 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -10,7 +10,6 @@
 
 from numpy.polynomial.chebyshev import chebval, chebvander
 from scipy.interpolate import splrep, BSpline
-from scipy.stats import multivariate_normal as mvn
 
 from sedpy.observate import getSED
 from sedpy.smoothing import smoothspec
@@ -20,8 +19,9 @@
 from ..sources.constants import cosmo, lightspeed, ckms, jansky_cgs
 
 
-__all__ = ["SpecModel", "PolySpecModel", "SplineSpecModel",
-           "LineSpecModel", "AGNSpecModel",
+__all__ = ["SpecModel",
+           "PolySpecModel", "SplineSpecModel",
+           "AGNSpecModel",
            "PolyFitModel"]
 
 
@@ -220,28 +220,32 @@ def predict_spec(self, obs, **extras):
 
     def predict_lines(self, obs, **extras):
         """Generate a prediction for the observed nebular line fluxes.  This method assumes
-        that the model parameters have been set and that the following
-        attributes are present and correct
+        that the model parameters have been set, that any adjustments to the
+        emission line fluxes based on ML fitting have been applied, and that the
+        following attributes are present and correct
           + ``_wave`` - The SPS restframe wavelength array
           + ``_zred`` - Redshift
-          + ``_norm_spec`` - Observed frame spectral fluxes, in units of maggies
           + ``_eline_wave`` and ``_eline_lum`` - emission line parameters from the SPS model
         It generates the following attributes
           + ``_outwave`` - Wavelength grid (observed frame)
           + ``_speccal`` - Calibration vector
+          + ``line_norm`` - the conversion from FSPS line luminosities to the
+                            observed line luminosities, including scaling fudge_factor
+          + ``_predicted_line_inds`` - the indices of the line that are predicted
 
         Numerous quantities related to the emission lines are also cached (see
         ``cache_eline_parameters()`` and ``fit_mle_elines()`` for details) including
         ``_predicted_line_inds`` which is the indices of the line that are predicted.
+        ``cache_eline_parameters()`` and ``fit_elines()`` for details).
+
 
         :param obs:
-            An observation dictionary, containing the keys
+            A ``data.observation.Lines()`` instance, with the attributes
             + ``"wavelength"`` - the observed frame wavelength of the lines.
             + ``"line_ind"`` - a set of indices identifying the observed lines in
             the fsps line array
-            Assumed to be the result of :py:meth:`utils.obsutils.rectify_obs`
 
-        :returns spec:
+        :returns elum:
             The prediction for the observed frame nebular emission line flux these
             parameters, at the wavelengths specified by ``obs['wavelength']``,
             ndarray of shape ``(nwave,)`` in units of erg/s/cm^2.
@@ -260,6 +264,7 @@ def predict_lines(self, obs, **extras):
         self._speccal = 1.0
 
         self.line_norm = self.flux_norm() / (1 + self._zred) * (3631*jansky_cgs)
+        self.line_norm *= self.params.get("linespec_scaling", 1.0)
         elums = self._eline_lum[self._predicted_line_inds] * self.line_norm
 
         return elums

From 3a1f234bde534e742d61205cf3e71e843f6f2849 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 30 Nov 2022 01:41:42 +0000
Subject: [PATCH 035/132] Fix imports; update and test AGNSpecModel
 predictions.

---
 prospect/data/observation.py | 20 +++++++++++++-------
 prospect/models/__init__.py  |  2 +-
 prospect/models/sedmodel.py  | 28 ++++++++++++++++++++++++++--
 tests/test_agn_eline.py      | 29 +++++++++++++----------------
 4 files changed, 53 insertions(+), 26 deletions(-)

diff --git a/prospect/data/observation.py b/prospect/data/observation.py
index 95ae7844..963cbe40 100644
--- a/prospect/data/observation.py
+++ b/prospect/data/observation.py
@@ -221,9 +221,13 @@ def wavelength(self):
         return np.array([f.wave_effective for f in self.filters])
 
     def to_oldstyle(self):
-        obs = vars(self)
-        obs.update({k: self[v] for k, v in self.alias.items()})
-        _ = [obs.pop(k) for k in ["flux", "uncertainty", "mask"]]
+        obs = {}
+        obs.update(vars(self))
+        for k, v in self.alias.items():
+            obs[k] = self[v]
+            _ = obs.pop(v)
+        #obs.update({k: self[v] for k, v in self.alias.items()})
+        #_ = [obs.pop(k) for k in ["flux", "uncertainty", "mask"]]
         obs["phot_wave"] = self.wavelength
         return obs
 
@@ -285,7 +289,7 @@ def instrumental_smoothing(self, obswave, influx, libres=0):
             Flux array
 
         libres : float or ndarray
-            Library resolution in units of km/ (dispersion) to be subtracted from the smoothing kernel.
+            Library resolution in units of km/s (dispersion) to be subtracted from the smoothing kernel.
 
         Returns
         -------
@@ -308,9 +312,11 @@ def instrumental_smoothing(self, obswave, influx, libres=0):
         return out
 
     def to_oldstyle(self):
-        obs = vars(self)
-        obs.update({k: self[v] for k, v in self.alias.items()})
-        _ = [obs.pop(k) for k in ["flux", "uncertainty"]]
+        obs = {}
+        obs.update(vars(self))
+        for k, v in self.alias.items():
+            obs[k] = self[v]
+            _ = obs.pop(v)
         return obs
 
 
diff --git a/prospect/models/__init__.py b/prospect/models/__init__.py
index c263ee34..1fe98241 100644
--- a/prospect/models/__init__.py
+++ b/prospect/models/__init__.py
@@ -8,7 +8,7 @@
 
 from .sedmodel import ProspectorParams, SpecModel
 from .sedmodel import PolySpecModel, SplineSpecModel
-from .sedmodel import AGNSpecModel, LineSpecModel
+from .sedmodel import AGNSpecModel
 
 
 __all__ = ["ProspectorParams",
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 243557db..3d5d8871 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -881,7 +881,7 @@ def init_aline_info(self):
         assert np.abs(self.emline_info["wave"][59] - 4863) < 2
         self._aline_lum[ainds] = afluxes
 
-    def predict_spec(self, obs, sigma_spec=None, **extras):
+    def predict_spec(self, obs, **extras):
         """Generate a prediction for the observed spectrum.  This method assumes
         that the parameters have been set and that the following attributes are
         present and correct
@@ -933,7 +933,7 @@ def predict_spec(self, obs, sigma_spec=None, **extras):
         self.cache_eline_parameters(obs, nsigma=nsigma)
 
         # --- smooth and put on output wavelength grid ---
-        smooth_spec = self.smoothspec(obs_wave, self._norm_spec)
+        smooth_spec = self.velocity_smoothing(obs_wave, self._norm_spec)
 
         # --- add fixed lines ---
         assert self.params["nebemlineinspec"] == False, "must add agn and nebular lines within prospector"
@@ -962,6 +962,30 @@ def predict_spec(self, obs, sigma_spec=None, **extras):
 
         return calibrated_spec
 
+    def predict_lines(self, obs, **extras):
+        """Generate a prediction for the observed nebular line fluxes, including
+        AGN.
+
+        :param obs:
+            A ``data.observation.Lines()`` instance, with the attributes
+            + ``"wavelength"`` - the observed frame wavelength of the lines.
+            + ``"line_ind"`` - a set of indices identifying the observed lines in
+            the fsps line array
+
+        :returns elum:
+            The prediction for the observed frame nebular + AGN emission line
+            flux these parameters, at the wavelengths specified by
+            ``obs['wavelength']``, ndarray of shape ``(nwave,)`` in units of
+            erg/s/cm^2.
+        """
+        sflums = super().predict_lines(obs, **extras)
+        anorm = self.params.get('agn_elum', 1.0) * self.line_norm
+        alums = self._aline_lum[self._predicted_line_inds] * anorm
+
+        elums = sflums + alums
+
+        return elums
+
     def predict_phot(self, filters):
         """Generate a prediction for the observed photometry.  This method assumes
         that the parameters have been set and that the following attributes are
diff --git a/tests/test_agn_eline.py b/tests/test_agn_eline.py
index 3fca249d..84f8afe7 100644
--- a/tests/test_agn_eline.py
+++ b/tests/test_agn_eline.py
@@ -5,7 +5,7 @@
 import numpy as np
 
 from sedpy import observate
-from prospect.utils.obsutils import fix_obs
+from prospect.data.observation import Spectrum, Photometry
 from prospect.models.sedmodel import AGNSpecModel
 from prospect.models.templates import TemplateLibrary
 from prospect.sources import CSPSpecBasis
@@ -19,11 +19,13 @@ def test_agn_elines():
     fnames = [f"sdss_{b}0" for b in "ugriz"]
     filts = observate.load_filters(fnames)
 
-    obs = dict(filters=filts,
-               wavelength=np.linspace(3000, 9000, 1000),
-               spectrum=np.ones(1000),
-               unc=np.ones(1000)*0.1)
-    obs = fix_obs(obs)
+    phot = Photometry(filters=filts,
+                      flux=np.ones(len(filts)),
+                      uncertainty=0.1 * np.ones(len(filts)))
+    spec = Spectrum(wavelength=np.linspace(3000, 9000, 1000),
+                    flux=np.ones(1000),
+                    uncertainty=np.ones(1000)*0.1)
+    obs = [spec, phot]
 
     # --- model ---
     model_pars = TemplateLibrary["parametric_sfh"]
@@ -36,26 +38,21 @@ def test_agn_elines():
     model = AGNSpecModel(model_pars)
 
     model.params["agn_elum"] = 1e-4
-    spec0, phot0, x0 = model.predict(model.theta, obs, sps)
+    (spec0, phot0), x0 = model.predict(model.theta, obs, sps)
     model.params["agn_elum"] = 1e-6
-    spec1, phot1, x1 = model.predict(model.theta, obs, sps)
+    (spec1, phot1), x1 = model.predict(model.theta, obs, sps)
     assert (not np.allclose(spec1, spec0)), "changing AGN luminosity had no effect"
 
     model.params["agn_elum"] = 1e-4
     model.params["agn_eline_sigma"] = 400.0
-    spec2, phot2, x2 = model.predict(model.theta, obs, sps)
+    (spec2, phot2), x2 = model.predict(model.theta, obs, sps)
     assert (not np.allclose(spec2, spec0)), "broadening lines had no effect on the spectrum"
 
     assert np.allclose(phot2, phot0), "broadening lines changed the photometry"
 
     # do a check for phot-only obs
-    pobs = dict(filters=filts,
-                maggies=np.ones(len(filts)),
-                maggies_unc=0.1 * np.ones(len(filts)),
-                wavelength=np.linspace(3000, 9000, 1000),
-                spectrum=None)
-    pobs = fix_obs(pobs)
-    spec3, phot3, x2 = model.predict(model.theta, obs=pobs, sps=sps)
+    pobs = [phot]
+    (phot3), x2 = model.predict(model.theta, observations=pobs, sps=sps)
     assert np.allclose(phot3, phot2), "Phot-only obs did not add AGn lines correctly"
 
     if False:

From 6c25bb13f2e1723845077c54073ccebad42f658c Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 15 Jan 2023 21:40:53 -0500
Subject: [PATCH 036/132] fixes for run_dynesty; better observation data
 checking; some work with noise modeling.

---
 prospect/data/observation.py       |  2 ++
 prospect/fitting/fitting.py        |  7 +++----
 prospect/likelihood/noise_model.py | 25 +++++++++----------------
 3 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/prospect/data/observation.py b/prospect/data/observation.py
index 963cbe40..1361bd66 100644
--- a/prospect/data/observation.py
+++ b/prospect/data/observation.py
@@ -86,6 +86,8 @@ def rectify(self):
             return
 
         assert self.wavelength.ndim == 1, "`wavelength` is not 1-d array"
+        assert self.flux.ndim == 1, "flux is not a 1d array"
+        assert self.uncertainty.ndim == 1, "uncertainty is not a 1d array"
         assert self.ndata > 0, "no wavelength points supplied!"
         assert self.uncertainty is not None, "No uncertainties."
         assert len(self.wavelength) == len(self.flux), "Flux array not same shape as wavelength."
diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index 4afa53bd..7c6fdea9 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -100,7 +100,7 @@ def lnprobfn(theta, model=None, observations=None, sps=None,
     # --- Optionally return chi vectors for least-squares ---
     # note this does not include priors!
     if residuals:
-        chi = [compute_chi(spec, obs) for pred, obs in zip(predictions, observations)]
+        chi = [compute_chi(pred, obs) for pred, obs in zip(predictions, observations)]
         return np.concatenate(chi)
 
     # --- Emission Lines ---
@@ -411,7 +411,7 @@ def run_emcee(observations, model, sps, lnprobfn=lnprobfn,
     return sampler, ts
 
 
-def run_dynesty(obs, model, sps, noise, lnprobfn=lnprobfn,
+def run_dynesty(observations, model, sps, lnprobfn=lnprobfn,
                 pool=None, nested_target_n_effective=10000, **kwargs):
     """Thin wrapper on :py:class:`prospect.fitting.nested.run_dynesty_sampler`
 
@@ -461,8 +461,7 @@ def run_dynesty(obs, model, sps, noise, lnprobfn=lnprobfn,
     from dynesty.dynamicsampler import stopping_function, weight_function
     nested_stop_kwargs = {"target_n_effective": nested_target_n_effective}
 
-    lnp = wrap_lnp(lnprobfn, observations, model, sps, noise=noise,
-                   nested=True)
+    lnp = wrap_lnp(lnprobfn, observations, model, sps, nested=True)
 
     # Need to deal with postkwargs...
 
diff --git a/prospect/likelihood/noise_model.py b/prospect/likelihood/noise_model.py
index 5683cb21..9da98abd 100644
--- a/prospect/likelihood/noise_model.py
+++ b/prospect/likelihood/noise_model.py
@@ -12,8 +12,8 @@
 
 class NoiseModel:
 
-    """This class allows for 1-d covariance matrix noise models without any
-    special kernels for covariance matrix construction.
+    """This base class allows for 1-d noise models without any special kernels
+    for covariance matrix construction, but with possibility for outliers.
     """
 
     f_outlier = 0
@@ -31,8 +31,9 @@ def update(self, **params):
 
     def lnlike(self, pred, obs, vectors={}):
 
-        # Construct Sigma (and factorize if 2d)
+        # populatate vectors used as metrics and weight functions.
         vectors = self.populate_vectors(obs)
+        # Construct Sigma (and factorize if 2d)
         self.compute(**vectors)
 
         # Compute likelihood
@@ -56,7 +57,9 @@ def lnlike(self, pred, obs, vectors={}):
     def populate_vectors(self, obs, vectors={}):
         # update vectors
         vectors["mask"] = obs.mask
-        vectors["unc"] = obs.uncertainty
+        vectors["wavelength"] = obs.wavelength
+        vectors["uncertainty"] = obs.uncertainty
+        vectors["flux"] = obs.flux
         if obs.kind == "photometry":
             vectors["filternames"] = obs.filternames
             vectors["phot_samples"] = obs.get("phot_samples", None)
@@ -81,7 +84,8 @@ def lnlikelihood(self, pred, data):
 
 
 class NoiseModelCov(NoiseModel):
-    """This object allows for 1d or 2d covariance matrices constructed from kernels
+    """This object allows for 1d or 2d covariance matrices constructed from
+    kernels.
     """
 
     def __init__(self, frac_out_name="f_outlier", nsigma_out_name="nsigma_outlier",
@@ -95,17 +99,6 @@ def __init__(self, frac_out_name="f_outlier", nsigma_out_name="nsigma_outlier",
         self.metric_name = metric_name
         self.mask_name = mask_name
 
-    def populate_vectors(self, vectors, obs):
-        # update vectors
-        vectors["mask"] = obs.mask
-        vectors["wavelength"] = obs.wavelength
-        vectors["unc"] = obs.uncertainty
-        vectors["flux"] = obs.flux
-        if obs.kind == "photometry":
-            vectors["filternames"] = obs.filternames
-            vectors["phot_samples"] = obs.get("phot_samples", None)
-        return vectors
-
     def construct_covariance(self, **vectors):
         """Construct a covariance matrix from a metric, a list of kernel
         objects, and a list of weight vectors (of same length as the metric)

From 78f23325b348b8f35174dcebad54f5ecbb12be03 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 16 Jan 2023 17:35:24 -0500
Subject: [PATCH 037/132] Fix imports and robustify metadata writing.

---
 prospect/io/write_results.py | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index 765e41b3..ef6ce252 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -6,6 +6,7 @@
 """
 
 import os, time, warnings
+from copy import deepcopy
 import pickle, json, base64
 import numpy as np
 try:
@@ -14,7 +15,6 @@
 except(ImportError):
     _has_h5py_ = False
 
-
 __all__ = ["githash", "write_hdf5",
            "chain_to_struct"]
 
@@ -22,6 +22,23 @@
 unserial = json.dumps('Unserializable')
 
 
+class NumpyEncoder(json.JSONEncoder):
+    """
+    """
+
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        if isinstance(obj, type):
+            return str(obj)
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+
+        return json.JSONEncoder.default(self, obj)
+
+
 def pick(obj):
     """create a serialized object that can go into hdf5 in py2 and py3, and can be read by both
     """
@@ -32,7 +49,8 @@ def githash(**extras):
     """Pull out the git hash history for Prospector here.
     """
     try:
-        from .._version import __version__, __githash__
+        from .._version import __version__#, __githash__
+        __githash__ = None
         bgh = __version__, __githash__
     except(ImportError):
         warnings.warn("Could not obtain prospector version info", RuntimeWarning)
@@ -139,7 +157,7 @@ def write_hdf5(hfile, run_params, model, obs,
             if obs["wavelength"] is None:
                 best.create_dataset("restframe_wavelengths", data=sps.wavelengths)
 
-        # Store the githash last after flushing since getting it might cause an
+    # Store the githash last after flushing since getting it might cause an
     # uncatchable crash
     bgh = githash(**run_params)
     hf.attrs['prospector_version'] = json.dumps(bgh)
@@ -154,7 +172,7 @@ def metadata(run_params, model, write_model_params=True):
         meta["model_params"] = deepcopy(model.params)
     for k, v in list(meta.items()):
         try:
-            meta[k] = json.dumps(v)
+            meta[k] = json.dumps(v, cls=NumpyEncoder)
         except(TypeError):
             meta[k] = pick(v)
         except:

From 28770a74025e6f3462e3ccb75f15cbb44eaf2cc5 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 17 Jan 2023 22:30:36 -0500
Subject: [PATCH 038/132] fix bug in covariance construction; add option to
 median smooth before polynomial fitting; comment out broken bestfit model
 saving.

---
 prospect/io/write_results.py       | 21 +++++++++++----------
 prospect/likelihood/noise_model.py |  4 ++--
 prospect/models/sedmodel.py        | 10 +++++++++-
 3 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index ef6ce252..0194902c 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -146,16 +146,17 @@ def write_hdf5(hfile, run_params, model, obs,
     # Best fitting model in space of data
     if sps is not None:
         if "sampling/chain" in hf:
-            from ..plotting.utils import best_sample
-            pbest = best_sample(hf["sampling"])
-            spec, phot, mfrac = model.predict(pbest, obs=obs, sps=sps)
-            best = hf.create_group("bestfit")
-            best.create_dataset("spectrum", data=spec)
-            best.create_dataset("photometry", data=phot)
-            best.create_dataset("parameter", data=pbest)
-            best.attrs["mfrac"] = mfrac
-            if obs["wavelength"] is None:
-                best.create_dataset("restframe_wavelengths", data=sps.wavelengths)
+            pass
+            #from ..plotting.utils import best_sample
+            #pbest = best_sample(hf["sampling"])
+            #spec, phot, mfrac = model.predict(pbest, obs=obs, sps=sps)
+            #best = hf.create_group("bestfit")
+            #best.create_dataset("spectrum", data=spec)
+            #best.create_dataset("photometry", data=phot)
+            #best.create_dataset("parameter", data=pbest)
+            #best.attrs["mfrac"] = mfrac
+            #if obs["wavelength"] is None:
+            #    best.create_dataset("restframe_wavelengths", data=sps.wavelengths)
 
     # Store the githash last after flushing since getting it might cause an
     # uncatchable crash
diff --git a/prospect/likelihood/noise_model.py b/prospect/likelihood/noise_model.py
index 9da98abd..9fc49e77 100644
--- a/prospect/likelihood/noise_model.py
+++ b/prospect/likelihood/noise_model.py
@@ -65,8 +65,8 @@ def populate_vectors(self, obs, vectors={}):
             vectors["phot_samples"] = obs.get("phot_samples", None)
         return vectors
 
-    def construct_covariance(self, unc=[], mask=slice(None), **vectors):
-        self.Sigma = np.atleast_1d(unc[mask]**2)
+    def construct_covariance(self, uncertainty=[], mask=slice(None), **other_vectors):
+        self.Sigma = np.atleast_1d(uncertainty[mask]**2)
 
     def compute(self, **vectors):
         """Make a boring diagonal Covariance array
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 3d5d8871..786b735e 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -10,6 +10,7 @@
 
 from numpy.polynomial.chebyshev import chebval, chebvander
 from scipy.interpolate import splrep, BSpline
+from scipy.signal import medfilt
 
 from sedpy.observate import getSED
 from sedpy.smoothing import smoothspec
@@ -714,7 +715,8 @@ class PolySpecModel(SpecModel):
 
     def _available_parameters(self):
         pars = [("polyorder", "order of the polynomial to fit"),
-                ("poly_regularization", "vector of length `polyorder` providing regularization for each polynomial term")
+                ("poly_regularization", "vector of length `polyorder` providing regularization for each polynomial term"),
+                ("median_polynomial", "if > 0, median smooth with a kernel of width order/range/median_polynomial before fitting")
                 ]
 
         return pars
@@ -756,6 +758,12 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
             # masked wavelengths may have x>1, x<-1
             x = self.wave_to_x(obs["wavelength"], mask)
             y = (obs['spectrum'] / spec)[mask] - 1.0
+
+            if self.params.get('median_polynomial', 0) > 0:
+                kernel_factor = self.params["median_polynomial"]
+                knl = int((x.max() - x.min()) / order / kernel_factor)
+                knl += int((knl % 2) == 0)
+                y = medfilt(y, knl)
             yerr = (obs['unc'] / spec)[mask]
             yvar = yerr**2
             A = chebvander(x[mask], order)

From b0f80a54c7afe2a36167eb6320a935403b8a89ad Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 19 Jan 2023 22:53:04 -0500
Subject: [PATCH 039/132] io and plotting; allow vector nebemlineinspec.

---
 prospect/data/observation.py             |  80 +++++++-----
 prospect/io/read_results.py              |  42 ++++---
 prospect/io/write_results.py             |   4 +-
 prospect/models/sedmodel.py              |   3 +-
 prospect/plotting/utils.py               |  41 +-----
 prospect/utils/{plotting.py => stats.py} | 153 ++++++++---------------
 6 files changed, 131 insertions(+), 192 deletions(-)
 rename prospect/utils/{plotting.py => stats.py} (61%)

diff --git a/prospect/data/observation.py b/prospect/data/observation.py
index 1361bd66..8d2c3bf5 100644
--- a/prospect/data/observation.py
+++ b/prospect/data/observation.py
@@ -9,8 +9,8 @@
 from ..likelihood.noise_model import NoiseModel
 
 
-__all__ = ["Observation", "Spectrum", "Photometry",
-           "from_oldstyle"]
+__all__ = ["Observation", "Spectrum", "Photometry", "Lines"
+           "from_oldstyle", "from_serial", "obstypes"]
 
 
 class NumpyEncoder(json.JSONEncoder):
@@ -37,8 +37,8 @@ class Observation:
 
     logify_spectrum = False
     alias = {}
-    meta = ["kind", "name"]
-    data = ["wavelength", "flux", "uncertainty", "mask"]
+    _meta = ["kind", "name"]
+    _data = ["wavelength", "flux", "uncertainty", "mask"]
 
     def __init__(self,
                  flux=None,
@@ -126,18 +126,20 @@ def ndata(self):
         else:
             return len(self.wavelength)
 
-    def to_json(self):
-        obs = {m: getattr(self, m) for m in self.meta + self.data}
-        serial = json.dumps(obs, cls=NumpyEncoder)
-        return serial
+    @property
+    def metadata(self):
+        meta = {m: getattr(self, m) for m in self._meta}
+        if "filternames" in meta:
+            meta["filters"] = ",".join(meta["filternames"])
+        return meta
 
     def to_struct(self, data_dtype=np.float32):
         """Convert data to a structured array
         """
         self._automask()
-        dtype = np.dtype([(c, data_dtype) for c in self.data])
+        dtype = np.dtype([(c, data_dtype) for c in self._data])
         struct = np.zeros(self.ndata, dtype=dtype)
-        for c in self.data:
+        for c in self._data:
             data = getattr(self, c)
             try:
                 struct[c] = data
@@ -146,31 +148,27 @@ def to_struct(self, data_dtype=np.float32):
         return struct
 
     def to_fits(self, filename=""):
-        """
-        """
         from astropy.io import fits
         hdus = fits.HDUList([fits.PrimaryHDU(),
                              fits.BinTableHDU(self.to_struct())])
-        meta = {m: getattr(self, m) for m in self.meta}
-        if "filternames" in meta:
-            meta["filters"] = ",".join(meta["filternames"])
-        for k, v in meta.items():
-            try:
-                for hdu in hdus:
-                    hdu.header[k] = v
-            except(ValueError):
-                pass
+        for hdu in hdus:
+            hdu.header.update(self.metadata)
         if filename:
             hdus.writeto(filename, overwrite=True)
             hdus.close()
 
     def to_h5_dataset(self, handle):
         dset = handle.create_dataset(self.name, data=self.to_struct())
-        for m in self.meta:
-            try:
-                dset.attr[m] = getattr(self, m)
-            except:
-                pass
+        dset.attrs.update(self.metadata)
+
+    def to_json(self):
+        obs = {m: getattr(self, m) for m in self._meta + self._data}
+        serial = json.dumps(obs, cls=NumpyEncoder)
+        return serial
+
+    @property
+    def to_nJy(self):
+        return 1e9 * 3631
 
 
 class Photometry(Observation):
@@ -180,7 +178,7 @@ class Photometry(Observation):
                  maggies_unc="uncertainty",
                  filters="filters",
                  phot_mask="mask")
-    meta = ["kind", "name", "filternames"]
+    _meta = ["kind", "name", "filternames"]
 
     def __init__(self, filters=[], name="PhotA", **kwargs):
         """On Observation object that holds photometric data
@@ -203,16 +201,20 @@ def __init__(self, filters=[], name="PhotA", **kwargs):
         super(Photometry, self).__init__(name=name, **kwargs)
 
     def set_filters(self, filters):
-        if not filters:
+        if len(filters) == 0:
             self.filters = filters
             self.filternames = []
             self.filterset = None
             return
 
-        if type(filters[0]) is str:
-            self.filternames = filters
-        else:
+        try:
             self.filternames = [f.name for f in filters]
+        except(AttributeError):
+            self.filternames = filters
+        #if type(filters[0]) is str:
+        #    self.filternames = filters
+        #else:
+        #    self.filternames = [f.name for f in filters]
 
         self.filterset = FilterSet(self.filternames)
         # filters on the gridded resolution
@@ -367,6 +369,11 @@ def __init__(self,
         self.line_ind = np.array(line_ind).as_type(int)
 
 
+obstypes = dict(photometry=Photometry,
+                spectrum=Spectrum,
+                lines=Lines)
+
+
 def from_oldstyle(obs, **kwargs):
     """Convert from an oldstyle dictionary to a list of observations
     """
@@ -375,3 +382,14 @@ def from_oldstyle(obs, **kwargs):
     #[o.rectify() for o in obslist]
 
     return [spec, phot]
+
+
+def from_serial(arr, meta):
+    adict = {a:arr[a] for a in arr.dtype.names}
+    adict["name"] = meta.get("name", "")
+    if 'filters' in meta:
+        adict["filters"] = meta["filters"].split(",")
+    obs = obstypes[meta["kind"]](**adict)
+    #[setattr(obs, m, v) for m, v in meta.items()]
+    return obs
+
diff --git a/prospect/io/read_results.py b/prospect/io/read_results.py
index 71508841..40d9d789 100644
--- a/prospect/io/read_results.py
+++ b/prospect/io/read_results.py
@@ -69,19 +69,17 @@ def results_from(filename, model_file=None, dangerous=True, **kwargs):
 
     """
     # Read the basic chain, parameter, and run_params info
-    res = read_hdf5(filename, **kwargs)
+    res, obs = read_hdf5(filename, **kwargs)
 
     # Now try to instantiate the model object from the paramfile
-    param_file = (res['run_params'].get('param_file', ''),
-                  res.get("paramfile_text", ''))
     if dangerous:
         try:
             model = get_model(res)
         except:
             model = None
-    res['model'] = model
+    #res['model'] = model
 
-    return res, res["obs"], model
+    return res, obs, model
 
 
 def emcee_restarter(restart_from="", niter=32, **kwargs):
@@ -151,8 +149,9 @@ def read_hdf5(filename, **extras):
     :param filename:
         Name of the HDF5 file.
     """
-    groups = {"sampling": {}, "obs": {},
-              "bestfit": {}, "optimization": {}}
+    groups = {"sampling": {},
+              "bestfit": {},
+              "optimization": {}}
     res = {}
     with h5py.File(filename, "r") as hf:
         # loop over the groups
@@ -184,17 +183,23 @@ def read_hdf5(filename, **extras):
         res.update(groups['sampling'])
         res["bestfit"] = groups["bestfit"]
         res["optimization"] = groups["optimization"]
-        res['obs'] = groups['obs']
-        try:
-            res['obs']['filters'] = load_filters([str(f) for f in res['obs']['filters']])
-        except:
-            pass
-        try:
-            res['rstate'] = unpick(res['rstate'])
-        except:
-            pass
+        if 'observations' in hf:
+            obs = obs_from_h5(hf['observations'])
+        else:
+            obs = None
+        #res['obs'] = obs
+
+    return res, obs
+
 
-    return res
+def obs_from_h5(obsgroup):
+    from ..data.observation import from_serial
+    observations = []
+    for obsname, dset in obsgroup.items():
+        arr, meta = dset[:], dict(dset.attrs)
+        obs = from_serial(arr, meta)
+        observations.append(obs)
+    return observations
 
 
 def get_sps(res):
@@ -258,8 +263,7 @@ def get_model(res):
         A prospect.models.SedModel object
     """
     import os
-    param_file = (res['run_params'].get('param_file', ''),
-                  res.get("paramfile_text", ''))
+    param_file = ("prospar", res.get("paramfile_text", ''))
     path, filename = os.path.split(param_file[0])
     modname = filename.replace('.py', '')
     user_module = import_module_from_string(param_file[1], modname)
diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index 0194902c..748cd1f5 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -126,7 +126,7 @@ def write_hdf5(hfile, run_params, model, obs,
     # High level parameter and version info
     meta = metadata(run_params, model, write_model_params=write_model_params)
     for k, v in meta.items():
-        hf.attrs[k] = k
+        hf.attrs[k] = v
     hf.flush()
 
     # -----------------
@@ -232,7 +232,7 @@ def write_obs_to_h5(hf, obslist):
     """Write observational data to the hdf5 file
     """
     try:
-        odat = hf.create_group('obs')
+        odat = hf.create_group('observations')
     except(ValueError):
         # We already have an 'obs' group
         return
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 786b735e..73eb65b3 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -340,7 +340,7 @@ def init_eline_info(self, eline_file='emlines_info.dat'):
 
     @property
     def _need_lines(self):
-        return (not (bool(self.params.get("nebemlineinspec", True))))
+        return (not (bool(np.any(self.params.get("nebemlineinspec", True)))))
 
     @property
     def _want_lines(self):
@@ -430,6 +430,7 @@ def cache_eline_parameters(self, obs, nsigma=5, forcelines=False):
         # exit gracefully if not adding lines.  We also exit if only fitting
         # photometry, for performance reasons
         hasspec = obs.get('spectrum', None) is not None
+        #hasspec = True
         if not (self._want_lines & self._need_lines & hasspec):
             self._fit_eline_pixelmask = np.array([], dtype=bool)
             self._fix_eline_pixelmask = np.array([], dtype=bool)
diff --git a/prospect/plotting/utils.py b/prospect/plotting/utils.py
index f5c13ad2..df08c489 100644
--- a/prospect/plotting/utils.py
+++ b/prospect/plotting/utils.py
@@ -4,9 +4,10 @@
 import numpy as np
 from .corner import _quantile
 from ..models.priors import TopHat as Uniform
+from ..utils.stats import get_best, best_sample
 
-
-__all__ = ["get_best", "best_sample", "get_simple_prior", "sample_prior", "sample_posterior",
+__all__ = ["get_best", "best_sample",
+           "get_simple_prior", "sample_prior", "sample_posterior",
            "boxplot", "violinplot", "step"]
 
 
@@ -92,42 +93,6 @@ def sample_posterior(chain, weights=None, nsample=int(1e4),
         return flatchain[inds, :], extra[inds, ...]
 
 
-def get_best(res, **kwargs):
-    """Get the maximum a posteriori parameters and their names
-
-    :param res:
-        A ``results`` dictionary with the keys 'lnprobability', 'chain', and
-        'theta_labels'
-
-    :returns theta_names:
-        List of strings giving the names of the parameters, of length ``ndim``
-
-    :returns best:
-        ndarray with shape ``(ndim,)`` of parameter values corresponding to the
-        sample with the highest posterior probaility
-    """
-    theta_best = best_sample(res)
-
-    try:
-        theta_names = res["theta_labels"]
-    except(KeyError):
-        theta_names = res["model"].theta_labels()
-    return theta_names, theta_best
-
-
-def best_sample(res):
-    """Get the posterior sample with the highest posterior probability.
-    """
-    imax = np.argmax(res['lnprobability'])
-    # there must be a more elegant way to deal with differnt shapes
-    try:
-        i, j = np.unravel_index(imax, res['lnprobability'].shape)
-        theta_best = res['chain'][i, j, :].copy()
-    except(ValueError):
-        theta_best = res['chain'][imax, :].copy()
-    return theta_best
-
-
 def violinplot(data, pos, widths, ax=None,
                violin_kwargs={"showextrema": False},
                color="slateblue", alpha=0.5, span=None, **extras):
diff --git a/prospect/utils/plotting.py b/prospect/utils/stats.py
similarity index 61%
rename from prospect/utils/plotting.py
rename to prospect/utils/stats.py
index 9c1940e0..91d24dd2 100644
--- a/prospect/utils/plotting.py
+++ b/prospect/utils/stats.py
@@ -7,13 +7,49 @@
 except(ImportError):
     pass
 
-from ..plotting.utils import get_best
 
 __all__ = ["get_best", "get_truths", "get_percentiles", "get_stats",
            "posterior_samples", "hist_samples", "joint_pdf", "compute_sigma_level",
            "trim_walkers", "fill_between", "figgrid"]
 
 
+def flatstruct(struct):
+    params = struct.dtype.names
+    m = [struct[s] for s in params]
+    return np.concatenate(m), params
+
+
+def get_best(res, **kwargs):
+    """Get the maximum a posteriori parameters and their names
+
+    :param res:
+        A ``results`` dictionary with the keys 'lnprobability', 'chain', and
+        'theta_labels'
+
+    :returns theta_names:
+        List of strings giving the names of the parameters, of length ``ndim``
+
+    :returns best:
+        ndarray with shape ``(ndim,)`` of parameter values corresponding to the
+        sample with the highest posterior probaility
+    """
+    qbest, qnames = flatstruct(best_sample(res))
+    return qnames, qbest
+
+
+def best_sample(res):
+    """Get the posterior sample with the highest posterior probability.
+    """
+    imax = np.argmax(res['lnprobability'])
+    # there must be a more elegant way to deal with differnt shapes
+    try:
+        i, j = np.unravel_index(imax, res['lnprobability'].shape)
+        Qbest = res['chain'][i, j].copy()
+    except(ValueError):
+        Qbest = res['chain'][imax].copy()
+    return Qbest
+
+
 def get_truths(res):
     import pickle
     try:
@@ -48,16 +84,22 @@ def get_percentiles(res, ptile=[16, 50, 84], start=0.0, thin=1, **extras):
        requested percentiles for that parameter.
     """
 
-    parnames = np.array(res.get('theta_labels', res['model'].theta_labels()))
-    niter = res['chain'].shape[-2]
+    chaincat = res["chain"]
+    niter = res['chain'].shape[0]
+    parnames = chaincat.dtype.names
+    weights = res.get("weights", None)
+
+
     start_index = np.floor(start * (niter-1)).astype(int)
-    if res["chain"].ndim > 2:
-        flatchain = res['chain'][:, start_index::thin, :]
-        dims = flatchain.shape
-        flatchain = flatchain.reshape(dims[0]*dims[1], dims[2])
-    elif res["chain"].ndim == 2:
-        flatchain = res["chain"][start_index::thin, :]
-    pct = np.array([quantile(p, ptile, weights=res.get("weights", None)) for p in flatchain.T])
+    if res["chain"].ndim > 1:
+        flatchain = res['chain'][:, start_index::thin]
+        flatchain = flatchain.reshape(-1)
+    elif res["chain"].ndim == 1:
+        flatchain = res["chain"][start_index::thin]
+    chain = flatstruct(chaincat)
+
+    pct = [quantile(x, ptile, weights=weights, axis=0)
+           for x in chain.T]
     return dict(zip(parnames, pct))
 
 
@@ -111,38 +153,6 @@ def trim_walkers(res, threshold=-1e4):
     return trimmed
 
 
-def joint_pdf(res, p1, p2, pmap={}, **kwargs):
-    """Build a 2-dimensional array representing the binned joint PDF of 2
-    parameters, in terms of sigma or fraction of the total distribution.
-
-    For example, to plot contours of the joint PDF of parameters ``"parname1"``
-    and ``"parname2"`` from the last half of a chain with 30bins in each
-    dimension;
-
-    ::
-
-        xb, yb, sigma = joint_pdf(res, parname1, parname2, nbins=30, start=0.5)
-        ax.contour(xb, yb, sigma, **plotting_kwargs)
-
-    :param p1:
-        The name of the parameter for the x-axis
-
-    :param p2:
-        The name of the parameter for the y axis
-
-    :returns xb, yb, sigma:
-        The bins and the 2-d histogram
-    """
-    trace, pars = hist_samples(res, [p1, p2], **kwargs)
-    trace = trace.copy().T
-    if pars[0] == p1:
-        trace = trace[::-1, :]
-    x = pmap.get(p2, lambda x: x)(trace[0])
-    y = pmap.get(p1, lambda x: x)(trace[1])
-    xbins, ybins, sigma = compute_sigma_level(x, y, **kwargs)
-    return xbins, ybins, sigma.T
-
-
 def posterior_samples(res, nsample=None, **kwargs):
     """Pull samples of theta from the MCMC chain
 
@@ -211,64 +221,5 @@ def hist_samples(res, showpars=None, start=0, thin=1,
     return flatchain, parnames[ind_show]
 
 
-def compute_sigma_level(trace1, trace2, nbins=30, weights=None, extents=None, **extras):
-    """From a set of traces in two parameters, make a 2-d histogram of number
-    of standard deviations.  Following examples from J Vanderplas.
-    """
-    L, xbins, ybins = np.histogram2d(trace1, trace2, bins=nbins,
-                                     weights=weights,
-                                     range=extents)
-    L[L == 0] = 1E-16
-    logL = np.log(L)
-
-    shape = L.shape
-    L = L.ravel()
-
-    # obtain the indices to sort and unsort the flattened array
-    i_sort = np.argsort(L)[::-1]
-    i_unsort = np.argsort(i_sort)
-
-    L_cumsum = L[i_sort].cumsum()
-    L_cumsum /= L_cumsum[-1]
-
-    xbins = 0.5 * (xbins[1:] + xbins[:-1])
-    ybins = 0.5 * (ybins[1:] + ybins[:-1])
-
-    return xbins, ybins, L_cumsum[i_unsort].reshape(shape)
-
-
-def figgrid(ny, nx, figsize=None, left=0.1, right=0.85,
-            top=0.9, bottom=0.1, wspace=0.2, hspace=0.10):
-    """Gridpars is
-    left, right
-    """
-    from matplotlib import gridspec
-    if figsize is None:
-        figsize = (nx*4.5, ny*3)
-    fig = pl.figure(figsize=figsize)
-    axarray = np.zeros([ny, nx], dtype=np.dtype('O'))
-    gs1 = gridspec.GridSpec(ny, nx)
-    gs1.update(left=left, right=right, top=top, bottom=bottom,
-               wspace=wspace, hspace=hspace)
-    for i in range(ny):
-        for j in range(nx):
-            axarray[i, j] = fig.add_subplot(gs1[i, j])
-    return fig, axarray
-
-
-def fill_between(x, y1, y2=0, ax=None, **kwargs):
-    """Plot filled region between `y1` and `y2`.
-
-    This function works exactly the same as matplotlib's fill_between, except
-    that it also plots a proxy artist (specifically, a rectangle of 0 size)
-    so that it can be added it appears on a legend.
-    """
-    ax = ax if ax is not None else pl.gca()
-    ax.fill_between(x, y1, y2, **kwargs)
-    p = pl.Rectangle((0, 0), 0, 0, **kwargs)
-    ax.add_patch(p)
-    return p
-
-
 def logify(x):
     return np.log10(x)

From 3f419d131e4747776ab11e6fb4d4566f493a2c65 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 11 Apr 2023 10:50:11 -0400
Subject: [PATCH 040/132] Rename prospect.data -> prospect.observation. Also
 slight change to instrumental smoothing.

---
 prospect/data/__init__.py                     |  6 ------
 prospect/models/sedmodel.py                   | 15 ++++++++-------
 prospect/observation/__init__.py              |  6 ++++++
 prospect/{data => observation}/observation.py | 15 ++++++++-------
 prospect/{data => observation}/obsutils.py    |  0
 pyproject.toml                                |  2 +-
 tests/test_agn_eline.py                       |  2 +-
 tests/test_eline.py                           |  2 +-
 8 files changed, 25 insertions(+), 23 deletions(-)
 delete mode 100644 prospect/data/__init__.py
 create mode 100644 prospect/observation/__init__.py
 rename prospect/{data => observation}/observation.py (95%)
 rename prospect/{data => observation}/obsutils.py (100%)

diff --git a/prospect/data/__init__.py b/prospect/data/__init__.py
deleted file mode 100644
index f4bb7dc4..00000000
--- a/prospect/data/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from .observation import Photometry, Spectrum, from_oldstyle
-
-__all__ = ["Photometry", "Spectrum",
-           "from_oldstyle"]
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 73eb65b3..4a077822 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -72,7 +72,7 @@ def predict(self, theta, observations=None, sps=None, **extras):
         theta : ndarray of shape ``(ndim,)``
             Vector of free model parameter values.
 
-        observations : A list of `Observation` instances.
+        observations : A list of `Observation` instances (e.g. instance of )
             The data to predict
 
         sps :
@@ -104,7 +104,7 @@ def predict(self, theta, observations=None, sps=None, **extras):
         self._wave, self._spec, self._mfrac = sps.get_galaxy_spectrum(**self.params)
         self._zred = self.params.get('zred', 0)
         self._eline_wave, self._eline_lum = sps.get_galaxy_elines()
-        self._library_resolution = getattr(sps, "spectral_resolution", 0.0)
+        self._library_resolution = getattr(sps, "spectral_resolution", 0.0) # restframe
 
         # Flux normalize
         self._norm_spec = self._spec * self.flux_norm()
@@ -184,10 +184,11 @@ def predict_spec(self, obs, **extras):
         self.cache_eline_parameters(obs)
 
         # --- smooth and put on output wavelength grid ---
-        # physical smoothing
+        # Physical smoothing of the whole spectrum
         smooth_spec = self.velocity_smoothing(obs_wave, self._norm_spec)
-        # instrumental smoothing (accounting for library resolution)
-        smooth_spec = obs.instrumental_smoothing(self._outwave, smooth_spec,
+        # Instrumental smoothing (accounting for library resolution)
+        # put onto the spec.wavelength grid
+        smooth_spec = obs.instrumental_smoothing(obs_wave, smooth_spec,
                                                  libres=self._library_resolution)
 
         # --- add fixed lines if necessary ---
@@ -640,8 +641,8 @@ def velocity_smoothing(self, wave, spec):
         """Smooth the spectrum.  See :py:func:`prospect.utils.smoothing.smoothspec`
         for details.
         """
-        sigma = self.params.get("sigma_smooth", 100)
-        outspec = smoothspec(wave, spec, sigma, outwave=self._outwave,
+        sigma = self.params.get("sigma_smooth", 300)
+        outspec = smoothspec(wave, spec, sigma, outwave=wave,
                              smoothtype="vel", fft=True)
 
         return outspec
diff --git a/prospect/observation/__init__.py b/prospect/observation/__init__.py
new file mode 100644
index 00000000..cc72dfc9
--- /dev/null
+++ b/prospect/observation/__init__.py
@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+from .observation import Photometry, Spectrum, Lines, from_oldstyle
+
+__all__ = ["Photometry", "Spectrum", "Lines",
+           "from_oldstyle"]
diff --git a/prospect/data/observation.py b/prospect/observation/observation.py
similarity index 95%
rename from prospect/data/observation.py
rename to prospect/observation/observation.py
index 8d2c3bf5..1366c396 100644
--- a/prospect/data/observation.py
+++ b/prospect/observation/observation.py
@@ -280,31 +280,32 @@ def __init__(self,
         self.calibration = calibration
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
 
-    def instrumental_smoothing(self, obswave, influx, libres=0):
+    def instrumental_smoothing(self, obswave, influx, zred=0, libres=0):
         """Smooth a spectrum by the instrumental resolution, optionally
         accounting (in quadrature) the intrinsic library resolution.
 
         Parameters
         ----------
-        obswave : ndarray
-            Observed frame wavelengths, in units of AA
+        obswave : ndarray of shape (N_pix_model,)
+            Observed frame wavelengths, in units of AA for the model
 
-        influx : ndarray
+        influx : ndarray of shape (N_pix_model,)
             Flux array
 
-        libres : float or ndarray
+        libres : float or ndarray of shape (N_pix_model,)
             Library resolution in units of km/s (dispersion) to be subtracted from the smoothing kernel.
+            This should be in the observed frame and *on the same wavelength grid as obs.wavelength*
 
         Returns
         -------
-        outflux : ndarray
+        outflux : ndarray of shape (ndata,)
             If instrument resolution is not None, this is the smoothed flux on
             the observed ``wavelength`` grid.  If resolution is None, this just
             passes ``influx`` right back again.
         """
         if self.resolution is None:
             # no-op
-            return influx
+            return np.interp(self.wavelength, obswave, influx)
 
         if libres:
             kernel = np.sqrt(self.resolution**2 - libres**2)
diff --git a/prospect/data/obsutils.py b/prospect/observation/obsutils.py
similarity index 100%
rename from prospect/data/obsutils.py
rename to prospect/observation/obsutils.py
diff --git a/pyproject.toml b/pyproject.toml
index 56035247..26500144 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,7 +24,7 @@ test = ["pytest", "pytest-xdist"]
 
 [tool.setuptools]
 packages = ["prospect",
-            "prospect.models", "prospect.sources", "prospect.data",
+            "prospect.models", "prospect.sources", "prospect.observation",
             "prospect.likelihood", "prospect.fitting",
             "prospect.io", "prospect.plotting", "prospect.utils"]
 
diff --git a/tests/test_agn_eline.py b/tests/test_agn_eline.py
index 84f8afe7..8c173839 100644
--- a/tests/test_agn_eline.py
+++ b/tests/test_agn_eline.py
@@ -5,7 +5,7 @@
 import numpy as np
 
 from sedpy import observate
-from prospect.data.observation import Spectrum, Photometry
+from prospect.observation import Spectrum, Photometry
 from prospect.models.sedmodel import AGNSpecModel
 from prospect.models.templates import TemplateLibrary
 from prospect.sources import CSPSpecBasis
diff --git a/tests/test_eline.py b/tests/test_eline.py
index 64c409c1..293d7e70 100644
--- a/tests/test_eline.py
+++ b/tests/test_eline.py
@@ -7,7 +7,7 @@
 
 from sedpy import observate
 
-from prospect.data import Photometry, Spectrum, from_oldstyle
+from prospect.observation import Photometry, Spectrum, from_oldstyle
 from prospect.models.templates import TemplateLibrary
 from prospect.models.sedmodel import SpecModel
 from prospect.sources import CSPSpecBasis

From cf90515e94ac55a99229f5222ecbe120cce1c96d Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 11 Apr 2023 16:33:27 -0400
Subject: [PATCH 041/132] fix tests; put weight vector names in the kernels;
 add a NoiseModel1D class for uncorrelated kernels (like jitter).

---
 prospect/likelihood/kernels.py     |  5 ++-
 prospect/likelihood/noise_model.py | 62 +++++++++++++++++++-----------
 prospect/models/sedmodel.py        |  2 +-
 tests/test_predict.py              |  2 +-
 4 files changed, 45 insertions(+), 26 deletions(-)

diff --git a/prospect/likelihood/kernels.py b/prospect/likelihood/kernels.py
index 7e77e513..f4379c53 100644
--- a/prospect/likelihood/kernels.py
+++ b/prospect/likelihood/kernels.py
@@ -6,7 +6,7 @@
 
 class Kernel(object):
 
-    def __init__(self, parnames=[], name=''):
+    def __init__(self, parnames=[], weight_by=None, name=''):
         """
         :param parnames:
             A list of names of the kernel params, used to alias the intrinsic
@@ -19,6 +19,7 @@ def __init__(self, parnames=[], name=''):
         self.param_alias = dict(zip(self.kernel_params, parnames))
         self.params = {}
         self.name = name
+        self.weight_by = weight_by
 
     def __repr__(self):
         return '{}({})'.format(self.__class__, self.param_alias.items())
@@ -31,7 +32,7 @@ def update(self, **kwargs):
         for k in self.kernel_params:
             self.params[k] = kwargs[self.param_alias[k]]
 
-    def __call__(self, metric, weights=None, ndim=2, **extras):
+    def __call__(self, metric, weights=None, ndim=2):
         """Return a covariance matrix, given a metric.  Optionally, multiply
         the output kernel by a weight function to induce non-stationarity.
         """
diff --git a/prospect/likelihood/noise_model.py b/prospect/likelihood/noise_model.py
index 9fc49e77..f1585ce6 100644
--- a/prospect/likelihood/noise_model.py
+++ b/prospect/likelihood/noise_model.py
@@ -7,7 +7,7 @@
 except(ImportError):
     pass
 
-__all__ = ["NoiseModel", "NoiseModelCov", "NoiseModelKDE"]
+__all__ = ["NoiseModel", "NoiseModel1D", "NoiseModelCov", "NoiseModelKDE"]
 
 
 class NoiseModel:
@@ -19,7 +19,8 @@ class NoiseModel:
     f_outlier = 0
     n_sigma_outlier = 50
 
-    def __init__(self, frac_out_name="f_outlier", nsigma_out_name="nsigma_outlier"):
+    def __init__(self, frac_out_name="f_outlier",
+                 nsigma_out_name="nsigma_outlier"):
         self.frac_out_name = frac_out_name
         self.nsigma_out_name = nsigma_out_name
         self.kernels = []
@@ -83,7 +84,40 @@ def lnlikelihood(self, pred, data):
         return lnp.sum()
 
 
-class NoiseModelCov(NoiseModel):
+class NoiseModel1D(NoiseModel):
+    """This class allows for 1D (diagonal) kernels
+    """
+
+    # TODO: metric names should be the responsibility of kernels, not noise models
+    def __init__(self, frac_out_name="f_outlier",
+                 nsigma_out_name="nsigma_outlier",
+                 metric_name='',
+                 mask_name='mask',
+                 kernels=[]):
+        self.frac_out_name = frac_out_name
+        self.nsigma_out_name = nsigma_out_name
+        self.kernels = kernels
+        self.metric_name = metric_name
+        self.mask_name = mask_name
+
+    def construct_covariance(self, **vectors):
+        """Construct a covariance matrix from a metric, a list of kernel
+        objects, and a list of weight vectors (of same length as the metric)
+        """
+        metric = vectors[self.metric_name]
+        mask = vectors.get(self.mask_name, slice(None))
+
+        # 1 = uncorrelated errors, 2 = covariance matrix, >2 undefined
+        ndmax = 1
+        Sigma = np.zeros(metric[mask].shape[0])
+
+        for kernel in self.kernels:
+            wght = vectors.get(kernel.weight_by, None)
+            Sigma += kernel(metric[mask], weights=wght[mask], ndim=ndmax)
+        return Sigma
+
+
+class NoiseModelCov(NoiseModel1D):
     """This object allows for 1d or 2d covariance matrices constructed from
     kernels.
     """
@@ -110,27 +144,11 @@ def construct_covariance(self, **vectors):
         ndmax = np.array([k.ndim for k in self.kernels]).max()
         Sigma = np.zeros(ndmax * [metric[mask].shape[0]])
 
-        weight_vectors = self.get_weights(**vectors)
-        for i, (kernel, wght) in enumerate(zip(self.kernels, weight_vectors)):
-            Sigma += kernel(metric[mask], weights=wght, ndim=ndmax)
+        for kernel in self.kernels:
+            wght = vectors.get(kernel.weight_by, None)
+            Sigma += kernel(metric[mask], weights=wght[mask], ndim=ndmax)
         return Sigma
 
-    def get_weights(self, **vectors):
-        """From a dictionary of vectors that give weights, pull the vectors
-        that correspond to each kernel, as stored in the `weight_names`
-        attribute.  A None vector will result in None weights
-        """
-        mask = vectors.get(self.mask_name, slice(None))
-        wghts = []
-        for w in self.weight_names:
-            if w is None:
-                wghts += [None]
-            elif vectors[w] is None:
-                wghts += [None]
-            else:
-                wghts.append(vectors[w][mask])
-        return wghts
-
     def compute(self, check_finite=False, **vectors):
         """Build and cache the covariance matrix, and if it is 2-d factorize it
         and cache that.  Also cache ``log_det``.
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 4a077822..8890c0e3 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -187,7 +187,7 @@ def predict_spec(self, obs, **extras):
         # Physical smoothing of the whole spectrum
         smooth_spec = self.velocity_smoothing(obs_wave, self._norm_spec)
         # Instrumental smoothing (accounting for library resolution)
-        # put onto the spec.wavelength grid
+        # Put onto the spec.wavelength grid.
         smooth_spec = obs.instrumental_smoothing(obs_wave, smooth_spec,
                                                  libres=self._library_resolution)
 
diff --git a/tests/test_predict.py b/tests/test_predict.py
index 73ff5c16..9fd74853 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -9,7 +9,7 @@
 from sedpy.observate import load_filters
 from prospect.sources import CSPSpecBasis
 from prospect.models import SpecModel, templates
-from prospect.data import Spectrum, Photometry
+from prospect.observation import Spectrum, Photometry
 
 
 @pytest.fixture(scope="module")

From 3f96e55d8b85c613bd5c32e5f1d2152928044064 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 11 Apr 2023 22:17:32 -0400
Subject: [PATCH 042/132] Work on instrumental smoothing.

---
 prospect/models/sedmodel.py         | 25 +++++----
 prospect/observation/observation.py | 83 +++++++++++++++++++++++------
 tests/test_agn_eline.py             |  1 -
 tests/test_predict.py               |  2 +
 4 files changed, 85 insertions(+), 26 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 8890c0e3..022b4cd8 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -116,6 +116,9 @@ def predict(self, theta, observations=None, sps=None, **extras):
         self._ln_eline_penalty = 0
         self._eline_lum_var = np.zeros_like(self._eline_wave)
 
+        # physical velocity smoothing of the whole UV/NIR spectrum
+        self._smooth_spec = self.velocity_smoothing(self._wave, self._norm_spec)
+
         # generate predictions for likelihood
         # this assumes all spectral datasets (if present) occur first
         # because they can change the line strengths during marginalization.
@@ -184,12 +187,10 @@ def predict_spec(self, obs, **extras):
         self.cache_eline_parameters(obs)
 
         # --- smooth and put on output wavelength grid ---
-        # Physical smoothing of the whole spectrum
-        smooth_spec = self.velocity_smoothing(obs_wave, self._norm_spec)
         # Instrumental smoothing (accounting for library resolution)
         # Put onto the spec.wavelength grid.
-        smooth_spec = obs.instrumental_smoothing(obs_wave, smooth_spec,
-                                                 libres=self._library_resolution)
+        inst_spec = obs.instrumental_smoothing(obs_wave, self._smooth_spec,
+                                               libres=self._library_resolution)
 
         # --- add fixed lines if necessary ---
         emask = self._fix_eline_pixelmask
@@ -198,11 +199,11 @@ def predict_spec(self, obs, **extras):
             espec = self.predict_eline_spec(line_indices=inds,
                                             wave=self._outwave[emask])
             self._fix_eline_spec = espec
-            smooth_spec[emask] += self._fix_eline_spec.sum(axis=1)
+            inst_spec[emask] += self._fix_eline_spec.sum(axis=1)
 
         # --- calibration ---
-        self._speccal = self.spec_calibration(obs=obs, spec=smooth_spec, **extras)
-        calibrated_spec = smooth_spec * self._speccal
+        self._speccal = self.spec_calibration(obs=obs, spec=inst_spec, **extras)
+        calibrated_spec = inst_spec * self._speccal
 
         # --- fit and add lines if necessary ---
         emask = self._fit_eline_pixelmask
@@ -642,8 +643,12 @@ def velocity_smoothing(self, wave, spec):
         for details.
         """
         sigma = self.params.get("sigma_smooth", 300)
-        outspec = smoothspec(wave, spec, sigma, outwave=wave,
-                             smoothtype="vel", fft=True)
+        sel = (wave > 1.2e3) & (wave < 2.5e4)
+        # TODO: make a fast version of this that is also accurate
+        sm = smoothspec(wave, spec, sigma, outwave=wave[sel],
+                        smoothtype="vel", fftsmooth=True)
+        outspec = spec.copy()
+        outspec[sel] = sm
 
         return outspec
 
@@ -944,6 +949,8 @@ def predict_spec(self, obs, **extras):
 
         # --- smooth and put on output wavelength grid ---
         smooth_spec = self.velocity_smoothing(obs_wave, self._norm_spec)
+        smooth_spec = obs.instrumental_smoothing(obs_wave, smooth_spec,
+                                                 libres=self._library_resolution)
 
         # --- add fixed lines ---
         assert self.params["nebemlineinspec"] == False, "must add agn and nebular lines within prospector"
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 1366c396..26a4bc98 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -4,7 +4,7 @@
 import numpy as np
 
 from sedpy.observate import FilterSet
-from sedpy.smoothing import smoothspec
+from sedpy.smoothing import smoothspec, smooth_fft
 
 from ..likelihood.noise_model import NoiseModel
 
@@ -13,6 +13,8 @@
            "from_oldstyle", "from_serial", "obstypes"]
 
 
+CKMS = 2.998e5
+
 class NumpyEncoder(json.JSONEncoder):
 
     def default(self, obj):
@@ -126,6 +128,14 @@ def ndata(self):
         else:
             return len(self.wavelength)
 
+    @property
+    def wave_min(self):
+        return np.min(self.wavelength)
+
+    @property
+    def wave_max(self):
+        return np.max(self.wavelength)
+
     @property
     def metadata(self):
         meta = {m: getattr(self, m) for m in self._meta}
@@ -201,7 +211,7 @@ def __init__(self, filters=[], name="PhotA", **kwargs):
         super(Photometry, self).__init__(name=name, **kwargs)
 
     def set_filters(self, filters):
-        if len(filters) == 0:
+        if (len(filters) == 0) or (filters is None):
             self.filters = filters
             self.filternames = []
             self.filterset = None
@@ -279,8 +289,40 @@ def __init__(self,
         self.resolution = resolution
         self.calibration = calibration
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
-
-    def instrumental_smoothing(self, obswave, influx, zred=0, libres=0):
+        assert np.all(np.diff(self.wavelength) > 0)
+        self.pad_wavelength_array()
+
+    def pad_wavelength_array(self, lambda_pad=100):
+        #wave_min = self.wave_min * (1 - np.arange(npad, 0, -1) * Kdelta[0] / ckms)
+        low_pad = np.arange(lambda_pad, 1, (self.wavelength[0]-self.wavelength[1]))
+        hi_pad = np.arange(1, lambda_pad, (self.wavelength[-1]-self.wavelength[-2]))
+        wave_min = self.wave_min - low_pad
+        wave_max = self.wave_max + hi_pad
+        self.padded_wavelength = np.concatenate([wave_min, self.wavelength, wave_max])
+        self.padded_resolution = np.interp(self.padded_wavelength, self.wavelength, self.resolution)
+        self._unpadded_inds = slice(len(low_pad), -len(hi_pad))
+
+    def smooth_lsf_fft(self, inwave, influx, outwave, sigma):
+        dw = np.gradient(outwave)
+        sigma_per_pixel = (dw / sigma)
+        cdf = np.cumsum(sigma_per_pixel)
+        cdf /= cdf.max()
+        # check: do we need this?
+        x_per_pixel = np.gradient(cdf)
+        x_per_sigma = np.nanmedian(x_per_pixel / sigma_per_pixel)
+        pix_per_sigma = 1
+        N = pix_per_sigma / x_per_sigma
+        nx = int(2**np.ceil(np.log2(N)))
+        # now evenly sample in the x coordinate
+        x = np.linspace(0, 1, nx)
+        dx = 1.0 / nx
+        lam = np.interp(x, cdf, outwave)
+        newflux = np.interp(lam, inwave, influx)
+        flux_conv = smooth_fft(dx, newflux, x_per_sigma)
+        outflux = np.interp(outwave, lam, flux_conv)
+        return outflux
+
+    def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
         """Smooth a spectrum by the instrumental resolution, optionally
         accounting (in quadrature) the intrinsic library resolution.
 
@@ -303,18 +345,27 @@ def instrumental_smoothing(self, obswave, influx, zred=0, libres=0):
             the observed ``wavelength`` grid.  If resolution is None, this just
             passes ``influx`` right back again.
         """
-        if self.resolution is None:
-            # no-op
-            return np.interp(self.wavelength, obswave, influx)
-
-        if libres:
-            kernel = np.sqrt(self.resolution**2 - libres**2)
-        else:
-            kernel = self.resolution
-        out = smoothspec(obswave, influx, kernel,
-                         outwave=self.wavelength,
-                         **self.instrument_smoothing_parameters)
-        return out
+        # interpolate library resolution onto the instrumental wavelength grid
+        Klib = np.interp(self.padded_wavelength, wave_obs, libres)
+        # quadrature difference of instrumental and library reolution
+        Kdelta = np.sqrt(self.padded_resolution**2 - Klib**2)
+        Kdelta_lambda = Kdelta / CKMS * self.padded_wavelength
+
+        outspec_padded = self.smooth_lsf_fft(wave_obs,
+                                             influx,
+                                             self.padded_wavelength,
+                                             Kdelta_lambda)
+        if False:
+            warr = [wave_min]
+            while warr[-1] < wave_max:
+                w = warr[-1]
+                dv = np.interp(w, self.wavelength, Kdelta)
+                warr.append((1 + dv / ckms) * w)
+            warr = np.array(warr)
+            flux_resampled = np.interp(warr, wave_obs, influx)
+            np.convolve(flux_resampled, )
+
+        return outspec_padded[self._unpadded_inds]
 
     def to_oldstyle(self):
         obs = {}
diff --git a/tests/test_agn_eline.py b/tests/test_agn_eline.py
index 8c173839..1cd5a61e 100644
--- a/tests/test_agn_eline.py
+++ b/tests/test_agn_eline.py
@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from copy import deepcopy
 import numpy as np
 
 from sedpy import observate
diff --git a/tests/test_predict.py b/tests/test_predict.py
index 9fd74853..e2323cfd 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -58,7 +58,9 @@ def test_prediction_nodata(build_sps):
     sobs.uncertainty = None
     pred, mfrac = model.predict(model.theta, observations=[sobs, pobs], sps=sps)
     assert len(pred[0]) == len(sps.wavelengths)
+    assert np.any(np.isfinite(pred[0]))
     assert len(pred[1]) == len(pobs.filterset)
+    assert np.any(np.isfinite(pred[1]))
 
 
 def test_multispec(build_sps):

From daf4e034e1f5672dce552902fd04c6740916b6f6 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 7 Jul 2023 15:48:09 -0400
Subject: [PATCH 043/132] Add instrumental resolution to emission linewidths;
 Treat case of dummy observation that is not any of the recognized kinds; Bump
 python version requirement.

---
 prospect/models/sedmodel.py      | 9 ++++++++-
 prospect/observation/__init__.py | 2 +-
 prospect/sources/galaxy_basis.py | 4 ++++
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 022b4cd8..e36a20af 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -133,6 +133,8 @@ def predict_obs(self, obs):
             prediction = self.predict_lines(obs)
         elif obs.kind == "photometry":
             prediction = self.predict_phot(obs.filterset)
+        else:
+            prediction = None
         return prediction
 
     def predict_spec(self, obs, **extras):
@@ -438,12 +440,17 @@ def cache_eline_parameters(self, obs, nsigma=5, forcelines=False):
             self._fix_eline_pixelmask = np.array([], dtype=bool)
             return
 
-        # observed linewidths
+        # linewidths
         nline = self._ewave_obs.shape[0]
+        # physical linewidths
         self._eline_sigma_kms = np.atleast_1d(self.params.get('eline_sigma', 100.0))
         # what is this wierd construction for?
         self._eline_sigma_kms = (self._eline_sigma_kms[None] * np.ones(nline)).squeeze()
         #self._eline_sigma_lambda = eline_sigma_kms * self._ewave_obs / ckms
+        # instrumental linewidths
+        if obs.resolution is not None:
+            sigma_inst = np.interp(self._ewave_obs, obs.wavelength, obs.resolution)
+            self._eline_sigma_kms = np.hypot(self._eline_sigma_kms, sigma_inst)
 
         # --- get valid lines ---
         # fixed and fit lines specified by user, but remove any lines which do
diff --git a/prospect/observation/__init__.py b/prospect/observation/__init__.py
index cc72dfc9..c130e1ef 100644
--- a/prospect/observation/__init__.py
+++ b/prospect/observation/__init__.py
@@ -2,5 +2,5 @@
 
 from .observation import Photometry, Spectrum, Lines, from_oldstyle
 
-__all__ = ["Photometry", "Spectrum", "Lines",
+__all__ = ["Observation", "Photometry", "Spectrum", "Lines",
            "from_oldstyle"]
diff --git a/prospect/sources/galaxy_basis.py b/prospect/sources/galaxy_basis.py
index da616086..fb967446 100644
--- a/prospect/sources/galaxy_basis.py
+++ b/prospect/sources/galaxy_basis.py
@@ -161,6 +161,10 @@ def logage(self):
     def wavelengths(self):
         return self.ssp.wavelengths.copy()
 
+    @property
+    def spectral_resolution(self):
+        r = getattr(self.ssp, "resolutions", np.array(0))
+        return r
 
 class FastStepBasis(SSPBasis):
     """Subclass of :py:class:`SSPBasis` that implements a "nonparameteric"

From a252c46bd473c87f3a100602f2fa23adfb90f4c4 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 6 Aug 2023 03:12:37 -0400
Subject: [PATCH 044/132] handle spectrum padding when no resoltion or
 wavelength; actually test in lnlike_testing

---
 prospect/observation/observation.py | 25 +++++++++++++++++--------
 tests/test_predict.py               | 22 +++++++++++++++++-----
 2 files changed, 34 insertions(+), 13 deletions(-)

diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 26a4bc98..676ee4f8 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -293,14 +293,17 @@ def __init__(self,
         self.pad_wavelength_array()
 
     def pad_wavelength_array(self, lambda_pad=100):
+        if self.wavelength is None:
+            return
         #wave_min = self.wave_min * (1 - np.arange(npad, 0, -1) * Kdelta[0] / ckms)
         low_pad = np.arange(lambda_pad, 1, (self.wavelength[0]-self.wavelength[1]))
         hi_pad = np.arange(1, lambda_pad, (self.wavelength[-1]-self.wavelength[-2]))
         wave_min = self.wave_min - low_pad
         wave_max = self.wave_max + hi_pad
         self.padded_wavelength = np.concatenate([wave_min, self.wavelength, wave_max])
-        self.padded_resolution = np.interp(self.padded_wavelength, self.wavelength, self.resolution)
         self._unpadded_inds = slice(len(low_pad), -len(hi_pad))
+        if self.resolution is not None:
+            self.padded_resolution = np.interp(self.padded_wavelength, self.wavelength, self.resolution)
 
     def smooth_lsf_fft(self, inwave, influx, outwave, sigma):
         dw = np.gradient(outwave)
@@ -328,23 +331,29 @@ def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
 
         Parameters
         ----------
-        obswave : ndarray of shape (N_pix_model,)
-            Observed frame wavelengths, in units of AA for the model
+        wave_obs : ndarray of shape (N_pix_model,)
+            Observed frame wavelengths, in units of AA for the *model*
 
         influx : ndarray of shape (N_pix_model,)
-            Flux array
+            Flux array corresponding to the observed frame wavelengths
 
         libres : float or ndarray of shape (N_pix_model,)
-            Library resolution in units of km/s (dispersion) to be subtracted from the smoothing kernel.
-            This should be in the observed frame and *on the same wavelength grid as obs.wavelength*
+            Library resolution in units of km/s (dispersion) to be subtracted
+            from the smoothing kernel. This should be in the observed frame and
+            on the same wavelength grid as obswave
 
         Returns
         -------
         outflux : ndarray of shape (ndata,)
             If instrument resolution is not None, this is the smoothed flux on
-            the observed ``wavelength`` grid.  If resolution is None, this just
-            passes ``influx`` right back again.
+            the observed ``wavelength`` grid.  If wavelength is None, this just
+            passes ``influx`` right back again.  If ``resolution`` is None then
+            ``influx`` is simply interpolated onto the wavelength grid
         """
+        if self.wavelength is None:
+            return influx
+        if self.resolution is None:
+            return np.interp(self.wavelength, wave_obs, influx)
         # interpolate library resolution onto the instrumental wavelength grid
         Klib = np.interp(self.padded_wavelength, wave_obs, libres)
         # quadrature difference of instrumental and library reolution
diff --git a/tests/test_predict.py b/tests/test_predict.py
index e2323cfd..b0a5eae1 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -97,9 +97,21 @@ def lnlike_testing(build_sps):
 
     from prospect.likelihood.likelihood import compute_lnlike
     from prospect.fitting import lnprobfn
-    lnp = lnprobfn(model.theta, model=model, observations=obslist, sps=sps)
 
-    #%timeit model.prior_product(model.theta)
-    #%timeit predictions, x = model.predict(model.theta + np.random.uniform(0, 3) * arr, observations=obslist, sps=sps)
-    #%timeit lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs in zip(predictions, observations)]
-    #%timeit lnp = lnprobfn(model.theta + np.random.uniform(0, 3) * arr, model=model, observations=obslist, sps=sps)
+    predictions, x = model.predict(model.theta, observations, sps=sps)
+    lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs
+                in zip(predictions, observations)]
+    assert np.all([np.isscalar(p) for p in lnp_data])
+    assert len(lnp_data) == len(observations)
+
+    lnp = lnprobfn(model.theta, model=model, observations=observations, sps=sps)
+
+    assert np.isscalar(lnp)
+
+    # %timeit model.prior_product(model.theta)
+    # arr = np.zeros(model.ndim)
+    # arr[-1] = 1
+    # theta = model.theta.copy()
+    # %timeit predictions, x = model.predict(theta + np.random.uniform(-0.1, 0.1) * arr, observations=observations, sps=sps)
+    # %timeit lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs in zip(predictions, observations)]
+    # %timeit lnp = lnprobfn(theta + np.random.uniform(0, 3) * arr, model=model, observations=observations, sps=sps)

From 31ad26cdd5218ae029bbd547d46825a12d9aa961 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 6 Aug 2023 13:52:19 -0400
Subject: [PATCH 045/132] return scalar from NoiseModel.lnlike when using
 outlier model.

---
 prospect/likelihood/noise_model.py  | 2 +-
 prospect/observation/observation.py | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/prospect/likelihood/noise_model.py b/prospect/likelihood/noise_model.py
index f1585ce6..db0cd480 100644
--- a/prospect/likelihood/noise_model.py
+++ b/prospect/likelihood/noise_model.py
@@ -51,7 +51,7 @@ def lnlike(self, pred, obs, vectors={}):
             var_bad = var * (self.n_sigma_outlier**2)
             lnp_bad = -0.5*((delta**2 / var_bad) + np.log(2*np.pi*var_bad))
             lnp_tot = np.logaddexp(lnp + np.log(1 - self.f_outlier), lnp_bad + np.log(self.f_outlier))
-            return lnp_tot
+            return np.sum(lnp_tot)
         else:
             raise ValueError("f_outlier must be >= 0")
 
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 676ee4f8..8089eb06 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -293,6 +293,9 @@ def __init__(self,
         self.pad_wavelength_array()
 
     def pad_wavelength_array(self, lambda_pad=100):
+        """Pad the wavelength and, if present, resolution arrays so that FFTs
+        can be used on the models without edge effects.
+        """
         if self.wavelength is None:
             return
         #wave_min = self.wave_min * (1 - np.arange(npad, 0, -1) * Kdelta[0] / ckms)
@@ -356,10 +359,10 @@ def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
             return np.interp(self.wavelength, wave_obs, influx)
         # interpolate library resolution onto the instrumental wavelength grid
         Klib = np.interp(self.padded_wavelength, wave_obs, libres)
-        # quadrature difference of instrumental and library reolution
+        # quadrature difference of instrumental and library resolution
+        assert np.all(self.padded_resolution >= Klib), "data higher resolution than library"
         Kdelta = np.sqrt(self.padded_resolution**2 - Klib**2)
         Kdelta_lambda = Kdelta / CKMS * self.padded_wavelength
-
         outspec_padded = self.smooth_lsf_fft(wave_obs,
                                              influx,
                                              self.padded_wavelength,

From e4c5436079db77e93e3ccbfae230165e8a9d6718 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 6 Aug 2023 14:52:37 -0400
Subject: [PATCH 046/132] add some noise model parameter docs.

---
 prospect/likelihood/noise_model.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/prospect/likelihood/noise_model.py b/prospect/likelihood/noise_model.py
index db0cd480..1fe0a044 100644
--- a/prospect/likelihood/noise_model.py
+++ b/prospect/likelihood/noise_model.py
@@ -25,6 +25,11 @@ def __init__(self, frac_out_name="f_outlier",
         self.nsigma_out_name = nsigma_out_name
         self.kernels = []
 
+    def _available_parameters(self):
+        new_pars = [(self.frac_out_name, "Fraction of data points that are outliers"),
+                    (self.nsigma_out_name, "Dispersion of the outlier distribution, in units of chi")]
+        return new_pars
+
     def update(self, **params):
         self.f_outlier = params.get(self.frac_out_name, 0)
         self.n_sigma_outlier = params.get(self.nsigma_out_name, 50)
@@ -100,6 +105,13 @@ def __init__(self, frac_out_name="f_outlier",
         self.metric_name = metric_name
         self.mask_name = mask_name
 
+    def _available_parameters(self):
+        new_pars = [(self.frac_out_name, "Fraction of data points that are outliers"),
+                    (self.nsigma_out_name, "Dispersion of the outlier distribution, in units of chi")]
+        for kernel in self.kernels:
+            new_pars += getattr(kernel, "_available_parameters", [])
+        return new_pars
+
     def construct_covariance(self, **vectors):
         """Construct a covariance matrix from a metric, a list of kernel
         objects, and a list of weight vectors (of same length as the metric)

From 10232a4606b4c07bf9ddc4f3ed1b3956472e38c5 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 26 Aug 2023 16:30:55 -0400
Subject: [PATCH 047/132] fix Observation class attributes for H5 storage.

---
 prospect/__init__.py                |   1 +
 prospect/io/read_results.py         |   4 +-
 prospect/models/sedmodel.py         |   2 +-
 prospect/observation/__init__.py    |   5 +-
 prospect/observation/observation.py | 116 +++++++++++++++-------------
 5 files changed, 71 insertions(+), 57 deletions(-)

diff --git a/prospect/__init__.py b/prospect/__init__.py
index f1213763..338b909b 100644
--- a/prospect/__init__.py
+++ b/prospect/__init__.py
@@ -4,6 +4,7 @@
     pass
 
 from . import models
+from . import observation
 from . import fitting
 from . import io
 from . import sources
diff --git a/prospect/io/read_results.py b/prospect/io/read_results.py
index 40d9d789..cff75423 100644
--- a/prospect/io/read_results.py
+++ b/prospect/io/read_results.py
@@ -183,17 +183,17 @@ def read_hdf5(filename, **extras):
         res.update(groups['sampling'])
         res["bestfit"] = groups["bestfit"]
         res["optimization"] = groups["optimization"]
+        # do observations
         if 'observations' in hf:
             obs = obs_from_h5(hf['observations'])
         else:
             obs = None
-        #res['obs'] = obs
 
     return res, obs
 
 
 def obs_from_h5(obsgroup):
-    from ..data.observation import from_serial
+    from ..observation import from_serial
     observations = []
     for obsname, dset in obsgroup.items():
         arr, meta = dset[:], dict(dset.attrs)
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index e36a20af..4e1625f6 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -578,7 +578,7 @@ def fit_mle_elines(self, obs, calibrated_spec, sigma_spec=None):
 
         # Cache the ln-penalty
         # FIXME this needs to be acumulated if there are multiple spectra
-        self._ln_eline_penalty = K
+        self._ln_eline_penalty += K
 
         # Store fitted emission line luminosities in physical units
         self._eline_lum[idx] = alpha_bar / linecal
diff --git a/prospect/observation/__init__.py b/prospect/observation/__init__.py
index c130e1ef..ebf9c627 100644
--- a/prospect/observation/__init__.py
+++ b/prospect/observation/__init__.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
-from .observation import Photometry, Spectrum, Lines, from_oldstyle
+from .observation import Photometry, Spectrum, Lines
+from .observation import from_oldstyle, from_serial
 
 __all__ = ["Observation", "Photometry", "Spectrum", "Lines",
-           "from_oldstyle"]
+           "from_oldstyle", "from_serial"]
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 8089eb06..8cce6727 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -39,8 +39,8 @@ class Observation:
 
     logify_spectrum = False
     alias = {}
-    _meta = ["kind", "name"]
-    _data = ["wavelength", "flux", "uncertainty", "mask"]
+    _meta = ("kind", "name")
+    _data = ("wavelength", "flux", "uncertainty", "mask")
 
     def __init__(self,
                  flux=None,
@@ -147,14 +147,23 @@ def to_struct(self, data_dtype=np.float32):
         """Convert data to a structured array
         """
         self._automask()
-        dtype = np.dtype([(c, data_dtype) for c in self._data])
-        struct = np.zeros(self.ndata, dtype=dtype)
+        cols = []
         for c in self._data:
+            dat = getattr(self, c)
+            if (dat is None):
+                continue
+            if (len(dat) != self.ndata):
+                continue
+                #raise ValueError(f"The {c} attribute of the {self.name} observation has the wrong length ({len(dat)} instead of {self.ndata})")
+            cols += [(c, dat.dtype)]
+        dtype = np.dtype(cols)
+        struct = np.zeros(self.ndata, dtype=dtype)
+        for c in dtype.names:
             data = getattr(self, c)
-            try:
+            if c is not None:
                 struct[c] = data
-            except(ValueError):
-                pass
+            #except(ValueError):
+            #    pass
         return struct
 
     def to_fits(self, filename=""):
@@ -176,8 +185,16 @@ def to_json(self):
         serial = json.dumps(obs, cls=NumpyEncoder)
         return serial
 
+    def to_oldstyle(self):
+        obs = {}
+        obs.update(vars(self))
+        for k, v in self.alias.items():
+            obs[k] = self[v]
+            _ = obs.pop(v)
+        return obs
+
     @property
-    def to_nJy(self):
+    def maggies_to_nJy(self):
         return 1e9 * 3631
 
 
@@ -188,7 +205,7 @@ class Photometry(Observation):
                  maggies_unc="uncertainty",
                  filters="filters",
                  phot_mask="mask")
-    _meta = ["kind", "name", "filternames"]
+    _meta =  ("kind", "name", "filternames")
 
     def __init__(self, filters=[], name="PhotA", **kwargs):
         """On Observation object that holds photometric data
@@ -211,6 +228,8 @@ def __init__(self, filters=[], name="PhotA", **kwargs):
         super(Photometry, self).__init__(name=name, **kwargs)
 
     def set_filters(self, filters):
+
+        # TODO: Make this less convoluted
         if (len(filters) == 0) or (filters is None):
             self.filters = filters
             self.filternames = []
@@ -235,13 +254,7 @@ def wavelength(self):
         return np.array([f.wave_effective for f in self.filters])
 
     def to_oldstyle(self):
-        obs = {}
-        obs.update(vars(self))
-        for k, v in self.alias.items():
-            obs[k] = self[v]
-            _ = obs.pop(v)
-        #obs.update({k: self[v] for k, v in self.alias.items()})
-        #_ = [obs.pop(k) for k in ["flux", "uncertainty", "mask"]]
+        obs = super(Photometry, self).to_oldstyle()
         obs["phot_wave"] = self.wavelength
         return obs
 
@@ -254,14 +267,16 @@ class Spectrum(Observation):
                  wavelength="wavelength",
                  mask="mask")
 
-    data = ["wavelength", "flux", "uncertainty", "mask",
-            "resolution", "calibration"]
+    _meta = ("kind", "name", "lambda_pad")
+    _data = ("wavelength", "flux", "uncertainty", "mask",
+             "resolution", "calibration")
 
     def __init__(self,
                  wavelength=None,
                  resolution=None,
                  calibration=None,
                  name="SpecA",
+                 lambda_pad=100,
                  **kwargs):
 
         """
@@ -290,17 +305,18 @@ def __init__(self,
         self.calibration = calibration
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
         assert np.all(np.diff(self.wavelength) > 0)
+        self.lambda_pad = lambda_pad
         self.pad_wavelength_array()
 
-    def pad_wavelength_array(self, lambda_pad=100):
+    def pad_wavelength_array(self):
         """Pad the wavelength and, if present, resolution arrays so that FFTs
         can be used on the models without edge effects.
         """
         if self.wavelength is None:
             return
-        #wave_min = self.wave_min * (1 - np.arange(npad, 0, -1) * Kdelta[0] / ckms)
-        low_pad = np.arange(lambda_pad, 1, (self.wavelength[0]-self.wavelength[1]))
-        hi_pad = np.arange(1, lambda_pad, (self.wavelength[-1]-self.wavelength[-2]))
+
+        low_pad = np.arange(self.lambda_pad, 1, (self.wavelength[0]-self.wavelength[1]))
+        hi_pad = np.arange(1, self.lambda_pad, (self.wavelength[-1]-self.wavelength[-2]))
         wave_min = self.wave_min - low_pad
         wave_max = self.wave_max + hi_pad
         self.padded_wavelength = np.concatenate([wave_min, self.wavelength, wave_max])
@@ -308,7 +324,7 @@ def pad_wavelength_array(self, lambda_pad=100):
         if self.resolution is not None:
             self.padded_resolution = np.interp(self.padded_wavelength, self.wavelength, self.resolution)
 
-    def smooth_lsf_fft(self, inwave, influx, outwave, sigma):
+    def _smooth_lsf_fft(self, inwave, influx, outwave, sigma):
         dw = np.gradient(outwave)
         sigma_per_pixel = (dw / sigma)
         cdf = np.cumsum(sigma_per_pixel)
@@ -357,35 +373,22 @@ def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
             return influx
         if self.resolution is None:
             return np.interp(self.wavelength, wave_obs, influx)
+
         # interpolate library resolution onto the instrumental wavelength grid
         Klib = np.interp(self.padded_wavelength, wave_obs, libres)
-        # quadrature difference of instrumental and library resolution
         assert np.all(self.padded_resolution >= Klib), "data higher resolution than library"
+
+        # quadrature difference of instrumental and library resolution
         Kdelta = np.sqrt(self.padded_resolution**2 - Klib**2)
         Kdelta_lambda = Kdelta / CKMS * self.padded_wavelength
-        outspec_padded = self.smooth_lsf_fft(wave_obs,
-                                             influx,
-                                             self.padded_wavelength,
-                                             Kdelta_lambda)
-        if False:
-            warr = [wave_min]
-            while warr[-1] < wave_max:
-                w = warr[-1]
-                dv = np.interp(w, self.wavelength, Kdelta)
-                warr.append((1 + dv / ckms) * w)
-            warr = np.array(warr)
-            flux_resampled = np.interp(warr, wave_obs, influx)
-            np.convolve(flux_resampled, )
 
-        return outspec_padded[self._unpadded_inds]
+        # Smooth by the difference kernel
+        outspec_padded = self._smooth_lsf_fft(wave_obs,
+                                              influx,
+                                              self.padded_wavelength,
+                                              Kdelta_lambda)
 
-    def to_oldstyle(self):
-        obs = {}
-        obs.update(vars(self))
-        for k, v in self.alias.items():
-            obs[k] = self[v]
-            _ = obs.pop(v)
-        return obs
+        return outspec_padded[self._unpadded_inds]
 
 
 class Lines(Spectrum):
@@ -397,8 +400,9 @@ class Lines(Spectrum):
                  mask="mask",
                  line_inds="line_ind")
 
-    data = ["wavelength", "flux", "uncertainty", "mask",
-            "resolution", "calibration", "line_ind"]
+    _meta = ("name", "kind")
+    _data = ("wavelength", "flux", "uncertainty", "mask",
+             "resolution", "calibration", "line_ind")
 
     def __init__(self,
                  line_ind=None,
@@ -428,7 +432,7 @@ def __init__(self,
         :param calibration:
             not sure yet ....
         """
-        super(Lines, self).__init__(name=name, **kwargs)
+        super(Lines, self).__init__(name=name, resolution=None, **kwargs)
         assert (line_ind is not None), "You must identify the lines by their index in the FSPS emission line array"
         self.line_ind = np.array(line_ind).as_type(int)
 
@@ -449,11 +453,19 @@ def from_oldstyle(obs, **kwargs):
 
 
 def from_serial(arr, meta):
+    kind = obstypes[meta.pop("kind")]
+
     adict = {a:arr[a] for a in arr.dtype.names}
-    adict["name"] = meta.get("name", "")
+    adict["name"] = meta.pop("name", "")
     if 'filters' in meta:
-        adict["filters"] = meta["filters"].split(",")
-    obs = obstypes[meta["kind"]](**adict)
-    #[setattr(obs, m, v) for m, v in meta.items()]
+        adict["filters"] = meta.pop("filters").split(",")
+
+    obs = kind(**adict)
+
+    # set other metadata as attributes? No, needs to be during instantiation
+    #for k, v in meta.items():
+    #    if k in kind._meta:
+    #        setattr(obs, k, v)
+
     return obs
 

From 2a7c5fd4c2253cb9560c374bfd09c2b4c0b9671f Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 18 Sep 2023 07:40:37 -0400
Subject: [PATCH 048/132] default Observation names now include a the hex id to
 distinguish instances.

---
 prospect/observation/observation.py | 31 ++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 8cce6727..358e180c 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -4,7 +4,7 @@
 import numpy as np
 
 from sedpy.observate import FilterSet
-from sedpy.smoothing import smoothspec, smooth_fft
+from sedpy.smoothing import smooth_fft
 
 from ..likelihood.noise_model import NoiseModel
 
@@ -15,6 +15,7 @@
 
 CKMS = 2.998e5
 
+
 class NumpyEncoder(json.JSONEncoder):
 
     def default(self, obj):
@@ -37,6 +38,7 @@ class Observation:
     noise :
     """
 
+    kind = "observation"
     logify_spectrum = False
     alias = {}
     _meta = ("kind", "name")
@@ -47,7 +49,7 @@ def __init__(self,
                  uncertainty=None,
                  mask=slice(None),
                  noise=NoiseModel(),
-                 name="ObsA",
+                 name=None,
                  **kwargs
                  ):
 
@@ -55,8 +57,15 @@ def __init__(self,
         self.uncertainty = np.array(uncertainty)
         self.mask = mask
         self.noise = noise
-        self.name = name
         self.from_oldstyle(**kwargs)
+        if name is None:
+            addr = f"{id(self):04x}"
+            self.name = f"{self.kind[:5]}-{addr[:6]}"
+        else:
+            self.name = name
+
+    def __str__(self):
+        return f"{self.kind} ({self.name})"
 
     def __getitem__(self, item):
         """Dict-like interface for backwards compatibility
@@ -207,7 +216,9 @@ class Photometry(Observation):
                  phot_mask="mask")
     _meta =  ("kind", "name", "filternames")
 
-    def __init__(self, filters=[], name="PhotA", **kwargs):
+    def __init__(self, filters=[],
+                 name=None,
+                 **kwargs):
         """On Observation object that holds photometric data
 
         Parameters
@@ -275,7 +286,7 @@ def __init__(self,
                  wavelength=None,
                  resolution=None,
                  calibration=None,
-                 name="SpecA",
+                 name=None,
                  lambda_pad=100,
                  **kwargs):
 
@@ -304,8 +315,14 @@ def __init__(self,
         self.resolution = resolution
         self.calibration = calibration
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
-        assert np.all(np.diff(self.wavelength) > 0)
         self.lambda_pad = lambda_pad
+        if self.wavelength is not None:
+            self.set_wavelength(self.wavelength)
+
+    # TODO make this a proper settr/gettr for wavelenth attribute
+    def set_wavelength(self, wavelength):
+        self.wavelength = wavelength
+        assert np.all(np.diff(self.wavelength) > 0)
         self.pad_wavelength_array()
 
     def pad_wavelength_array(self):
@@ -406,7 +423,7 @@ class Lines(Spectrum):
 
     def __init__(self,
                  line_ind=None,
-                 name="SpecA",
+                 name=None,
                  **kwargs):
 
         """

From ede002ad20a8789fcce99eb9471f00a637614023 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 18 Sep 2023 08:11:38 -0400
Subject: [PATCH 049/132] begin work on undersampledSpectrum.

---
 prospect/observation/observation.py | 50 +++++++++++++++++++++++------
 1 file changed, 41 insertions(+), 9 deletions(-)

diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 358e180c..37831d8e 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -5,6 +5,7 @@
 
 from sedpy.observate import FilterSet
 from sedpy.smoothing import smooth_fft
+from sedpy.observate import rebin
 
 from ..likelihood.noise_model import NoiseModel
 
@@ -311,19 +312,22 @@ def __init__(self,
             not sure yet ....
         """
         super(Spectrum, self).__init__(name=name, **kwargs)
-        self.wavelength = wavelength
+        self.lambda_pad = lambda_pad
         self.resolution = resolution
         self.calibration = calibration
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
-        self.lambda_pad = lambda_pad
-        if self.wavelength is not None:
-            self.set_wavelength(self.wavelength)
-
-    # TODO make this a proper settr/gettr for wavelenth attribute
-    def set_wavelength(self, wavelength):
         self.wavelength = wavelength
-        assert np.all(np.diff(self.wavelength) > 0)
-        self.pad_wavelength_array()
+
+    @property
+    def wavelength(self):
+        return self._wavelength
+
+    @wavelength.setter
+    def wavelength(self, wave):
+        self._wavelength = wave
+        if self._wavelength is not None:
+            assert np.all(np.diff(self._wavelength) > 0)
+            self.pad_wavelength_array()
 
     def pad_wavelength_array(self):
         """Pad the wavelength and, if present, resolution arrays so that FFTs
@@ -408,6 +412,34 @@ def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
         return outspec_padded[self._unpadded_inds]
 
 
+class UndersampledSpectrum(Spectrum):
+
+    def _smooth_lsf_fft(self, inwave, influx, outwave, sigma):
+        raise NotImplementedError
+        # TODO does this need to be changed if outwave is undersampled?
+        # TODO testing
+        dw = np.gradient(outwave)
+        sigma_per_pixel = (dw / sigma)
+        cdf = np.cumsum(sigma_per_pixel)
+        cdf /= cdf.max()
+        # check: do we need this?
+        x_per_pixel = np.gradient(cdf)
+        x_per_sigma = np.nanmedian(x_per_pixel / sigma_per_pixel)
+        pix_per_sigma = 1
+        N = pix_per_sigma / x_per_sigma
+        nx = int(2**np.ceil(np.log2(N)))
+        # now evenly sample in the x coordinate
+        x = np.linspace(0, 1, nx)
+        dx = 1.0 / nx
+        # convert x to wave
+        lam = np.interp(x, cdf, outwave)
+        newflux = np.interp(lam, inwave, influx)
+        flux_conv = smooth_fft(dx, newflux, x_per_sigma)
+        # TODO - does this do the right thing regarding edge/center of pixels?
+        outflux = rebin(outwave, lam, flux_conv)
+        return outflux
+
+
 class Lines(Spectrum):
 
     kind = "lines"

From c15ccc2f47fd76e34228d58767d9846e752e47aa Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 3 Jan 2024 13:59:28 -0500
Subject: [PATCH 050/132] fix bug in eline pixelmask generation.

---
 prospect/models/sedmodel.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 4e1625f6..76219e90 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -458,7 +458,7 @@ def cache_eline_parameters(self, obs, nsigma=5, forcelines=False):
         # This part has to go in every call
         linewidth = nsigma * self._ewave_obs / ckms * self._eline_sigma_kms
         pixel_mask = (np.abs(self._outwave - self._ewave_obs[:, None]) < linewidth[:, None])
-        pixel_mask = pixel_mask & obs.get("mask")[None, :]
+        pixel_mask = pixel_mask & obs.get("mask", np.ones_like(self._outwave))[None, :]
         self._valid_eline = pixel_mask.any(axis=1) & self._use_eline
 
         # --- wavelengths corresponding to valid lines ---

From b55325ddb59502c4019ce1b42ee759243c2a4f9a Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 4 Jan 2024 10:08:12 -0500
Subject: [PATCH 051/132] rectify obs before prediction in agn test.

---
 tests/test_agn_eline.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/test_agn_eline.py b/tests/test_agn_eline.py
index 1cd5a61e..a1090bc1 100644
--- a/tests/test_agn_eline.py
+++ b/tests/test_agn_eline.py
@@ -25,6 +25,7 @@ def test_agn_elines():
                     flux=np.ones(1000),
                     uncertainty=np.ones(1000)*0.1)
     obs = [spec, phot]
+    [ob.rectify() for ob in obs]
 
     # --- model ---
     model_pars = TemplateLibrary["parametric_sfh"]

From 933b0b7bc2b20b595e7b030fb95ba8ec6e826b5e Mon Sep 17 00:00:00 2001
From: Noah Franz <nfranz@arizona.edu>
Date: Sun, 7 Jan 2024 13:19:37 -0700
Subject: [PATCH 052/132] update API to work with emcee global variables

---
 prospect/fitting/fitting.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index dfc19a7e..85f8c7b3 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -441,12 +441,13 @@ def run_emcee(obs, model, sps, noise, lnprobfn=lnprobfn,
     """
     q = model.theta.copy()
 
-    postkwargs = {"obs": obs,
-                  "model": model,
-                  "sps": sps,
-                  "noise": noise,
-                  "nested": False,
-                  }
+    postkwargs = {}
+    for item in ['obs', 'model', 'sps', 'noise']:
+        val = eval(item)
+        if val is not None:
+            postkwargs[item] = val
+    
+    postkwargs['nested'] = False
 
     # Could try to make signatures for these two methods the same....
     if initial_positions is not None:

From 1154ca74fb41208f7466e592c8681cd8c65a3187 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 8 Jan 2024 13:21:55 -0500
Subject: [PATCH 053/132] fix tests; start on multispec tests.

---
 tests/test_eline.py     |  34 ++++++--------
 tests/test_lnlike.py    |  90 +++++++++++++++++++++++++++++++++++
 tests/test_multispec.py | 102 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 207 insertions(+), 19 deletions(-)
 create mode 100644 tests/test_lnlike.py
 create mode 100644 tests/test_multispec.py

diff --git a/tests/test_eline.py b/tests/test_eline.py
index 293d7e70..7330c425 100644
--- a/tests/test_eline.py
+++ b/tests/test_eline.py
@@ -59,16 +59,23 @@ def test_eline_parsing():
     assert model._fit_eline.sum() == (len(model._use_eline) - len(fix_lines))
 
 
-def test_nebline_phot_addition(get_sps):
-    fnames = [f"sdss_{b}0" for b in "ugriz"]
-    filts = observate.load_filters(fnames)
-
+def build_obs(filts):
     obs = dict(filters=filts,
                wavelength=np.linspace(3000, 9000, 1000),
                spectrum=np.ones(1000),
-               unc=np.ones(1000)*0.1)
+               unc=np.ones(1000)*0.1,
+               maggies=np.ones(len(filts))*1e-7,
+               maggies_unc=np.ones(len(filts))*1e-8)
     sdat, pdat = from_oldstyle(obs)
     obslist = [sdat, pdat]
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+def test_nebline_phot_addition(get_sps):
+    fnames = [f"sdss_{b}0" for b in "ugriz"]
+    filts = observate.load_filters(fnames)
+    obslist = build_obs(filts)
 
     sps = get_sps
 
@@ -104,13 +111,8 @@ def test_filtersets(get_sps):
     """
     fnames = [f"sdss_{b}0" for b in "ugriz"]
     flist = observate.load_filters(fnames)
-
-    obs = dict(wavelength=np.linspace(3000, 9000, 1000),
-               spectrum=np.ones(1000),
-               unc=np.ones(1000)*0.1,
-               filters=fnames)
-    sdat, pdat = from_oldstyle(obs)
-    obslist = [sdat, pdat]
+    obslist = build_obs(flist)
+    sdat, pdat = obslist
 
     sps = get_sps
 
@@ -149,13 +151,7 @@ def test_eline_implementation(get_sps):
     test_eline_parsing()
 
     filters = observate.load_filters([f"sdss_{b}0" for b in "ugriz"])
-    obs = dict(filters=filters,
-               wavelength=np.linspace(3000, 9000, 1000),
-               spectrum=np.ones(1000),
-               unc=np.ones(1000)*0.1,
-               maggies=np.ones(len(filters))*1e-7,
-               maggies_unc=np.ones(len(filters))*1e-8)
-    obslist = from_oldstyle(obs)
+    obslist = build_obs(filters)
 
     model_pars = TemplateLibrary["parametric_sfh"]
     model_pars.update(TemplateLibrary["nebular"])
diff --git a/tests/test_lnlike.py b/tests/test_lnlike.py
new file mode 100644
index 00000000..a1f4209c
--- /dev/null
+++ b/tests/test_lnlike.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+import numpy as np
+
+import pytest
+
+from prospect.sources import CSPSpecBasis
+from prospect.models import SpecModel, templates
+from prospect.observation import Spectrum, Photometry
+from prospect.likelihood import NoiseModel
+from prospect.likelihood.likelihood import compute_lnlike
+from prospect.fitting import lnprobfn
+
+
+@pytest.fixture
+def get_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+def build_model(add_neb=False, add_outlier=False):
+    model_params = templates.TemplateLibrary["parametric_sfh"]
+    if add_neb:
+        model_params.update(templates.TemplateLibrary["nebular"])
+    if add_outlier:
+        model_params.update(templates.TemplateLibrary["outlier_model"])
+        model_params["f_outlier_phot"]["isfree"] = True
+        model_params["f_outlier_phot"]["init"] = 0.05
+    return SpecModel(model_params)
+
+
+def build_obs(multispec=True, add_outlier=True):
+    N = 1500 * (2 - multispec)
+    wmax = 7000
+    wsplit = wmax - N * multispec
+
+    fnames = list([f"sdss_{b}0" for b in "ugriz"])
+    Nf = len(fnames)
+    phot = [Photometry(filters=fnames, flux=np.ones(Nf), uncertainty=np.ones(Nf)/10)]
+    spec = [Spectrum(wavelength=np.linspace(4000, wsplit, N),
+                     flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                     mask=slice(None))]
+
+    if add_outlier:
+        phot[0].noise = NoiseModel(frac_out_name='f_outlier_phot',
+                                   nsigma_out_name='nsigma_outlier_phot')
+
+    if multispec:
+        spec += [Spectrum(wavelength=np.linspace(wsplit+1, wmax, N),
+                          flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                          mask=slice(None))]
+
+    obslist = spec + phot
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+def test_lnlike_shape(get_sps):
+    # testing lnprobfn
+    sps = get_sps
+
+    for add_out in [True, False]:
+        observations = build_obs(add_outlier=add_out)
+        model = build_model(add_neb=add_out, add_outlier=add_out)
+
+        model.set_parameters(model.theta)
+        [obs.noise.update(**model.params) for obs in observations
+        if obs.noise is not None]
+        predictions, x = model.predict(model.theta, observations, sps=sps)
+
+        # check you get a scalar lnp for each observation
+        lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs
+                    in zip(predictions, observations)]
+        assert np.all([np.isscalar(p) for p in lnp_data]), f"failed for add_outlier={add_out}"
+        assert len(lnp_data) == len(observations), f"failed for add_outlier={add_out}"
+
+        # check lnprobfn returns scalar
+        lnp = lnprobfn(model.theta, model=model, observations=observations, sps=sps)
+
+        assert np.isscalar(lnp), f"failed for add_outlier={add_out}"
+
+    # %timeit model.prior_product(model.theta)
+    # arr = np.zeros(model.ndim)
+    # arr[-1] = 1
+    # theta = model.theta.copy()
+    # %timeit predictions, x = model.predict(theta + np.random.uniform(-0.1, 0.1) * arr, observations=observations, sps=sps)
+    # %timeit lnp_data = [compute_lnlike(pred, obs, vectors={}) for pred, obs in zip(predictions, observations)]
+    # %timeit lnp = lnprobfn(theta + np.random.uniform(0, 3) * arr, model=model, observations=observations, sps=sps)
diff --git a/tests/test_multispec.py b/tests/test_multispec.py
new file mode 100644
index 00000000..3d280eb5
--- /dev/null
+++ b/tests/test_multispec.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+import numpy as np
+
+import pytest
+
+from sedpy.observate import load_filters
+from prospect.sources import CSPSpecBasis
+from prospect.models import SpecModel, templates
+from prospect.observation import Spectrum, Photometry
+
+
+@pytest.fixture(scope="module")
+def build_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+def build_model(add_neb=False):
+    model_params = templates.TemplateLibrary["parametric_sfh"]
+    if add_neb:
+        model_params.update(templates.TemplateLibrary["nebular"])
+    return SpecModel(model_params)
+
+
+def build_obs(multispec=True):
+    N = 1500 * (2 - multispec)
+    wmax = 7000
+    wsplit = wmax - N * multispec
+
+    fnames = list([f"sdss_{b}0" for b in "ugriz"])
+    Nf = len(fnames)
+    phot = [Photometry(filters=fnames, flux=np.ones(Nf), uncertainty=np.ones(Nf)/10)]
+    spec = [Spectrum(wavelength=np.linspace(4000, wsplit, N),
+                     flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                     mask=slice(None))]
+
+    if multispec:
+        spec += [Spectrum(wavelength=np.linspace(wsplit+1, wmax, N),
+                          flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                          mask=slice(None))]
+
+    obslist = spec + phot
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+def test_prediction_nodata(build_sps):
+    sps = build_sps
+    model = build_model(add_neb=True)
+    sobs, pobs = build_obs(multispec=False)
+    pobs.flux = None
+    pobs.uncertainty = None
+    sobs.wavelength = None
+    sobs.flux = None
+    sobs.uncertainty = None
+    pred, mfrac = model.predict(model.theta, observations=[sobs, pobs], sps=sps)
+    assert len(pred[0]) == len(sps.wavelengths)
+    assert len(pred[1]) == len(pobs.filterset)
+
+
+def test_multispec(build_sps):
+    sps = build_sps
+
+    obslist_single = build_obs(multispec=False)
+    obslist_multi = build_obs(multispec=True)
+    model = build_model(add_neb=True)
+
+    preds_single, mfrac = model.predict(model.theta, observations=obslist_single, sps=sps)
+    preds_multi, mfrac = model.predict(model.theta, observations=obslist_multi, sps=sps)
+
+    assert len(preds_single) == 2
+    assert len(preds_multi) == 3
+    assert np.allclose(preds_single[-1], preds_multi[-1])
+
+    # TODO: turn this plot into an actual test
+    #import matplotlib.pyplot as pl
+    #fig, ax = pl.subplots()
+    #ax.plot(obslist_single[0].wavelength, predictions_single[0])
+    #for p, o in zip(predictions, obslist):
+    #    if o.kind == "photometry":
+    #        ax.plot(o.wavelength, p, "o")
+    #    else:
+    #        ax.plot(o.wavelength, p)
+
+
+def test_multires():
+    # Test the smoothing of multiple spectra to different resolutions
+    # - give the same wavelength array different instrumental resolutions, assert similar but different, and that smoothing by the difference gives the right answer
+    # Test the use of two differernt smoothings, physical and instrumental
+    # - give an obs with no instrument smoothing and one with, make sure they are different
+    pass
+
+
+def test_multinoise():
+    pass
+
+
+def test_multical():
+    pass
\ No newline at end of file

From 48318f992709c964c649a21eb1b234464493425a Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 9 Jan 2024 12:57:28 -0500
Subject: [PATCH 054/132] propogate fitted emission line uncertainties across
 prior and multiple spectra.

---
 prospect/models/sedmodel.py | 38 ++++++++++++++++++++++++-------------
 tests/test_multispec.py     |  9 +++++++++
 2 files changed, 34 insertions(+), 13 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 76219e90..3d6df346 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -112,9 +112,12 @@ def predict(self, theta, observations=None, sps=None, **extras):
         # cache eline observed wavelengths
         eline_z = self.params.get("eline_delta_zred", 0.0)
         self._ewave_obs = (1 + eline_z + self._zred) * self._eline_wave
+
         # cache eline mle info
         self._ln_eline_penalty = 0
-        self._eline_lum_var = np.zeros_like(self._eline_wave)
+        self._eline_lum_mle = self._eline_lum.copy()
+        self._eline_lum_covar = np.diag((self.params.get('eline_prior_width', 0.0) *
+                                         self._eline_lum)**2)
 
         # physical velocity smoothing of the whole UV/NIR spectrum
         self._smooth_spec = self.velocity_smoothing(self._wave, self._norm_spec)
@@ -510,7 +513,7 @@ def fit_mle_elines(self, obs, calibrated_spec, sigma_spec=None):
         :param calibrated_spec:
             The predicted (so far) observer-frame spectrum in the same units as
             the observed spectrum, ndarray of shape ``(n_wave,)``  Should
-            include pixed lines but not lines to be fit
+            include fixed lines but not lines to be fit
 
         :param sigma_spec:
             Spectral covariance matrix, if using a non-trivial noise model.
@@ -553,16 +556,24 @@ def fit_mle_elines(self, obs, calibrated_spec, sigma_spec=None):
         else:
             sigma_inv = np.diag(1. / sigma_spec)
 
-        # calculate ML emission line amplitudes and covariance matrix
+        # Calculate ML emission line amplitudes and covariance matrix
         # FIXME: nebopt: do this with a solve
         sigma_alpha_hat = np.linalg.pinv(np.dot(eline_gaussians.T, np.dot(sigma_inv, eline_gaussians)))
         alpha_hat = np.dot(sigma_alpha_hat, np.dot(eline_gaussians.T, np.dot(sigma_inv, delta)))
 
-        # generate likelihood penalty term (and MAP amplitudes)
-        # FIXME: Cache line amplitude covariance matrices?
-        if self.params.get('use_eline_prior', False):
-            # Incorporate gaussian priors on the amplitudes
-            sigma_alpha_breve = np.diag((self.params['eline_prior_width'] * np.abs(alpha_breve)))**2
+        # Generate likelihood penalty term (and MAP amplitudes)
+
+        # grab current covar matrix for these lines
+        sigma_alpha_breve = self._eline_lum_covar[np.ix_(idx, idx)]
+
+        if np.any(sigma_alpha_breve > 0):
+            # Incorporate gaussian "priors" on the amplitudes
+            # these can come from cloudy model & uncertainty, or fit from previous dataset
+
+            # first account for calibration vector
+            sigma_alpha_breve = sigma_alpha_breve * linecal[:, None] * linecal[None, :]
+
+            # combine covar matrices
             M = np.linalg.pinv(sigma_alpha_hat + sigma_alpha_breve)
             alpha_bar = (np.dot(sigma_alpha_breve, np.dot(M, alpha_hat)) +
                          np.dot(sigma_alpha_hat, np.dot(M, alpha_breve)))
@@ -576,15 +587,16 @@ def fit_mle_elines(self, obs, calibrated_spec, sigma_spec=None):
             sigma_alpha_bar = sigma_alpha_hat
             K = ln_mvn(alpha_hat, mean=alpha_hat, cov=sigma_alpha_hat)
 
-        # Cache the ln-penalty
-        # FIXME this needs to be acumulated if there are multiple spectra
+        # Cache the ln-penalty, accumulating (in case there are multiple spectra)
         self._ln_eline_penalty += K
 
-        # Store fitted emission line luminosities in physical units
+        # Store fitted emission line luminosities in physical units, including prior
         self._eline_lum[idx] = alpha_bar / linecal
-        self._eline_lum_var[idx] = np.diag(sigma_alpha_bar) / linecal**2
+        # store new Gaussian uncertainties in physical units
+        self._eline_lum_var[np.ix_(idx, idx)] = sigma_alpha_bar / linecal[:, None] / linecal[None, :]
 
-        # return the maximum-likelihood line spectrum in observed units
+        # return the maximum-likelihood line spectrum for this observation in observed units
+        self._eline_lum_mle[idx] = alpha_hat / linecal
         return alpha_hat * eline_gaussians
 
     def predict_eline_spec(self, line_indices=slice(None), wave=None):
diff --git a/tests/test_multispec.py b/tests/test_multispec.py
index 3d280eb5..c69a66cb 100644
--- a/tests/test_multispec.py
+++ b/tests/test_multispec.py
@@ -86,6 +86,15 @@ def test_multispec(build_sps):
     #        ax.plot(o.wavelength, p)
 
 
+def test_multiline():
+    """The goal is combine all constraints on the emission line luminosities.
+    
+    
+    
+    """
+
+
+
 def test_multires():
     # Test the smoothing of multiple spectra to different resolutions
     # - give the same wavelength array different instrumental resolutions, assert similar but different, and that smoothing by the difference gives the right answer

From d13454c483b19e03158405892b9dce5c33bd990d Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 9 Jan 2024 14:24:12 -0500
Subject: [PATCH 055/132] [ci skip] update v2.0 todo list.

---
 README.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index d6ad5f71..bc8ab330 100644
--- a/README.md
+++ b/README.md
@@ -17,20 +17,20 @@ Work to do includes:
 - [x] Put responsibility for Noise Models including outlier modeling in individual Observation instances
 - [x] Make predictions even when there is no fittable data (e.g. model spectra when fitting photometry only)
 - [x] Store Observation objects in HDF5, FITS, etc as structured arrays with metadata
-- [ ] Test multi-spectral calibration
-- [ ] Test multi-spectral instrumental & physical smoothing
-- [ ] Test smoothing accounting for library resolution
-- [ ] Test multi-spectra noise modeling
-- [ ] Catch (and handle?) emission line marginalization if spectra overlap.
-- [x] Update demo scripts
+- [x] Catch (and handle) emission line marginalization if spectra overlap.
+- [x] Structured ndarray for output chains and lnlikehoods
 - [x] Update docs
+- [x] Update demo scripts
+- [ ] Account for undersampled spectra via a square convolution in pixel space (or explicit rebinning)
 - [ ] Update notebooks
-- [x] Structured ndarray for output chains and lnlikehoods
+- [ ] Update plotting module
 - [ ] Test i/o with structured arrays
+- [ ] Test multi-spectral calibration, smoothing, and noise modeling
+- [ ] Test smoothing accounting for library, instrumental & physical smoothing
 - [ ] Structured ndarray for derived parameters
-- [ ] Store samples of spectra, photometry, and mfrac
-- [ ] Update plotting module
+- [ ] Store samples of spectra, photometry, and mfrac (blobs)
 - [ ] Implement an emulator-based SpecModel class
+- [ ] Implement UltraNest and Nautilus backends
 
 
 Purpose

From 417adb629aaef7083b1748fcc88e3a72dd0acd2d Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 21 Jan 2024 21:28:39 -0500
Subject: [PATCH 056/132] update dtypes for numpy 1.20; closes #315

---
 prospect/io/write_results.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index d8d7a7bc..81a41571 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -338,8 +338,8 @@ def write_obs_to_h5(hf, obs):
 
 def optresultlist_to_ndarray(results):
     npar, nout = len(results[0].x), len(results[0].fun)
-    dt = [("success", np.bool), ("message", "S50"), ("nfev", np.int),
-          ("x", (np.float, npar)), ("fun", (np.float, nout))]
+    dt = [("success", bool), ("message", "U50"), ("nfev", int),
+          ("x", (float, npar)), ("fun", (float, nout))]
     out = np.zeros(len(results), dtype=np.dtype(dt))
     for i, r in enumerate(results):
         for f in out.dtype.names:

From b2d4b2d5428a4577602aea857bf787d5cc2ee147 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 26 Jan 2024 17:26:29 -0500
Subject: [PATCH 057/132] add DLA absorption to spectrum.

---
 prospect/models/sedmodel.py | 83 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 82 insertions(+), 1 deletion(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 3d6df346..bd139a32 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -53,7 +53,8 @@ def _available_parameters(self):
                     ("eline_delta_zred", ""),
                     ("eline_sigma", ""),
                     ("use_eline_priors", ""),
-                    ("eline_prior_width", "")]
+                    ("eline_prior_width", ""),
+                    ("dla_logNh", "log_10 HI column density for damped Lyman-alpha absorption")]
 
         referenced_pars = [("mass", ""),
                            ("lumdist", ""),
@@ -121,6 +122,8 @@ def predict(self, theta, observations=None, sps=None, **extras):
 
         # physical velocity smoothing of the whole UV/NIR spectrum
         self._smooth_spec = self.velocity_smoothing(self._wave, self._norm_spec)
+        # DLA absorption
+        self._smooth_spec = self.add_dla(self._wave, self._smooth_spec)
 
         # generate predictions for likelihood
         # this assumes all spectral datasets (if present) occur first
@@ -671,6 +674,15 @@ def velocity_smoothing(self, wave, spec):
 
         return outspec
 
+    def add_dla(self, wave_rest, spec):
+        logN = self.params.get("dla_logNh", None)
+        if logN is None:
+            return spec
+        tau = voigt_profile(wave_rest, 10**logN)
+        spec *= np.exp(-tau)
+        return spec
+
+
     def observed_wave(self, wave, do_wavecal=False):
         """Convert the restframe wavelngth grid to the observed frame wavelength
         grid, optionally including wavelength calibration adjustments.  Requires
@@ -1164,3 +1176,72 @@ def gauss(x, mu, A, sigma):
     mu, A, sigma = np.atleast_2d(mu), np.atleast_2d(A), np.atleast_2d(sigma)
     val = A / (sigma * np.sqrt(np.pi * 2)) * np.exp(-(x[:, None] - mu)**2 / (2 * sigma**2))
     return val.sum(axis=-1)
+
+
+def H(a, x):
+    """Voigt Profile Approximation from T. Tepper-Garcia (2006, 2007).
+    Valid to a fractional error of ~ 1e-7 * (N_h/10^22) for Lyman-alpha (a~1e-4)"""
+    P = x**2
+    H0 = np.exp(-x**2)
+    Q = 1.5/x**2
+    return H0 - a/np.sqrt(np.pi)/P * (H0*H0*(4.*P*P + 7.*P + 4. + Q) - Q - 1)
+
+
+def voigt_profile(wave_rest, N, bkms=40, l0=1215.6696, f=4.16e-1, gamma=6.265e8):
+    """
+    Calculate the optical depth Voigt profile.
+    Default values of the atomic constants f, l0, and gamma are for Lyman-alpha.
+    Following Krogager 2018
+
+    Parameters
+    ----------
+    wave_rest : array_like, shape (N)
+        Restframe wavelength grid in Angstroms at which to evaluate the optical depth.
+
+    l0 : float
+        Rest frame transition wavelength in Angstroms.
+
+    f : float
+        Oscillator strength.
+
+    N : float
+        Column density in units of cm^-2.
+
+    bkms : float
+        Velocity width of the Voigt profile in km/s.
+
+    gamma : float
+        Radiation damping constant, or Einstein constant (A_ul)
+
+    Returns
+    -------
+    tau : array_like, shape (N)
+        Optical depth array evaluated at the input grid wavelengths `l`.
+    """
+    # Units & constants
+    c = 2.99792e10        # cm/s
+    const = 0.0149736082  # sqrt(pi) * e**2/(c * m_e) (cgs)
+    l0_cm = (l0*1.e-8)
+    b = bkms * 1e5
+
+    # Calculate Profile
+    C_a = const * f * l0_cm / b
+    a = l0_cm * gamma / (4.*np.pi*b)
+
+    x = (c / b) * (1. - l0 / wave_rest)
+    tau = np.float64(C_a) * N * H(a, x)
+
+    return tau
+
+
+def Voigt(x, alpha, gamma):
+    """
+    Return the Voigt line shape at x with Lorentzian component HWHM gamma
+    and Gaussian component HWHM alpha.
+
+    """
+    from scipy.special import wofz
+    sigma = alpha / np.sqrt(2 * np.log(2))
+
+    return np.real(wofz((x + 1j*gamma)/sigma/np.sqrt(2))) / sigma\
+                                                           /np.sqrt(2*np.pi)
\ No newline at end of file

From 167b3dc543b51bef6d1e6acaae98ff3e27ba2cdb Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 27 Jan 2024 15:54:47 -0500
Subject: [PATCH 058/132] make sure photometry includes igm and physical
 smoothing.

---
 prospect/models/sedmodel.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index bd139a32..33528420 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -305,7 +305,7 @@ def predict_phot(self, filterset):
 
         # generate photometry w/o emission lines
         obs_wave = self.observed_wave(self._wave, do_wavecal=False)
-        flambda = self._norm_spec * lightspeed / obs_wave**2 * (3631*jansky_cgs)
+        flambda = self._smooth_spec * lightspeed / obs_wave**2 * (3631*jansky_cgs)
         phot = np.atleast_1d(getSED(obs_wave, flambda, filterset, linear_flux=True))
 
         # generate emission-line photometry

From 477a6a4b248600a3c134080c8713c704a051038e Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 27 Jan 2024 16:56:30 -0500
Subject: [PATCH 059/132] add test for dla.

---
 tests/test_dla.py | 91 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100644 tests/test_dla.py

diff --git a/tests/test_dla.py b/tests/test_dla.py
new file mode 100644
index 00000000..acb960dd
--- /dev/null
+++ b/tests/test_dla.py
@@ -0,0 +1,91 @@
+import sys
+import numpy as np
+
+import pytest
+
+from prospect.sources import CSPSpecBasis
+from prospect.models import SpecModel, templates, priors
+from prospect.observation import Spectrum, Photometry
+
+
+@pytest.fixture
+def build_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+def build_model(free_dla=True):
+    model_params = templates.TemplateLibrary["parametric_sfh"]
+    model_params["zred"]["isfree"] = True
+    model_params.update(templates.TemplateLibrary["nebular"])
+    model_params["nebemlineinspec"]["init"] = False
+    lya = "Ly-alpha 1215"
+    model_params["elines_to_ignore"] = dict(init=lya, isfree=False)
+
+    # scaling igm_factor is something like x_HI
+    model_params.update(templates.TemplateLibrary["igm"])
+    model_params["igm_factor"]["isfree"] = True
+
+    # Add the dla column density parameter
+    model_params["dla_logNh"] = dict(N=1, isfree=free_dla, init=18,
+                                     prior=priors.Uniform(mini=18, maxi=23))
+
+    return SpecModel(model_params)
+
+
+def build_obs():
+
+    N = 1000
+    wave = np.linspace(0.7e4, 4e4, N)
+
+    lw = ["090w", "115w", "150w", "162m", "182m", "200w", "210m"]
+    sw = ["250m", "277w", "300m", "335m", "356w", "410m", "444w"]
+    fnames = list([f"jwst_f{b}" for b in sw+lw])
+    Nf = len(fnames)
+    phot = [Photometry(filters=fnames, flux=np.ones(Nf), uncertainty=np.ones(Nf)/10)]
+    spec = [Spectrum(wavelength=wave, flux=np.ones(N),
+                     uncertainty=np.ones(N) / 10, mask=slice(None))]
+
+    obslist = spec + phot
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+def test_dla(build_sps, plot=False):
+    sps = build_sps
+
+    obs = build_obs()
+    model = build_model()
+
+    model.params["zred"] = 13
+    model.params["dla_logNh"] = 0
+    model.params["tage"] = 0.4
+    model.params["tau"] = 0.2
+    theta1 = model.theta.copy()
+
+    pred1 = model.predict(theta1, obs, sps)
+    (spec1, phot1), mfrac = pred1
+
+    if plot:
+        import matplotlib.pyplot as pl
+        #pl.ion()
+        fig, ax = pl.subplots()
+        ax.plot(obs[0].wavelength/1e4, spec1)
+        ax.plot(obs[1].wavelength/1e4, phot1, "o")
+
+    for nh in [21.5, 22, 23]:
+        model.params["dla_logNh"] = nh
+        theta = model.theta.copy()
+        pred = model.predict(theta, obs, sps)
+        (spec, phot), mfrac = pred
+        assert np.any(phot < phot1)
+        assert np.any(spec < spec1)
+        if plot:
+            ax.plot(obs[0].wavelength/1e4, spec, label=f"log N_h={nh}")
+
+    if plot:
+        ax.plot(obs[1].wavelength/1e4, phot, "o", label=f"log N_h={nh}")
+        ax.legend()
+        ax.set_xlabel(r"$\lambda (\mu{\rm m})$")
+        ax.set_ylabel(r"$f_\nu$")
+        fig.savefig("prospector_dla.png")
\ No newline at end of file

From 555fc9f7405be0fdf887bbf92f3c9ef668c7f949 Mon Sep 17 00:00:00 2001
From: Jenny Wan <jtw.cpc@gmail.com>
Date: Sun, 17 Mar 2024 21:11:34 -0700
Subject: [PATCH 060/132] Add files via upload

---
 prospect/models/parameters.py | 108 ++++++++++-
 prospect/models/priors.py     | 327 +++++++---------------------------
 prospect/models/templates.py  | 121 ++++++++-----
 prospect/models/transforms.py | 117 ++++++------
 4 files changed, 293 insertions(+), 380 deletions(-)

diff --git a/prospect/models/parameters.py b/prospect/models/parameters.py
index 888e4d03..249367ba 100644
--- a/prospect/models/parameters.py
+++ b/prospect/models/parameters.py
@@ -13,6 +13,9 @@
 import json, pickle
 from . import priors
 from .templates import describe
+import scipy
+from gp_sfh import *
+import gp_sfh_kernels
 
 __all__ = ["ProspectorParams"]
 
@@ -166,6 +169,7 @@ def prior_product(self, theta, nested=False, **extras):
             The natural log of the prior probability at ``theta``
         """
         lpp = self._prior_product(theta)
+        # print(lpp)
         if nested & np.any(np.isfinite(lpp)):
             return 0.0
         return lpp
@@ -184,11 +188,41 @@ def _prior_product(self, theta, **extras):
             parameter values.
         """
         lnp_prior = 0
-        for k, inds in list(self.theta_index.items()):
-
-            func = self.config_dict[k]['prior']
-            this_prior = np.sum(func(theta[..., inds]), axis=-1)
+        
+        hyper_params = ['sigma_reg', 'tau_eq', 'tau_in', 'sigma_dyn', 'tau_dyn']
+        psd_params = np.zeros(len(hyper_params))
+        
+        if any(hp in self.theta_index.keys() for hp in hyper_params):
+            for i, p in enumerate(hyper_params):
+                if self.config_dict[p]['isfree']:
+                    inds = self.theta_index[p]
+                    psd_params[i] = theta[..., inds][0]
+                    func = self.config_dict[p]['prior']
+                    this_prior = np.sum(func(theta[..., inds]), axis=-1)
+                    lnp_prior += this_prior
+                else:
+                    psd_params[i] = self.config_dict[p]['init']
+                    
+            sfr_covar_matrix = get_sfr_covar(psd_params, agebins=self.config_dict['agebins']['init'])
+            sfr_ratio_covar_matrix = sfr_covar_to_sfr_ratio_covar(sfr_covar_matrix)
+            nbins = len(self.config_dict['agebins']['init'])
+            logsfr_ratio_prior = scipy.stats.multivariate_normal(mean=[0.]*(nbins-1), cov=sfr_ratio_covar_matrix)
+            inds = self.theta_index['logsfr_ratios']
+            this_prior = np.sum(np.log(logsfr_ratio_prior.pdf(theta[..., inds])))
+            #this_prior = np.sum(logsfr_ratio_prior(theta[..., inds]), axis=-1)
             lnp_prior += this_prior
+        
+            for k, inds in list(self.theta_index.items()):
+                if (k in hyper_params) or (k == 'logsfr_ratios'):
+                    continue
+                func = self.config_dict[k]['prior']
+                this_prior = np.sum(func(theta[..., inds]), axis=-1)
+                lnp_prior += this_prior
+        else:
+            for k, inds in list(self.theta_index.items()):
+                func = self.config_dict[k]['prior']
+                this_prior = np.sum(func(theta[..., inds]), axis=-1)
+                lnp_prior += this_prior
 
         return lnp_prior
 
@@ -203,9 +237,41 @@ def prior_transform(self, unit_coords):
             corresponding to ``unit_coords``. ndarray of shape ``(ndim,)``
         """
         theta = np.zeros(len(unit_coords))
-        for k, inds in list(self.theta_index.items()):
-            func = self.config_dict[k]['prior'].unit_transform
-            theta[inds] = func(unit_coords[inds])
+        
+        hyper_params = ['sigma_reg', 'tau_eq', 'tau_in', 'sigma_dyn', 'tau_dyn']
+        psd_params = np.zeros(len(hyper_params))
+        
+        
+        if any(hp in self.theta_index.keys() for hp in hyper_params):
+        
+            for i, p in enumerate(hyper_params):
+                if self.config_dict[p]['isfree']:
+                    func = self.config_dict[p]['prior'].unit_transform
+                    inds = self.theta_index[p]
+                    psd_params[i] = func(unit_coords[inds])
+                    theta[inds] = psd_params[i]
+                else:
+                    psd_params[i] = self.config_dict[p]['init']
+                
+            sfr_covar_matrix = get_sfr_covar(psd_params, agebins=self.config_dict['agebins']['init'])#, **self.params)
+            sfr_ratio_covar_matrix = sfr_covar_to_sfr_ratio_covar(sfr_covar_matrix)
+            logsfr_ratio_prior = priors.MultiVariateNormal(mean=0, Sigma=sfr_ratio_covar_matrix)
+            x = unit_coords[self.theta_index['logsfr_ratios']]
+            logsfr_ratios = logsfr_ratio_prior.unit_transform(x)
+            theta[self.theta_index['logsfr_ratios']] = logsfr_ratios
+                        
+            for k, inds in list(self.theta_index.items()):
+                if (k in hyper_params) or (k == 'logsfr_ratios'):
+                    continue
+                func = self.config_dict[k]['prior'].unit_transform
+                theta[inds] = func(unit_coords[inds])
+            
+        else:
+
+            for k, inds in list(self.theta_index.items()):
+                func = self.config_dict[k]['prior'].unit_transform
+                theta[inds] = func(unit_coords[inds])
+        
         return theta
 
     def propagate_parameter_dependencies(self):
@@ -409,3 +475,31 @@ def pdict_to_plist(pdict, order=None):
         plist += [v]
     return plist
 
+
+def get_sfr_covar(psd_params, agebins=[], **extras):
+
+    bincenters = np.array([np.mean(agebins[i]) for i in range(len(agebins))])
+    bincenters = (10**bincenters)/1e9
+    case1 = simple_GP_sfh()
+    case1.tarr = bincenters
+    case1.kernel = gp_sfh_kernels.extended_regulator_model_kernel_paramlist
+    covar_matrix = case1.get_covariance_matrix(kernel_params = psd_params, show_prog=False)
+
+    return covar_matrix
+
+
+def sfr_covar_to_sfr_ratio_covar(covar_matrix):
+    
+    dim = covar_matrix.shape[0]
+    
+    sfr_ratio_covar = []
+    
+    for i in range(dim-1):
+        row = []
+        for j in range(dim-1):
+            cov = covar_matrix[i][j] - covar_matrix[i+1][j] - covar_matrix[i][j+1] + covar_matrix[i+1][j+1]
+            row.append(cov)
+        sfr_ratio_covar.append(row)
+    
+    return np.array(sfr_ratio_covar)
+
diff --git a/prospect/models/priors.py b/prospect/models/priors.py
index 335ba90e..a04a7785 100644
--- a/prospect/models/priors.py
+++ b/prospect/models/priors.py
@@ -5,16 +5,13 @@
 When called these return the ln-prior-probability, and they can also be used to
 construct prior transforms (for nested sampling) and can be sampled from.
 """
+
 import numpy as np
 import scipy.stats
-from scipy.special import erf, erfinv
 
-__all__ = ["Prior", "Uniform", "TopHat", "Normal", "ClippedNormal",
+__all__ = ["Prior", "Uniform", "TopHat", "Normal", "MultiVariateNormal", "ClippedNormal",
            "LogNormal", "LogUniform", "Beta",
-           "StudentT", "SkewNormal",
-           "FastUniform", "FastTruncatedNormal",
-           "FastTruncatedEvenStudentTFreeDeg2",
-           "FastTruncatedEvenStudentTFreeDeg2Scalar"]
+           "StudentT", "SkewNormal"]
 
 
 class Prior(object):
@@ -38,7 +35,7 @@ class Prior(object):
         A list of names of the parameters, used to alias the intrinsic
         parameter names.  This way different instances of the same Prior can
         have different parameter names, in case they are being fit for....
-
+    
     Attributes
     ----------
     params : dictionary
@@ -106,18 +103,22 @@ def __call__(self, x, **kwargs):
         """
         if len(kwargs) > 0:
             self.update(**kwargs)
+            
         pdf = self.distribution.pdf
+        
         try:
             p = pdf(x, *self.args, loc=self.loc, scale=self.scale)
-        except(ValueError):
+            
+        except(ValueError):#, TypeError):
             # Deal with `x` vectors of shape (nsamples, len(prior))
             # for pdfs that don't broadcast nicely.
             p = [pdf(_x, *self.args, loc=self.loc, scale=self.scale)
-                 for _x in x]
+                 for _x in x]           
             p = np.array(p)
 
         with np.errstate(invalid='ignore'):
             lnp = np.log(p)
+            
         return lnp
 
     def sample(self, nsample=None, **kwargs):
@@ -260,6 +261,64 @@ def bounds(self, **kwargs):
         return (-np.inf, np.inf)
 
 
+class MultiVariateNormal(Prior):
+    prior_params = ["mean", 'Sigma']
+    distribution = scipy.stats.norm
+
+    @property
+    def scale(self):
+        return self.params['Sigma']
+
+    @property
+    def loc(self):
+        return self.params['mean']
+
+    @property
+    def range(self):
+        nsig = 4
+        return (self.params['mean'] - nsig * self.params['Sigma'],
+                self.params['mean'] + nsig * self.params['Sigma'])
+
+    def bounds(self, **kwargs):
+        #if len(kwargs) > 0:
+        #    self.update(**kwargs)
+        return (-np.inf, np.inf)
+    
+    def sample(self, nsample=None, **kwargs):
+        prior = scipy.stats.multivariate_normal(mean=self.loc, cov=self.scale)
+        return prior.rvs(size = nsample)
+
+    def unit_transform(self, x, **kwargs):
+        """Go from a value of the CDF (between 0 and 1) to the corresponding
+        parameter value.
+
+        :param x:
+            A scalar or vector of same length as the Prior with values between
+            zero and one corresponding to the value of the CDF.
+
+        :returns theta:
+            The parameter value corresponding to the value of the CDF given by
+            `x`.
+        """
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+        z = self.distribution.ppf(x, *self.args, loc=0, scale=1)
+        #print(z)
+        sqrtS = np.linalg.cholesky(self.params['Sigma']) #, lower=True)
+        #print(sqrtS)
+        #theta = np.matmul(z, sqrtS)
+        theta = np.matmul(sqrtS, z)
+        return theta
+    
+    def inverse_unit_transform(self, x, **kwargs):
+        """Go from the parameter value to the unit coordinate using the cdf.
+        """
+        if len(kwargs) > 0:
+            self.update(**kwargs)
+        return scipy.stats.multivariate_normal.cdf(x, *self.args,
+                                                   mean=0., cov=self.params['Sigma'])
+
+
 class ClippedNormal(Prior):
     """A Gaussian prior clipped to some range.
 
@@ -522,253 +581,3 @@ def range(self):
 
     def bounds(self, **kwargs):
         return (-np.inf, np.inf)
-
-# fast versions to the above priors
-# essentially rewriting the numpy/scipy functions
-
-# A faster uniform distribution. Give it a lower bound `a` and
-# an upper bound `b`.
-class FastUniform(Prior):
-
-    prior_params = ['a', 'b']
-
-    def __init__(self, a=0.0, b=1.0, parnames=[], name='', ):
-        if len(parnames) == 0:
-            parnames = self.prior_params
-        assert len(parnames) == len(self.prior_params)
-
-        self.alias = dict(zip(self.prior_params, parnames))
-        self.params = {}
-
-        self.name = name
-
-        self.a, self.b = a, b
-
-        if self.b <= self.a:
-            raise ValueError('b must be greater than a')
-
-        self.diffthing = b - a
-        self.pdfval = 1.0 / (b - a)
-        self.logpdfval = np.log(self.pdfval)
-
-    def __len__(self):
-        return 1
-
-    def __call__(self, x):
-        if not hasattr(x, "__len__"):
-            if self.a <= x <= self.b:
-                return self.logpdfval
-            else:
-                return np.NINF
-        else:
-            return [self.logpdfval if (self.a <= xi <= self.b) else np.NINF for xi in x]
-
-    def scale(self):
-        return 0.5 * self.diffthing
-
-    def loc(self):
-        return 0.5 * (self.a + self.b)
-
-    def unit_transform(self, x):
-        return (x * self.diffthing) + self.a
-
-    def sample(self):
-        return self.unit_transform(np.random.rand())
-
-
-# A faster truncated normal distribution. Give it a lower bound `a`,
-# a upper bound `b`, a mean `mu`, and a standard deviation `sig`.
-class FastTruncatedNormal(Prior):
-
-    prior_params = ['a', 'b', 'mu', 'sig']
-
-    def __init__(self, a=-1.0, b=1.0, mu=0.0, sig=1.0, parnames=[], name='', ):
-        if len(parnames) == 0:
-            parnames = self.prior_params
-        assert len(parnames) == len(self.prior_params)
-
-        self.alias = dict(zip(self.prior_params, parnames))
-        self.params = {}
-
-        self.name = name
-
-        self.a, self.b, self.mu, self.sig = a, b, mu, sig
-
-        if self.b <= self.a:
-            raise ValueError('b must be greater than a')
-
-        self.alpha = (self.a - self.mu) / self.sig
-        self.beta = (self.b - self.mu) / self.sig
-
-        self.A = erf(self.alpha / np.sqrt(2.0))
-        self.B = erf(self.beta / np.sqrt(2.0))
-
-    def xi(self, x):
-        return (x - self.mu) / self.sig
-
-    def phi(self, x):
-        return np.sqrt(2.0 / (self.sig**2.0 * np.pi)) * np.exp(-0.5 * self.xi(x)**2.0)
-
-    def __len__(self):
-        return 1
-
-    def __call__(self, x):
-        # if self.a <= x <= self.b:
-        #     return np.log(self.phi(x) / (self.B - self.A))
-        # else:
-        #     return np.NINF
-        if not hasattr(x, "__len__"):
-            if self.a <= x <= self.b:
-                return np.log(self.phi(x) / (self.B - self.A))
-            else:
-                np.NINF
-        else:
-            return [np.log(self.phi(xi) / (self.B - self.A)) if (self.a <= xi <= self.b) else np.NINF for xi in x]
-
-    def scale(self):
-        return self.sig
-
-    def loc(self):
-        return self.mu
-
-    def unit_transform(self, x):
-        return self.sig * np.sqrt(2.0) * erfinv((self.B - self.A) * x + self.A) + self.mu
-
-    def sample(self):
-        return self.unit_transform(np.random.rand())
-
-
-# Okay. This is a sort of Student's t-distribution that allows
-# for truncation and rescaling, but it requires nu = 2 and mu = 0
-# and for the truncation limits to be equidistant from mu. Give it
-# the half-width of truncation (i.e. if you want it truncated to the
-# domain (-5, 5), give it `hw = 5`) and the rescaled standard
-# devation `sig`.
-class FastTruncatedEvenStudentTFreeDeg2(Prior):
-
-    prior_params = ['hw', 'sig']
-
-    def __init__(self, hw=0.0, sig=1.0, parnames=[], name='', ):
-        if len(parnames) == 0:
-            parnames = self.prior_params
-        assert len(parnames) == len(self.prior_params)
-
-        self.alias = dict(zip(self.prior_params, parnames))
-        self.params = {}
-
-        self.name = name
-
-        self.hw, self.sig = hw, sig
-
-        if np.any(self.hw <= 0.0):
-            raise ValueError('hw must be greater than 0.0')
-
-        if np.any(self.sig <= 0.0):
-            raise ValueError('sig must be greater than 0.0')
-
-        self.const1 = np.sqrt(1.0 + 0.5*(self.hw**2.0))
-        self.const2 = 2.0 * self.sig * self.hw
-        self.const3 = self.const2**2.0
-        self.const4 = 2.0 * (self.hw**2.0)
-
-    def __len__(self):
-        return len(self.hw)
-
-    def __call__(self, x):
-        if not hasattr(x, "__len__"):
-            if np.abs(x) <= self.hw:
-                return np.log(self.const1 / (self.const2 * (1 + 0.5*(x / self.sig)**2.0)**1.5))
-            else:
-                return np.NINF
-        else:
-            ret = np.log(self.const1 / (self.const2 * (1 + 0.5*(x / self.sig)**2.0)**1.5))
-            bad = np.abs(x) > self.hw
-            ret[bad] = np.NINF
-            return ret
-
-    def scale(self):
-        return self.sig
-
-    def loc(self):
-        return 0.0
-
-    def invcdf_numerator(self, x):
-        return -1.0 * (self.const3 * x**2.0 - self.const3 * x + (self.sig * self.hw)**2.0)
-
-    def invcdf_denominator(self, x):
-        return self.const4 * x**2.0 - self.const4 * x - self.sig**2.0
-
-    def unit_transform(self, x):
-        f = (((x > 0.5) & (x <= 1.0)) * np.sqrt(self.invcdf_numerator(x) / self.invcdf_denominator(x)) -
-             ((x >= 0.0) & (x <= 0.5)) * np.sqrt(self.invcdf_numerator(x) / self.invcdf_denominator(x)))
-        return f
-
-    def sample(self):
-        return self.unit_transform(np.random.rand())
-
-
-# Okay. This is a sort of Student's t-distribution that allows
-# for truncation and rescaling, but it requires nu = 2 and mu = 0
-# and for the truncation limits to be equidistant from mu. Give it
-# the half-width of truncation (i.e. if you want it truncated to the
-# domain (-5, 5), give it `hw = 5`) and the rescaled standard
-# devation `sig`.
-class FastTruncatedEvenStudentTFreeDeg2Scalar(Prior):
-
-    prior_params = ['hw', 'sig']
-
-    def __init__(self, hw=0.0, sig=1.0, parnames=[], name='', ):
-        if len(parnames) == 0:
-            parnames = self.prior_params
-        assert len(parnames) == len(self.prior_params)
-
-        self.alias = dict(zip(self.prior_params, parnames))
-        self.params = {}
-
-        self.name = name
-
-        self.hw, self.sig = hw, sig
-
-        if self.hw <= 0.0:
-            raise ValueError('hw must be greater than 0.0')
-
-        if self.sig <= 0.0:
-            raise ValueError('sig must be greater than 0.0')
-
-        self.const1 = np.sqrt(1.0 + 0.5*(self.hw**2.0))
-        self.const2 = 2.0 * self.sig * self.hw
-        self.const3 = self.const2**2.0
-        self.const4 = 2.0 * (self.hw**2.0)
-
-    def __len__(self):
-        return 1
-
-    def __call__(self, x):
-        if not hasattr(x, "__len__"):
-            if np.abs(x) <= self.hw:
-                return np.log(self.const1 / (self.const2 * (1 + 0.5*(x / self.sig)**2.0)**1.5))
-            else:
-                return np.NINF
-        else:
-            return [np.log(self.const1 / (self.const2 * (1 + 0.5*(xi / self.sig)**2.0)**1.5)) if np.abs(xi) <= self.hw else np.NINF for xi in x]
-
-    def scale(self):
-        return self.sig
-
-    def loc(self):
-        return 0.0
-
-    def invcdf_numerator(self, x):
-        return -1.0 * (self.const3 * x**2.0 - self.const3 * x + (self.sig * self.hw)**2.0)
-
-    def invcdf_denominator(self, x):
-        return self.const4 * x**2.0 - self.const4 * x - self.sig**2.0
-
-    def unit_transform(self, x):
-        if 0.0 <= x <= 0.5:
-            return -1.0 * np.sqrt(self.invcdf_numerator(x) / self.invcdf_denominator(x))
-        elif 0.5 < x <= 1.0:
-            return np.sqrt(self.invcdf_numerator(x) / self.invcdf_denominator(x))
-
-    def sample(self):
-        return self.unit_transform(np.random.rand())
diff --git a/prospect/models/templates.py b/prospect/models/templates.py
index e8f164da..2a57bd81 100755
--- a/prospect/models/templates.py
+++ b/prospect/models/templates.py
@@ -9,13 +9,13 @@
 import numpy as np
 import os
 from . import priors
-from . import priors_beta
 from . import transforms
 
 __all__ = ["TemplateLibrary",
            "describe",
            "adjust_dirichlet_agebins",
            "adjust_continuity_agebins",
+           "adjust_stochastic_params"
            ]
 
 
@@ -131,6 +131,27 @@ def adjust_continuity_agebins(parset, tuniv=13.7, nbins=7):
     return parset
 
 
+def adjust_stochastic_params(parset, tuniv=13.7):
+    
+    agebins = parset['agebins']['init']
+    
+    ncomp = len(parset['agebins']['init'])
+    mean = np.zeros(ncomp - 1)
+    psd_params = [parset['sigma_reg']['init'], parset['tau_eq']['init'], parset['tau_in']['init'],
+                  parset['sigma_dyn']['init'], parset['tau_dyn']['init']]
+    sfr_covar = transforms.get_sfr_covar(psd_params, agebins=agebins)
+    sfr_ratio_covar = transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar)
+    rprior = priors.MultiVariateNormal(mean=mean, Sigma=sfr_ratio_covar)
+    
+    parset['mass']['N'] = ncomp
+    parset['agebins']['N'] = ncomp
+    parset["logsfr_ratios"]["N"] = ncomp - 1
+    parset["logsfr_ratios"]["init"] = mean
+    parset["logsfr_ratios"]["prior"] = rprior
+
+    return parset
+
+
 TemplateLibrary = Directory()
 
 # A template for what parameter configuration element should look like
@@ -284,9 +305,6 @@ def adjust_continuity_agebins(parset, tuniv=13.7, nbins=7):
                      delimiter=',')
 except OSError:
     info = {'name':[]}
-except TypeError:
-    # SPS_HOME not defined
-    info = {'name':[]}
 
 # Fit all lines by default
 elines_to_fit = {'N': 1, 'isfree': False, 'init': np.array(info['name'])}
@@ -659,6 +677,58 @@ def adjust_continuity_agebins(parset, tuniv=13.7, nbins=7):
 TemplateLibrary["dirichlet_sfh"] = (_dirichlet_,
                                     "Non-parameteric SFH with Dirichlet prior (fractional SFR)")
 
+
+# ----------------------------
+# --- Stochastic SFH ----
+# ----------------------------
+# A non-parametric SFH model which correlates the SFRs between time bins based on Extended Regulator model in TFC2020
+
+_stochastic_ = TemplateLibrary["ssp"]
+_ = _stochastic_.pop("tage")
+
+_stochastic_["sfh"] = {"N": 1, "isfree": False, "init": 3, "units": "FSPS index"}
+# This is the *total*  mass formed, as a variable
+_stochastic_["logmass"] = {"N": 1, "isfree": True, "init": 10, 'units': 'Msun',
+                           'prior': priors.TopHat(mini=7, maxi=12)}
+# This will be the mass in each bin.  It depends on other free and fixed
+# parameters.  Its length needs to be modified based on the number of bins
+_stochastic_["mass"] = {'N': 8, 'isfree': False, 'init': 1e6, 'units': r'M$_\odot$',
+                        'depends_on': transforms.logsfr_ratios_to_masses}
+
+# This gives the start and stop of each age bin.  It can be adjusted and its
+# length must match the lenth of "mass"
+agebins = [[0.0, 6.0], [6.0, 6.5], [6.5, 7.0], [7.0, 7.5], [7.5, 8.0], [8.0, 8.5], [8.5, 9.0], [9.5, 10.0]]
+_stochastic_["agebins"] = {'N': 8, 'isfree': False, 'init': agebins, 'units': 'log(yr)'}
+
+# Sets the PSD parameters & priors
+# sigma_reg: Overall stochasticity coming from gas inflow
+_stochastic_["sigma_reg"] = {'name': 'sigma_reg', 'N': 1, 'isfree': True, 'init': 0.3, 
+                             'prior': priors.LogUniform(mini=0.01, maxi=5.0), 'units': 'dex^2'}
+# tau_eq: Timescale associated with equilibrium gas cycling in gas reservoir (related to depletion timescale)
+_stochastic_["tau_eq"] = {'name': 'tau_eq', 'N': 1, 'isfree': True, 'init': 2.5, 
+                          'prior': priors.TopHat(mini=0.01, maxi=7.0), 'units': 'Gyr'}
+# tau_in: Characteristic timescale associated with gas inflow into gas reservoir
+_stochastic_["tau_in"] = {'name': 'tau_in', 'N': 1, 'isfree': False, 'init': 7.0, 'units': 'Gyr'}
+# sigma_dyn: Overall stochasticity coming from short-term, dynamical processes (e.g., creation/destruction of GMCs)
+_stochastic_["sigma_dyn"] = {'name': 'sigma_dyn', 'N': 1, 'isfree': True, 'init': 0.01, 
+                             'prior': priors.LogUniform(mini=0.001, maxi=0.1), 'units': 'dex^2'}
+# tau_dyn: Characteristic timescale associated with short-term, dynamical processes
+_stochastic_["tau_dyn"] = {'name': 'tau_dyn', 'N': 1, 'isfree': True, 'init': 0.025, 
+                           'prior': priors.ClippedNormal(mini=0.005, maxi=0.2, mean=0.01, sigma=0.02), 'units': 'Gyr'}
+
+# calculates covariance matrix from the initial PSD parameter values to be used in log SFR ratios prior
+psd_params = [0.3, 2.5, 1.0, 0.01, 0.025]
+sfr_covar = transforms.get_sfr_covar(psd_params, agebins=agebins)
+sfr_ratio_covar = transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar)
+
+# This controls the distribution of SFR(t) / SFR(t+dt). It has NBINS-1 components.
+_stochastic_["logsfr_ratios"] = {'N': 7, 'isfree': True, 'init': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                                 'prior': priors.MultiVariateNormal(mean=[0.]*7, Sigma=sfr_ratio_covar)}
+
+TemplateLibrary["stochastic_sfh"] = (_stochastic_,
+                                     "Stochastic SFH which correlates the SFRs between time bins based on model in TFC2020")
+
+
 # ----------------------------
 # --- Prospector-alpha ---
 # ----------------------------
@@ -694,46 +764,3 @@ def adjust_continuity_agebins(parset, tuniv=13.7, nbins=7):
 
 TemplateLibrary["alpha"] = (_alpha_,
                             "The prospector-alpha model, Leja et al. 2017")
-
-
-# ----------------------------
-# --- Prospector-beta ---
-# ----------------------------
-
-_beta_nzsfh_ = TemplateLibrary["alpha"]
-_beta_nzsfh_.pop('z_fraction', None)
-_beta_nzsfh_.pop('total_mass', None)
-
-nbins_sfh = 7 # number of sfh bins
-_beta_nzsfh_['nzsfh'] = {'N': nbins_sfh+2, 'isfree': True, 'init': np.concatenate([[0.5,8,0.0], np.zeros(nbins_sfh-1)]),
-                         'prior': priors_beta.NzSFH(zred_mini=1e-3, zred_maxi=15.0,
-                                                    mass_mini=7.0, mass_maxi=12.5,
-                                                    z_mini=-1.98, z_maxi=0.19,
-                                                    logsfr_ratio_mini=-5.0, logsfr_ratio_maxi=5.0,
-                                                    logsfr_ratio_tscale=0.3, nbins_sfh=nbins_sfh,
-                                                    const_phi=True)}
-
-_beta_nzsfh_['zred'] = {'N': 1, 'isfree': False, 'init': 0.5,
-                        'depends_on': transforms.nzsfh_to_zred}
-
-_beta_nzsfh_['logmass'] = {'N': 1, 'isfree': False, 'init': 8.0, 'units': 'Msun',
-                           'depends_on': transforms.nzsfh_to_logmass}
-
-_beta_nzsfh_['logzsol'] = {'N': 1, 'isfree': False, 'init': -0.5, 'units': r'$\log (Z/Z_\odot)$',
-                           'depends_on': transforms.nzsfh_to_logzsol}
-
-# --- SFH ---
-_beta_nzsfh_["sfh"] = {'N': 1, 'isfree': False, 'init': 3}
-
-_beta_nzsfh_['logsfr_ratios'] = {'N': nbins_sfh-1, 'isfree': False, 'init': 0.0,
-                                 'depends_on': transforms.nzsfh_to_logsfr_ratios}
-
-_beta_nzsfh_["mass"] = {'N': nbins_sfh, 'isfree': False, 'init': 1e6, 'units': r'M$_\odot$',
-                        'depends_on': transforms.logsfr_ratios_to_masses}
-
-_beta_nzsfh_['agebins'] = {'N': nbins_sfh, 'isfree': False,
-                           'init': transforms.zred_to_agebins_pbeta(np.atleast_1d(0.5), np.zeros(nbins_sfh)),
-                           'depends_on': transforms.zred_to_agebins_pbeta}
-
-TemplateLibrary["beta"] = (_beta_nzsfh_,
-                           "The prospector-beta model; Wang, Leja, et al. 2023")
diff --git a/prospect/models/transforms.py b/prospect/models/transforms.py
index 7563e78d..c2d7ba26 100755
--- a/prospect/models/transforms.py
+++ b/prospect/models/transforms.py
@@ -10,6 +10,8 @@
 
 import numpy as np
 from ..sources.constants import cosmo
+from gp_sfh import *
+import gp_sfh_kernels
 
 __all__ = ["stellar_logzsol", "delogify_mass",
            "tburst_from_fage", "tage_from_tuniv", "zred_to_agebins",
@@ -17,10 +19,7 @@
            "logsfr_ratios_to_masses", "logsfr_ratios_to_sfrs",
            "logsfr_ratios_to_masses_flex", "logsfr_ratios_to_agebins",
            "zfrac_to_masses", "zfrac_to_sfrac", "zfrac_to_sfr", "masses_to_zfrac",
-           "sfratio_to_sfr", "sfratio_to_mass",
-           "zred_to_agebins_pbeta",
-           "zredmassmet_to_zred", "zredmassmet_to_logmass", "zredmassmet_to_mass", "zredmassmet_to_logzsol",
-           "nzsfh_to_zred", "nzsfh_to_logmass", "nzsfh_to_mass", "nzsfh_to_logzsol", "nzsfh_to_logsfr_ratios"]
+           "sfratio_to_sfr", "sfratio_to_mass", "get_sfr_covar", "sfr_covar_to_sfr_ratio_covar"]
 
 
 # --------------------------------------
@@ -184,7 +183,7 @@ def logsfr_ratios_to_masses(logmass=None, logsfr_ratios=None, agebins=None,
     time.
     """
     nbins = agebins.shape[0]
-    sratios = 10**np.clip(logsfr_ratios, -10, 10)  # numerical issues...
+    sratios = 10**np.clip(logsfr_ratios, -100, 100)  # numerical issues...
     dt = (10**agebins[:, 1] - 10**agebins[:, 0])
     coeffs = np.array([ (1. / np.prod(sratios[:i])) * (np.prod(dt[1: i+1]) / np.prod(dt[: i]))
                         for i in range(nbins)])
@@ -209,8 +208,8 @@ def logsfr_ratios_to_sfrs(logmass=None, logsfr_ratios=None, agebins=None, **extr
 def logsfr_ratios_to_masses_flex(logmass=None, logsfr_ratios=None,
                                  logsfr_ratio_young=None, logsfr_ratio_old=None,
                                  **extras):
-    logsfr_ratio_young = np.clip(logsfr_ratio_young, -10, 10)
-    logsfr_ratio_old = np.clip(logsfr_ratio_old, -10, 10)
+    logsfr_ratio_young = np.clip(logsfr_ratio_young, -100, 100)
+    logsfr_ratio_old = np.clip(logsfr_ratio_old, -100, 100)
 
     abins = logsfr_ratios_to_agebins(logsfr_ratios=logsfr_ratios, **extras)
 
@@ -236,7 +235,7 @@ def logsfr_ratios_to_agebins(logsfr_ratios=None, agebins=None, **extras):
     """
 
     # numerical stability
-    logsfr_ratios = np.clip(logsfr_ratios, -10, 10)
+    logsfr_ratios = np.clip(logsfr_ratios, -100, 100)
 
     # calculate delta(t) for oldest, youngest bins (fixed)
     lower_time = (10**agebins[0, 1] - 10**agebins[0, 0])
@@ -490,68 +489,52 @@ def sfratio_to_sfr(sfr_ratio=None, sfr0=None, **extras):
 
 def sfratio_to_mass(sfr_ratio=None, sfr0=None, agebins=None, **extras):
     raise(NotImplementedError)
-
-
+    
+    
 # --------------------------------------
-# --- Transforms for prospector-beta ---
+# --- Transforms for stochastic SFH prior ---
 # --------------------------------------
 
-def zred_to_agebins_pbeta(zred=None, agebins=[], **extras):
-    """New agebin scheme, refined so that none of the bins is overly wide when the universe is young.
-
-    Parameters
-    ----------
-    zred : float
-        Cosmological redshift.  This sets the age of the universe.
-
-    agebins :  ndarray of shape ``(nbin, 2)``
-        The SFH bin edges in log10(years).
-
+def get_sfr_covar(psd_params, agebins=[], **extras):
+    
+    """
+    Caluclates SFR covariance matrix for a given set of PSD parameters and agebins
+    PSD parameters must be in the order: [sigma_reg, tau_eq, tau_in, sigma_dyn, tau_dyn]
+    
     Returns
     -------
-    agebins : ndarray of shape ``(nbin, 2)``
-        The new SFH bin edges.
+    covar_matrix: (Nbins, Nbins)-dim array of covariance values for SFR
     """
-    amin = 7.1295
-    nbins_sfh = len(agebins)
-    tuniv = cosmo.age(zred)[0].value*1e9 # because input zred is atleast_1d
-    tbinmax = (tuniv*0.9)
-    if (zred <= 3.):
-        agelims = [0.0,7.47712] + np.linspace(8.0,np.log10(tbinmax),nbins_sfh-2).tolist() + [np.log10(tuniv)]
-    else:
-        agelims = np.linspace(amin,np.log10(tbinmax),nbins_sfh).tolist() + [np.log10(tuniv)]
-        agelims[0] = 0
-
-    agebins = np.array([agelims[:-1], agelims[1:]])
-    return agebins.T
-
-# separates a theta vector of [zred, mass, met] into individual parameters
-# can be used with PhiMet & ZredMassMet
-def zredmassmet_to_zred(zredmassmet=None, **extras):
-    return zredmassmet[0]
-
-def zredmassmet_to_logmass(zredmassmet=None, **extras):
-    return zredmassmet[1]
-
-def zredmassmet_to_mass(zredmassmet=None, **extras):
-    return 10**zredmassmet[1]
-
-def zredmassmet_to_logzsol(zredmassmet=None, **extras):
-    return zredmassmet[2]
-
-# separates a theta vector of [zred, mass, met, logsfr_ratios] into individual parameters
-# can be used with PhiSFH & NzSFH
-def nzsfh_to_zred(nzsfh=None, **extras):
-    return nzsfh[0]
-
-def nzsfh_to_logmass(nzsfh=None, **extras):
-    return nzsfh[1]
-
-def nzsfh_to_mass(nzsfh=None, **extras):
-    return 10**nzsfh[1]
-
-def nzsfh_to_logzsol(nzsfh=None, **extras):
-    return nzsfh[2]
-
-def nzsfh_to_logsfr_ratios(nzsfh=None, **extras):
-    return nzsfh[3:]
+    
+    bincenters = np.array([np.mean(agebins[i]) for i in range(len(agebins))])
+    bincenters = (10**bincenters)/1e9
+    case1 = simple_GP_sfh()
+    case1.tarr = bincenters
+    case1.kernel = gp_sfh_kernels.extended_regulator_model_kernel_paramlist
+    covar_matrix = case1.get_covariance_matrix(kernel_params = psd_params, show_prog=False)
+    
+    return covar_matrix
+
+
+def sfr_covar_to_sfr_ratio_covar(covar_matrix):
+    
+    """
+    Caluclates log SFR ratio covariance matrix from SFR covariance matrix
+    
+    Returns
+    -------
+    sfr_ratio_covar: (Nbins-1, Nbins-1)-dim array of covariance values for log SFR
+    """
+    
+    dim = covar_matrix.shape[0]
+    
+    sfr_ratio_covar = []
+    
+    for i in range(dim-1):
+        row = []
+        for j in range(dim-1):
+            cov = covar_matrix[i][j] - covar_matrix[i+1][j] - covar_matrix[i][j+1] + covar_matrix[i+1][j+1]
+            row.append(cov)
+        sfr_ratio_covar.append(row)
+    
+    return np.array(sfr_ratio_covar)

From c0a9dbbb5ad2a51567304c5fe631f6f413fcefca Mon Sep 17 00:00:00 2001
From: Jenny Wan <jtw.cpc@gmail.com>
Date: Sun, 17 Mar 2024 21:29:16 -0700
Subject: [PATCH 061/132] Added stochastic prior to SFH models

---
 prospect/models/priors.py     | 258 +++++++++++++++++++++++++++++++++-
 prospect/models/templates.py  |  47 +++++++
 prospect/models/transforms.py |  82 ++++++++++-
 3 files changed, 381 insertions(+), 6 deletions(-)

diff --git a/prospect/models/priors.py b/prospect/models/priors.py
index a04a7785..cd149a2a 100644
--- a/prospect/models/priors.py
+++ b/prospect/models/priors.py
@@ -8,10 +8,15 @@
 
 import numpy as np
 import scipy.stats
+from scipy.special import erf, erfinv
+
 
 __all__ = ["Prior", "Uniform", "TopHat", "Normal", "MultiVariateNormal", "ClippedNormal",
            "LogNormal", "LogUniform", "Beta",
-           "StudentT", "SkewNormal"]
+           "StudentT", "SkewNormal",
+           "FastUniform", "FastTruncatedNormal",
+           "FastTruncatedEvenStudentTFreeDeg2",
+           "FastTruncatedEvenStudentTFreeDeg2Scalar"]
 
 
 class Prior(object):
@@ -581,3 +586,254 @@ def range(self):
 
     def bounds(self, **kwargs):
         return (-np.inf, np.inf)
+
+
+# fast versions to the above priors
+# essentially rewriting the numpy/scipy functions
+
+# A faster uniform distribution. Give it a lower bound `a` and
+# an upper bound `b`.
+class FastUniform(Prior):
+
+    prior_params = ['a', 'b']
+
+    def __init__(self, a=0.0, b=1.0, parnames=[], name='', ):
+        if len(parnames) == 0:
+            parnames = self.prior_params
+        assert len(parnames) == len(self.prior_params)
+
+        self.alias = dict(zip(self.prior_params, parnames))
+        self.params = {}
+
+        self.name = name
+
+        self.a, self.b = a, b
+
+        if self.b <= self.a:
+            raise ValueError('b must be greater than a')
+
+        self.diffthing = b - a
+        self.pdfval = 1.0 / (b - a)
+        self.logpdfval = np.log(self.pdfval)
+
+    def __len__(self):
+        return 1
+
+    def __call__(self, x):
+        if not hasattr(x, "__len__"):
+            if self.a <= x <= self.b:
+                return self.logpdfval
+            else:
+                return np.NINF
+        else:
+            return [self.logpdfval if (self.a <= xi <= self.b) else np.NINF for xi in x]
+
+    def scale(self):
+        return 0.5 * self.diffthing
+
+    def loc(self):
+        return 0.5 * (self.a + self.b)
+
+    def unit_transform(self, x):
+        return (x * self.diffthing) + self.a
+
+    def sample(self):
+        return self.unit_transform(np.random.rand())
+
+
+# A faster truncated normal distribution. Give it a lower bound `a`,
+# a upper bound `b`, a mean `mu`, and a standard deviation `sig`.
+class FastTruncatedNormal(Prior):
+
+    prior_params = ['a', 'b', 'mu', 'sig']
+
+    def __init__(self, a=-1.0, b=1.0, mu=0.0, sig=1.0, parnames=[], name='', ):
+        if len(parnames) == 0:
+            parnames = self.prior_params
+        assert len(parnames) == len(self.prior_params)
+
+        self.alias = dict(zip(self.prior_params, parnames))
+        self.params = {}
+
+        self.name = name
+
+        self.a, self.b, self.mu, self.sig = a, b, mu, sig
+
+        if self.b <= self.a:
+            raise ValueError('b must be greater than a')
+
+        self.alpha = (self.a - self.mu) / self.sig
+        self.beta = (self.b - self.mu) / self.sig
+
+        self.A = erf(self.alpha / np.sqrt(2.0))
+        self.B = erf(self.beta / np.sqrt(2.0))
+
+    def xi(self, x):
+        return (x - self.mu) / self.sig
+
+    def phi(self, x):
+        return np.sqrt(2.0 / (self.sig**2.0 * np.pi)) * np.exp(-0.5 * self.xi(x)**2.0)
+
+    def __len__(self):
+        return 1
+
+    def __call__(self, x):
+        # if self.a <= x <= self.b:
+        #     return np.log(self.phi(x) / (self.B - self.A))
+        # else:
+        #     return np.NINF
+        if not hasattr(x, "__len__"):
+            if self.a <= x <= self.b:
+                return np.log(self.phi(x) / (self.B - self.A))
+            else:
+                np.NINF
+        else:
+            return [np.log(self.phi(xi) / (self.B - self.A)) if (self.a <= xi <= self.b) else np.NINF for xi in x]
+
+    def scale(self):
+        return self.sig
+
+    def loc(self):
+        return self.mu
+
+    def unit_transform(self, x):
+        return self.sig * np.sqrt(2.0) * erfinv((self.B - self.A) * x + self.A) + self.mu
+
+    def sample(self):
+        return self.unit_transform(np.random.rand())
+
+
+# Okay. This is a sort of Student's t-distribution that allows
+# for truncation and rescaling, but it requires nu = 2 and mu = 0
+# and for the truncation limits to be equidistant from mu. Give it
+# the half-width of truncation (i.e. if you want it truncated to the
+# domain (-5, 5), give it `hw = 5`) and the rescaled standard
+# devation `sig`.
+class FastTruncatedEvenStudentTFreeDeg2(Prior):
+
+    prior_params = ['hw', 'sig']
+
+    def __init__(self, hw=0.0, sig=1.0, parnames=[], name='', ):
+        if len(parnames) == 0:
+            parnames = self.prior_params
+        assert len(parnames) == len(self.prior_params)
+
+        self.alias = dict(zip(self.prior_params, parnames))
+        self.params = {}
+
+        self.name = name
+
+        self.hw, self.sig = hw, sig
+
+        if np.any(self.hw <= 0.0):
+            raise ValueError('hw must be greater than 0.0')
+
+        if np.any(self.sig <= 0.0):
+            raise ValueError('sig must be greater than 0.0')
+
+        self.const1 = np.sqrt(1.0 + 0.5*(self.hw**2.0))
+        self.const2 = 2.0 * self.sig * self.hw
+        self.const3 = self.const2**2.0
+        self.const4 = 2.0 * (self.hw**2.0)
+
+    def __len__(self):
+        return len(self.hw)
+
+    def __call__(self, x):
+        if not hasattr(x, "__len__"):
+            if np.abs(x) <= self.hw:
+                return np.log(self.const1 / (self.const2 * (1 + 0.5*(x / self.sig)**2.0)**1.5))
+            else:
+                return np.NINF
+        else:
+            ret = np.log(self.const1 / (self.const2 * (1 + 0.5*(x / self.sig)**2.0)**1.5))
+            bad = np.abs(x) > self.hw
+            ret[bad] = np.NINF
+            return ret
+
+    def scale(self):
+        return self.sig
+
+    def loc(self):
+        return 0.0
+
+    def invcdf_numerator(self, x):
+        return -1.0 * (self.const3 * x**2.0 - self.const3 * x + (self.sig * self.hw)**2.0)
+
+    def invcdf_denominator(self, x):
+        return self.const4 * x**2.0 - self.const4 * x - self.sig**2.0
+
+    def unit_transform(self, x):
+        f = (((x > 0.5) & (x <= 1.0)) * np.sqrt(self.invcdf_numerator(x) / self.invcdf_denominator(x)) -
+             ((x >= 0.0) & (x <= 0.5)) * np.sqrt(self.invcdf_numerator(x) / self.invcdf_denominator(x)))
+        return f
+
+    def sample(self):
+        return self.unit_transform(np.random.rand())
+
+
+# Okay. This is a sort of Student's t-distribution that allows
+# for truncation and rescaling, but it requires nu = 2 and mu = 0
+# and for the truncation limits to be equidistant from mu. Give it
+# the half-width of truncation (i.e. if you want it truncated to the
+# domain (-5, 5), give it `hw = 5`) and the rescaled standard
+# devation `sig`.
+class FastTruncatedEvenStudentTFreeDeg2Scalar(Prior):
+
+    prior_params = ['hw', 'sig']
+
+    def __init__(self, hw=0.0, sig=1.0, parnames=[], name='', ):
+        if len(parnames) == 0:
+            parnames = self.prior_params
+        assert len(parnames) == len(self.prior_params)
+
+        self.alias = dict(zip(self.prior_params, parnames))
+        self.params = {}
+
+        self.name = name
+
+        self.hw, self.sig = hw, sig
+
+        if self.hw <= 0.0:
+            raise ValueError('hw must be greater than 0.0')
+
+        if self.sig <= 0.0:
+            raise ValueError('sig must be greater than 0.0')
+
+        self.const1 = np.sqrt(1.0 + 0.5*(self.hw**2.0))
+        self.const2 = 2.0 * self.sig * self.hw
+        self.const3 = self.const2**2.0
+        self.const4 = 2.0 * (self.hw**2.0)
+
+    def __len__(self):
+        return 1
+
+    def __call__(self, x):
+        if not hasattr(x, "__len__"):
+            if np.abs(x) <= self.hw:
+                return np.log(self.const1 / (self.const2 * (1 + 0.5*(x / self.sig)**2.0)**1.5))
+            else:
+                return np.NINF
+        else:
+            return [np.log(self.const1 / (self.const2 * (1 + 0.5*(xi / self.sig)**2.0)**1.5)) if np.abs(xi) <= self.hw else np.NINF for xi in x]
+
+    def scale(self):
+        return self.sig
+
+    def loc(self):
+        return 0.0
+
+    def invcdf_numerator(self, x):
+        return -1.0 * (self.const3 * x**2.0 - self.const3 * x + (self.sig * self.hw)**2.0)
+
+    def invcdf_denominator(self, x):
+        return self.const4 * x**2.0 - self.const4 * x - self.sig**2.0
+
+    def unit_transform(self, x):
+        if 0.0 <= x <= 0.5:
+            return -1.0 * np.sqrt(self.invcdf_numerator(x) / self.invcdf_denominator(x))
+        elif 0.5 < x <= 1.0:
+            return np.sqrt(self.invcdf_numerator(x) / self.invcdf_denominator(x))
+
+    def sample(self):
+        return self.unit_transform(np.random.rand())
\ No newline at end of file
diff --git a/prospect/models/templates.py b/prospect/models/templates.py
index 2a57bd81..dd188a3e 100755
--- a/prospect/models/templates.py
+++ b/prospect/models/templates.py
@@ -9,6 +9,7 @@
 import numpy as np
 import os
 from . import priors
+from . import priors_beta
 from . import transforms
 
 __all__ = ["TemplateLibrary",
@@ -305,6 +306,9 @@ def adjust_stochastic_params(parset, tuniv=13.7):
                      delimiter=',')
 except OSError:
     info = {'name':[]}
+except TypeError:
+    # SPS_HOME not defined
+    info = {'name':[]}
 
 # Fit all lines by default
 elines_to_fit = {'N': 1, 'isfree': False, 'init': np.array(info['name'])}
@@ -764,3 +768,46 @@ def adjust_stochastic_params(parset, tuniv=13.7):
 
 TemplateLibrary["alpha"] = (_alpha_,
                             "The prospector-alpha model, Leja et al. 2017")
+
+
+# ----------------------------
+# --- Prospector-beta ---
+# ----------------------------
+
+_beta_nzsfh_ = TemplateLibrary["alpha"]
+_beta_nzsfh_.pop('z_fraction', None)
+_beta_nzsfh_.pop('total_mass', None)
+
+nbins_sfh = 7 # number of sfh bins
+_beta_nzsfh_['nzsfh'] = {'N': nbins_sfh+2, 'isfree': True, 'init': np.concatenate([[0.5,8,0.0], np.zeros(nbins_sfh-1)]),
+                         'prior': priors_beta.NzSFH(zred_mini=1e-3, zred_maxi=15.0,
+                                                    mass_mini=7.0, mass_maxi=12.5,
+                                                    z_mini=-1.98, z_maxi=0.19,
+                                                    logsfr_ratio_mini=-5.0, logsfr_ratio_maxi=5.0,
+                                                    logsfr_ratio_tscale=0.3, nbins_sfh=nbins_sfh,
+                                                    const_phi=True)}
+
+_beta_nzsfh_['zred'] = {'N': 1, 'isfree': False, 'init': 0.5,
+                        'depends_on': transforms.nzsfh_to_zred}
+
+_beta_nzsfh_['logmass'] = {'N': 1, 'isfree': False, 'init': 8.0, 'units': 'Msun',
+                           'depends_on': transforms.nzsfh_to_logmass}
+
+_beta_nzsfh_['logzsol'] = {'N': 1, 'isfree': False, 'init': -0.5, 'units': r'$\log (Z/Z_\odot)$',
+                           'depends_on': transforms.nzsfh_to_logzsol}
+
+# --- SFH ---
+_beta_nzsfh_["sfh"] = {'N': 1, 'isfree': False, 'init': 3}
+
+_beta_nzsfh_['logsfr_ratios'] = {'N': nbins_sfh-1, 'isfree': False, 'init': 0.0,
+                                 'depends_on': transforms.nzsfh_to_logsfr_ratios}
+
+_beta_nzsfh_["mass"] = {'N': nbins_sfh, 'isfree': False, 'init': 1e6, 'units': r'M$_\odot$',
+                        'depends_on': transforms.logsfr_ratios_to_masses}
+
+_beta_nzsfh_['agebins'] = {'N': nbins_sfh, 'isfree': False,
+                           'init': transforms.zred_to_agebins_pbeta(np.atleast_1d(0.5), np.zeros(nbins_sfh)),
+                           'depends_on': transforms.zred_to_agebins_pbeta}
+
+TemplateLibrary["beta"] = (_beta_nzsfh_,
+                           "The prospector-beta model; Wang, Leja, et al. 2023")
\ No newline at end of file
diff --git a/prospect/models/transforms.py b/prospect/models/transforms.py
index c2d7ba26..ae505c05 100755
--- a/prospect/models/transforms.py
+++ b/prospect/models/transforms.py
@@ -13,13 +13,17 @@
 from gp_sfh import *
 import gp_sfh_kernels
 
+
 __all__ = ["stellar_logzsol", "delogify_mass",
            "tburst_from_fage", "tage_from_tuniv", "zred_to_agebins",
            "dustratio_to_dust1",
            "logsfr_ratios_to_masses", "logsfr_ratios_to_sfrs",
            "logsfr_ratios_to_masses_flex", "logsfr_ratios_to_agebins",
            "zfrac_to_masses", "zfrac_to_sfrac", "zfrac_to_sfr", "masses_to_zfrac",
-           "sfratio_to_sfr", "sfratio_to_mass", "get_sfr_covar", "sfr_covar_to_sfr_ratio_covar"]
+           "sfratio_to_sfr", "sfratio_to_mass", "get_sfr_covar", "sfr_covar_to_sfr_ratio_covar",
+           "zred_to_agebins_pbeta",
+           "zredmassmet_to_zred", "zredmassmet_to_logmass", "zredmassmet_to_mass", "zredmassmet_to_logzsol",
+           "nzsfh_to_zred", "nzsfh_to_logmass", "nzsfh_to_mass", "nzsfh_to_logzsol", "nzsfh_to_logsfr_ratios"]
 
 
 # --------------------------------------
@@ -183,7 +187,8 @@ def logsfr_ratios_to_masses(logmass=None, logsfr_ratios=None, agebins=None,
     time.
     """
     nbins = agebins.shape[0]
-    sratios = 10**np.clip(logsfr_ratios, -100, 100)  # numerical issues...
+    sratios = 10**np.clip(logsfr_ratios, -10, 10)  # numerical issues...
+    #sratios = 10**np.clip(logsfr_ratios, -100, 100)  # numerical issues...
     dt = (10**agebins[:, 1] - 10**agebins[:, 0])
     coeffs = np.array([ (1. / np.prod(sratios[:i])) * (np.prod(dt[1: i+1]) / np.prod(dt[: i]))
                         for i in range(nbins)])
@@ -208,8 +213,10 @@ def logsfr_ratios_to_sfrs(logmass=None, logsfr_ratios=None, agebins=None, **extr
 def logsfr_ratios_to_masses_flex(logmass=None, logsfr_ratios=None,
                                  logsfr_ratio_young=None, logsfr_ratio_old=None,
                                  **extras):
-    logsfr_ratio_young = np.clip(logsfr_ratio_young, -100, 100)
-    logsfr_ratio_old = np.clip(logsfr_ratio_old, -100, 100)
+    logsfr_ratio_young = np.clip(logsfr_ratio_young, -10, 10)
+    logsfr_ratio_old = np.clip(logsfr_ratio_old, -10, 10)
+    #logsfr_ratio_young = np.clip(logsfr_ratio_young, -100, 100)
+    #logsfr_ratio_old = np.clip(logsfr_ratio_old, -100, 100)
 
     abins = logsfr_ratios_to_agebins(logsfr_ratios=logsfr_ratios, **extras)
 
@@ -235,7 +242,8 @@ def logsfr_ratios_to_agebins(logsfr_ratios=None, agebins=None, **extras):
     """
 
     # numerical stability
-    logsfr_ratios = np.clip(logsfr_ratios, -100, 100)
+    logsfr_ratios = np.clip(logsfr_ratios, -10, 10)
+    #logsfr_ratios = np.clip(logsfr_ratios, -100, 100)
 
     # calculate delta(t) for oldest, youngest bins (fixed)
     lower_time = (10**agebins[0, 1] - 10**agebins[0, 0])
@@ -489,6 +497,70 @@ def sfratio_to_sfr(sfr_ratio=None, sfr0=None, **extras):
 
 def sfratio_to_mass(sfr_ratio=None, sfr0=None, agebins=None, **extras):
     raise(NotImplementedError)
+
+
+# --------------------------------------
+# --- Transforms for prospector-beta ---
+# --------------------------------------
+
+def zred_to_agebins_pbeta(zred=None, agebins=[], **extras):
+    """New agebin scheme, refined so that none of the bins is overly wide when the universe is young.
+    
+    Parameters
+    ----------
+    zred : float
+        Cosmological redshift.  This sets the age of the universe.
+    agebins :  ndarray of shape ``(nbin, 2)``
+        The SFH bin edges in log10(years).
+    
+    Returns
+    -------
+    agebins : ndarray of shape ``(nbin, 2)``
+        The new SFH bin edges.
+    """
+    amin = 7.1295
+    nbins_sfh = len(agebins)
+    tuniv = cosmo.age(zred)[0].value*1e9 # because input zred is atleast_1d
+    tbinmax = (tuniv*0.9)
+    if (zred <= 3.):
+        agelims = [0.0,7.47712] + np.linspace(8.0,np.log10(tbinmax),nbins_sfh-2).tolist() + [np.log10(tuniv)]
+    else:
+        agelims = np.linspace(amin,np.log10(tbinmax),nbins_sfh).tolist() + [np.log10(tuniv)]
+        agelims[0] = 0
+        
+    agebins = np.array([agelims[:-1], agelims[1:]])
+    return agebins.T
+
+# separates a theta vector of [zred, mass, met] into individual parameters
+# can be used with PhiMet & ZredMassMet
+def zredmassmet_to_zred(zredmassmet=None, **extras):
+    return zredmassmet[0]
+
+def zredmassmet_to_logmass(zredmassmet=None, **extras):
+    return zredmassmet[1]
+
+def zredmassmet_to_mass(zredmassmet=None, **extras):
+    return 10**zredmassmet[1]
+
+def zredmassmet_to_logzsol(zredmassmet=None, **extras):
+    return zredmassmet[2]
+
+# separates a theta vector of [zred, mass, met, logsfr_ratios] into individual parameters
+# can be used with PhiSFH & NzSFH
+def nzsfh_to_zred(nzsfh=None, **extras):
+    return nzsfh[0]
+
+def nzsfh_to_logmass(nzsfh=None, **extras):
+    return nzsfh[1]
+
+def nzsfh_to_mass(nzsfh=None, **extras):
+    return 10**nzsfh[1]
+
+def nzsfh_to_logzsol(nzsfh=None, **extras):
+    return nzsfh[2]
+
+def nzsfh_to_logsfr_ratios(nzsfh=None, **extras):
+    return nzsfh[3:]
     
     
 # --------------------------------------

From cdd61e9a45b765429254adf60917d5a596bef852 Mon Sep 17 00:00:00 2001
From: Jenny Wan <jtw.cpc@gmail.com>
Date: Tue, 19 Mar 2024 11:14:20 -0700
Subject: [PATCH 062/132] Add files via upload

---
 prospect/models/gp_sfh.py         | 638 ++++++++++++++++++++++++++++++
 prospect/models/gp_sfh_kernels.py | 233 +++++++++++
 2 files changed, 871 insertions(+)
 create mode 100644 prospect/models/gp_sfh.py
 create mode 100644 prospect/models/gp_sfh_kernels.py

diff --git a/prospect/models/gp_sfh.py b/prospect/models/gp_sfh.py
new file mode 100644
index 00000000..282a17b8
--- /dev/null
+++ b/prospect/models/gp_sfh.py
@@ -0,0 +1,638 @@
+# main functions for the GP-SFH module.
+# contents:
+#   class simple_GP_sfh()
+
+import numpy as np
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+import scipy.special as ssp
+import fsps
+
+from astropy.cosmology import FlatLambdaCDM
+cosmo = FlatLambdaCDM(H0=70, Om0=0.3)
+
+import seaborn as sns
+sns.set(font_scale=1.8)
+sns.set_style('white')
+
+try:
+    import fsps
+except:
+    print('Failed to load FSPS. Install if spectral generation modules are needed.')
+
+def ujy_to_flam(data,lam):
+    flam = ((3e-5)*data)/((lam**2.)*(1e6))
+    return flam/1e-19
+
+def get_sigma_GMC_scale(sigma=1.0, tau_eq = 1.0, tau_in = 0.5, sigma_gmc = 0.01, tau_gmc = 0.001):
+    """
+    function to calculate relative GMC burstiness factoring in timescale effects
+    """
+
+    C0_norm_reg = sigma**2 / (tau_in + tau_eq)
+    C0_norm_gmc = sigma_gmc**2 / (2*tau_gmc)
+
+    effective_sigma_gmc_ratio = np.sqrt(C0_norm_gmc / C0_norm_reg)
+
+    return effective_sigma_gmc_ratio
+
+# Creating a base class that simplifies a lot of things.
+# The way this is set up, you can pass a kernel as an argument
+# to compute the covariance matrix and draw samples from it.
+class simple_GP_sfh():
+
+    """
+    A class that creates and holds information about a specific
+    kernel, and can generate samples from it.
+
+    Attributes
+    ----------
+    tarr: fiducial time array used to draw samples
+    kernel: accepts an input function as an argument,
+        of the format:
+
+            def kernel_function(delta_t, **kwargs):
+                ... function interior ...
+                return kernel_val[array of len(delta_t)]
+
+    Methods
+    -------
+    get_covariance_matrix
+        [although this has double for loops for maximum flexibility
+        with generic kernel functions, it only has to be computed once,
+        which makes drawing random samples super fast once it's computed.]
+    sample_kernel
+    plot_samples
+    plot_kernel
+    [to-do] condition on data
+
+    """
+
+    def __init__(self, sp = 'none', cosmo = cosmo, zval = 0.1):
+
+
+        self.kernel = []
+        self.covariance_matrix = []
+        self.zval = zval
+        self.sp = sp
+        self.cosmo = cosmo
+        self.get_t_univ()
+        self.get_tarr()
+
+    def init_SPS():
+
+        mocksp = fsps.StellarPopulation(compute_vega_mags=False, zcontinuous=1,sfh=0, imf_type=1, logzsol=0.0, dust_type=2, dust2=0.0, add_neb_emission=True)
+        self.sp = mocksp
+        return
+
+    def make_MS_SFH(self, Mseed, timeax = np.arange(0,cosmo.age(0.0).value, 1e-3)):
+
+        # following the right skew peak function parametrization from Ciesla+17
+        # www.arxiv.org/pdf/1706.08531.pdf
+
+        # Mseed [int] is the seed mass of the SFH at z=5
+        # timeax [int, array] is any array of times along which the SFH is computed
+
+        Ap = 6e-3
+        taup = -0.84
+        A = Ap*np.exp(-np.log10(Mseed)/taup)
+
+        Ap = 47.39
+        taup = 3.12
+        mu = Ap*np.exp(-np.log10(Mseed)/taup)
+
+        Ap = 17.08
+        taup = 2.96
+        sigma = Ap*np.exp(-np.log10(Mseed)/taup)
+
+        slope = -0.56
+        norm = 7.03
+        rs = slope*np.log10(Mseed) + norm
+
+        sfh = A * (np.pi/2) * (sigma) * np.exp( -((timeax-mu)/rs) + (sigma/(2*rs))**2) * ssp.erfc( (sigma/(2*rs)) - ((timeax-mu)/sigma))
+        sfh[np.isnan(sfh)] = 1e-10
+        return sfh
+
+
+    def get_basesfh(self, sfhtype='const', mstar = None, mstar_seed = None):
+
+        if sfhtype == 'const':
+            self.basesfh = np.ones_like(self.tarr)* 1.0
+        elif sfhtype == 'MS':
+            sfh = self.make_MS_SFH(10**mstar_seed, self.tarr)
+            mtot = (np.trapz(x= self.tarr*1e9, y = sfh)*0.6)
+            sfh = sfh*(10**mstar)/mtot
+            if np.sum(sfh) == 0:
+                print(mstar, mstar_seed)
+            self.basesfh = np.log10(sfh)
+        else:
+            print('unknown basesfh type. set yourself with len of tarr.')
+        return
+
+
+    def get_t_univ(self):
+
+        self.t_univ = self.cosmo.age(self.zval).value
+        return
+
+    def get_tarr(self, n_tarr = 1000):
+
+        self.get_t_univ()
+        if n_tarr > 1:
+            self.tarr = np.linspace(0,self.t_univ, n_tarr)
+        elif n_tarr < 1:
+            self.tarr = np.arange(0,self.t_univ, n_tarr)
+        else:
+            raise('Undefined n_tarr: expected int or float.')
+        return
+
+
+    def get_covariance_matrix(self, show_prog = True, **kwargs):
+        """
+        Evaluate covariance matrix with a particular kernel
+        """
+
+        cov_matrix = np.zeros((len(self.tarr),len(self.tarr)))
+
+        if show_prog == True:
+            iterrange = tqdm(range(len(cov_matrix)))
+        else:
+            iterrange = range(len(cov_matrix))
+        for i in iterrange:
+            for j in range(len(cov_matrix)):
+                    cov_matrix[i,j] = self.kernel(self.tarr[i] - self.tarr[j], **kwargs)
+
+        return cov_matrix
+
+    def get_covariance_matrix_timedep(self, show_prog = True, **kwargs):
+        """
+        Evaluate covariance matrix with a particular kernel (NONSTATIONARY)
+        """
+
+        cov_matrix = np.zeros((len(self.tarr),len(self.tarr)))
+        if show_prog == True:
+            iterrange = tqdm(range(len(cov_matrix)))
+        else:
+            iterrange = range(len(cov_matrix))
+        for i in iterrange:
+            for j in range(len(cov_matrix)):
+                    cov_matrix[i,j] = self.kernel(self.tarr[i], self.tarr[j], **kwargs)
+
+        return cov_matrix
+
+    def sample_kernel(self, nsamp = 100, random_seed = 42, force_cov=False, stationary = True, show_prog = True, **kwargs):
+
+        mean_array = np.zeros_like(self.tarr)
+        if (len(self.covariance_matrix) == 0) or (force_cov == True):
+            if stationary == True:
+                self.covariance_matrix = self.get_covariance_matrix(show_prog = show_prog, **kwargs)
+            else:
+                self.covariance_matrix = self.get_covariance_matrix_timedep(show_prog = show_prog, **kwargs)
+#         else:
+#             print('using precomputed covariance matrix')
+
+        np.random.seed(random_seed)
+        samples = np.random.multivariate_normal(mean_array,self.covariance_matrix,size=nsamp)
+
+        return samples
+
+    def get_spec(self, nsamp, show_prog = False, calc_bands = True):
+
+        bands = fsps.list_filters()
+        filter_wavelengths = [fsps.filters.get_filter(bands[i]).lambda_eff for i in range(len(bands))]
+
+        all_lam, all_spec, all_spec_massnorm, all_mstar, all_emline_wav, all_emline_lum, all_emline_lum_massnorm, all_filtmags = [], [], [], [], [], [], [], []
+
+        if show_prog == True:
+            iterrange = tqdm(range(nsamp))
+        else:
+            iterrange = range(nsamp)
+        for i in iterrange:
+
+            specsfh = 10**(self.basesfh+self.samples[i, 0:])
+            if np.sum(specsfh) > 0:
+
+                self.sp.set_tabular_sfh(self.tarr, specsfh)
+                lam, spec = self.sp.get_spectrum(tage = self.t_univ)
+                mstar = self.sp.stellar_mass
+                if calc_bands == True:
+                    bandmags = self.sp.get_mags(tage = self.cosmo.age(self.zval).value, redshift = self.zval, bands = bands)
+
+                all_lam.append(lam)
+                all_spec.append(spec)
+                all_spec_massnorm.append(spec/mstar)
+                all_mstar.append(mstar)
+                all_emline_wav.append(self.sp.emline_wavelengths)
+                all_emline_lum.append(self.sp.emline_luminosity)
+                all_emline_lum_massnorm.append(self.sp.emline_luminosity / mstar)
+
+                if calc_bands == True:
+                    all_filtmags.append(bandmags)
+            else:
+                print(self.basesfh, self.samples[i,0:])
+
+        self.lam = all_lam
+        self.spec = all_spec
+        self.spec_massnorm = all_spec_massnorm
+        self.mstar = all_mstar
+        self.emline_wav = all_emline_wav
+        self.emline_lum = all_emline_lum
+        self.emline_lum_massnorm = all_emline_lum_massnorm
+
+        # not mass normalized
+        self.bands = bands
+        self.filter_wavelengths = filter_wavelengths
+        self.filtmags = all_filtmags
+
+        return
+
+
+    def calc_spectral_features_case(self, massnorm = True):
+
+        if massnorm == True:
+            spectra = self.spec_massnorm
+            emline_lum = self.emline_lum_massnorm
+        else:
+            spectra = self.spec
+            emline_lum = self.emline_lum
+
+        lam = self.lam[0]
+        emline_wavs = self.emline_wav
+
+        ha_lums = []
+        hdelta_ews = []
+        dn4000_vals = []
+
+        ha_lambda = 6562 # in angstrom
+
+        for i in (range(len(spectra))):
+
+    #         specflam = ujy_to_flam(spectra[i], lam)
+            specflam = spectra[i]
+
+            ha_line_index = np.argmin(np.abs(emline_wavs[i] - ha_lambda))
+            ha_lum = emline_lum[i][ha_line_index]
+            ha_lums.append(ha_lum)
+
+            hdelta_mask = (lam > 4030.) & (lam < 4082.)
+            hdelta_cont1_flux = np.mean(specflam[hdelta_mask])
+            hdelta_mask = (lam > 4122.0) & (lam < 4170.00)
+            hdelta_cont2_flux = np.mean(specflam[hdelta_mask])
+            hdelta_cont_flux_av = (hdelta_cont1_flux + hdelta_cont2_flux)/2
+            hdelta_mask = (lam > 4083.5) & (lam < 4122.5)
+            hdelta_emline_fluxes = np.trapz(x=lam[hdelta_mask],
+                                            y = (hdelta_cont_flux_av - specflam[hdelta_mask])/hdelta_cont_flux_av)
+            hdelta_emline_fluxratios = hdelta_emline_fluxes / hdelta_cont_flux_av
+            hdelta_ew = hdelta_emline_fluxes
+            hdelta_ews.append(hdelta_ew)
+
+            dn4000_mask1 = (lam>3850) & (lam < 3950)
+            dn4000_flux1 = np.mean(specflam[dn4000_mask1])
+            dn4000_mask2 = (lam>4000) & (lam < 4100)
+            dn4000_flux2 = np.mean(specflam[dn4000_mask2])
+            dn4000 = dn4000_flux2/dn4000_flux1
+            dn4000_vals.append(dn4000)
+
+            self.ha_lums = ha_lums
+            self.hdelta_ews = hdelta_ews
+            self.dn4000_vals = dn4000_vals
+
+        return
+
+    def calc_spectral_features(self, massnorm = True):
+
+        if massnorm == True:
+            spectra = self.spec_massnorm
+            emline_lum = self.emline_lum_massnorm
+        else:
+            spectra = self.spec
+            emline_lum = self.emline_lum
+
+        lam = self.lam[0]
+        emline_wavs = self.emline_wav
+
+        ha_lums = []
+        hdelta_ews = []
+        dn4000_vals = []
+        fuv_vals = []
+        nuv_vals = []
+        u_vals = []
+        caH_ews = []
+        caK_ews = []
+
+        ha_lambda = 6562 # in angstrom
+
+        for i in (range(len(spectra))):
+
+    #         specflam = ujy_to_flam(spectra[i], lam)
+            specflam = spectra[i]
+
+            ha_line_index = np.argmin(np.abs(emline_wavs[i] - ha_lambda))
+            ha_lum = emline_lum[i][ha_line_index]
+            ha_lums.append(ha_lum)
+
+            hdelta_mask = (lam > 4030.) & (lam < 4082.)
+            hdelta_cont1_flux = np.mean(specflam[hdelta_mask])
+            hdelta_mask = (lam > 4122.0) & (lam < 4170.00)
+            hdelta_cont2_flux = np.mean(specflam[hdelta_mask])
+            hdelta_cont_flux_av = (hdelta_cont1_flux + hdelta_cont2_flux)/2
+            hdelta_mask = (lam > 4083.5) & (lam < 4122.5)
+            hdelta_emline_fluxes = np.trapz(x=lam[hdelta_mask],
+                                            y = (hdelta_cont_flux_av - specflam[hdelta_mask])/hdelta_cont_flux_av)
+            hdelta_emline_fluxratios = hdelta_emline_fluxes / hdelta_cont_flux_av
+            hdelta_ew = hdelta_emline_fluxes
+            hdelta_ews.append(hdelta_ew)
+
+            lam_index_caK = np.argmin(np.abs(lam - 3933.66))
+            lam_index_caH = np.argmin(np.abs(lam - 3968.47))
+
+            caK_mask = (lam > 3907.0064) & (lam <  3929.5122)
+            caK_cont1_flux = np.mean(specflam[caK_mask])
+            caK_mask = (lam > 3941.2155) & (lam < 3961.0205)
+            caK_cont2_flux = np.mean(specflam[caK_mask])
+            caK_cont_flux_av = (caK_cont1_flux + caK_cont2_flux)/2
+
+            caK_mask = (lam > 3929.5122) & (lam < 3941.2155)
+            caK_emline_fluxes = np.trapz(x=lam[caK_mask],
+                                    y = (caK_cont_flux_av - specflam[caK_mask])/caK_cont_flux_av)
+            caK_ew = caK_emline_fluxes
+            caK_ews.append(caK_ew)
+
+            caH_mask = (lam > 3941.2155) & (lam < 3961.0205)
+            caH_cont1_flux = np.mean(specflam[caH_mask])
+            caH_mask = (lam > 3980.8257) & (lam < 3997.0299)
+            caH_cont2_flux = np.mean(specflam[caH_mask])
+            caH_cont_flux_av = (caH_cont1_flux + caH_cont2_flux)/2
+
+            caH_mask = (lam > 3961.0205) & (lam < 3980.8257)
+            caH_emline_fluxes = np.trapz(x=lam[caH_mask],
+                                    y = (caH_cont_flux_av - specflam[caH_mask])/caH_cont_flux_av)
+            caH_ew = caH_emline_fluxes
+            caH_ews.append(caH_ew)
+
+            dn4000_mask1 = (lam>3850) & (lam < 3950)
+            dn4000_flux1 = np.mean(specflam[dn4000_mask1])
+            dn4000_mask2 = (lam>4000) & (lam < 4100)
+            dn4000_flux2 = np.mean(specflam[dn4000_mask2])
+            dn4000 = dn4000_flux2/dn4000_flux1
+            dn4000_vals.append(dn4000)
+
+            fuv_lum_mask = (lam > 1300) & (lam < 1700)
+            fuv_flux1 = np.mean(specflam[fuv_lum_mask])
+            fuv_vals.append(fuv_flux1)
+
+            nuv_lum_mask = (lam > 1800) & (lam < 2600)
+            nuv_flux1 = np.mean(specflam[nuv_lum_mask])
+            nuv_vals.append(nuv_flux1)
+
+            u_lum_mask = (lam > 3000) & (lam < 3800)
+            u_flux1 = np.mean(specflam[u_lum_mask])
+            u_vals.append(u_flux1)
+
+        self.ha_lums = ha_lums
+        self.hdelta_ews = hdelta_ews
+        self.dn4000_vals = dn4000_vals
+        self.fuv_vals = fuv_vals
+        self.nuv_vals = nuv_vals
+        self.u_vals = u_vals
+        self.caH_ews = caH_ews
+        self.caK_ews = caK_ews
+
+        return ha_lums, hdelta_ews, dn4000_vals, fuv_vals, nuv_vals, u_vals, caH_ews, caK_ews
+
+
+    def plot_samples(self, nsamp = 100, random_seed = 42, plot_samples=5,plim=2, plotlog=False,save_fname = 'none', **kwargs):
+
+        samples = self.sample_kernel(nsamp = nsamp, random_seed = random_seed, **kwargs)
+
+        plt.figure(figsize=(12,6))
+        if plotlog == True:
+            plt.plot(self.tarr, 10**samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
+            plt.plot(self.tarr, 10**np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
+            plt.xlabel('time [arbitrary units]')
+            plt.ylabel('some quantity of interest')
+        else:
+            plt.plot(self.tarr, samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
+            plt.plot(self.tarr, np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
+            plt.fill_between(self.tarr, np.nanpercentile(samples.T,16,axis=1),
+                            np.nanpercentile(samples.T,84,axis=1),color='k',alpha=0.1,label='1$\sigma$')
+            plt.xlabel('time [arbitrary units]')
+            plt.ylabel('some quantity of interest')
+            plt.legend(edgecolor='w');
+            plt.ylim(-plim,plim);plt.title([kwargs])
+
+        if save_fname is not 'none':
+            print('saving figure as: ',save_fname)
+            plt.savefig(save_fname, bbox_inches='tight')
+        plt.show()
+
+    def plot_kernel(self, deltat = np.round(np.arange(-10,10,0.1),1),save_fname = 'none', **kwargs):
+
+        plt.figure(figsize=(12,6))
+        plt.plot(deltat, self.kernel(deltat, **kwargs),lw=3,
+                 label=kwargs)
+        plt.xlabel('$\Delta t$')
+        plt.ylabel('covariance');plt.title(kwargs)
+        #plt.text(-9,0.23,'Past');plt.text(7,0.23,'Future')
+        if save_fname is not 'none':
+            print('saving figure as: ',save_fname)
+            plt.savefig(save_fname, bbox_inches='tight')
+        plt.show()
+
+    def plot_kernel_and_draws(self, deltat = np.round(np.arange(-10,10,0.1),1), nsamp = 100, random_seed = 42, plot_samples=5,plim=2, plotlog=False,save_fname = 'none', **kwargs):
+
+
+        plt.figure(figsize=(24,6))
+
+        plt.subplot(1,2,1)
+        plt.plot(deltat, self.kernel(deltat, **kwargs),lw=3,
+                 label=kwargs)
+        plt.xlabel('$\Delta t$')
+        plt.ylabel('covariance');plt.title(['(kernel)',kwargs])
+        plt.xlim(-np.amax(self.tarr),np.amax(self.tarr));
+        #plt.text(-9,0.23,'Past');plt.text(7,0.23,'Future')
+
+        plt.subplot(1,2,2)
+
+        samples = self.sample_kernel(nsamp = nsamp, random_seed = random_seed, **kwargs)
+
+        if plotlog == True:
+            plt.plot(self.tarr, 10**samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
+            plt.plot(self.tarr, 10**np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
+            plt.xlabel('time [arbitrary units]')
+            plt.ylabel('log SFR(t)')
+        else:
+            plt.plot(self.tarr, samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
+            plt.plot(self.tarr, np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
+            plt.fill_between(self.tarr, np.nanpercentile(samples.T,16,axis=1),
+                            np.nanpercentile(samples.T,84,axis=1),color='k',alpha=0.1,label='1$\sigma$')
+            plt.xlabel('time [arbitrary units]')
+            plt.ylabel('log SFR(t)')
+            plt.legend(edgecolor='w');
+            plt.ylim(-plim,plim);
+        plt.title('samples drawn from kernel')
+
+        if save_fname is not 'none':
+            print('saving figure as: ',save_fname)
+            plt.savefig(save_fname, bbox_inches='tight')
+        plt.show()
+
+    def plot_kernel_sfhs_spec(self, deltat = np.round(np.arange(-10,10,0.1),1), nsamp = 100, random_seed = 42, plot_samples=5,plim=2, plotlog=False,save_fname = 'none', titlestr = '', massnorm = True, **kwargs):
+
+        plt.figure(figsize=(24,6))
+
+        plt.subplot(1,3,1)
+        plt.plot(deltat, self.kernel(deltat, **kwargs),lw=3,
+                 label=kwargs)
+        plt.xlabel('$\Delta t$ [Gyr]')
+        plt.ylabel('covariance');#plt.title(['(kernel)',kwargs])
+        plt.title(titlestr)
+        plt.xlim(-np.amax(self.tarr),np.amax(self.tarr));
+        #plt.text(-9,0.23,'Past');plt.text(7,0.23,'Future')
+
+        plt.subplot(1,3,2)
+
+        samples = self.sample_kernel(nsamp = nsamp, random_seed = random_seed, **kwargs)
+
+        if plotlog == True:
+            plt.plot(self.tarr, 10**samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
+            plt.plot(self.tarr, 10**np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
+            plt.xlabel('time [arbitrary units]')
+            plt.ylabel('log SFR(t)')
+        else:
+            plt.plot(self.tarr, samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
+            plt.plot(self.tarr, np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
+            plt.fill_between(self.tarr, np.nanpercentile(samples.T,16,axis=1),
+                            np.nanpercentile(samples.T,84,axis=1),color='k',alpha=0.1,label='1$\sigma$')
+            plt.xlabel('time [Gyr]')
+            plt.ylabel('log SFR(t)')
+            plt.legend(edgecolor='w');
+            plt.ylim(-plim,plim);
+            #plt.xlim(0,1)
+        plt.title('samples drawn from kernel')
+
+        plt.subplot(1,3,3)
+
+        for i in range(plot_samples):
+            specsfh = 10**(self.basesfh+samples[i, 0:])
+            self.sp.set_tabular_sfh(self.tarr, specsfh)
+            lam, spec = self.sp.get_spectrum(tage = self.t_univ)
+            mstar = self.sp.stellar_mass
+
+            if massnorm == True:
+                plt.plot(lam, spec/mstar*1e10,alpha=0.7,lw=1)
+            else:
+                plt.plot(lam, spec,alpha=0.7,lw=1)
+
+        plt.xscale('log');plt.yscale('log')
+        plt.xlabel(r'$\lambda$ [rest-frame]')
+        plt.ylabel(r'$L_\nu$ [L$_\odot~/~$Hz]')
+        #plt.ylim(1e-6,1e-1)
+        plt.xlim(1e3,1e5)
+
+        plt.tight_layout()
+        if save_fname is not 'none':
+            print('saving figure as: ',save_fname)
+            plt.savefig(save_fname, bbox_inches='tight')
+        plt.show()
+
+
+
+def calc_spectral_features(spectra, emline_lum, lam, emline_wavs):
+
+    ha_lums = []
+    hdelta_ews = []
+    dn4000_vals = []
+    fuv_vals = []
+    nuv_vals = []
+    u_vals = []
+    caH_ews = []
+    caK_ews = []
+
+    ha_lambda = 6562 # in angstrom
+
+    for i in (range(len(spectra))):
+
+#         specflam = ujy_to_flam(spectra[i], lam)
+        specflam = spectra[i]
+
+        ha_line_index = np.argmin(np.abs(emline_wavs[i] - ha_lambda))
+        ha_lum = emline_lum[i][ha_line_index]
+        ha_lums.append(ha_lum)
+
+        hdelta_mask = (lam > 4030.) & (lam < 4082.)
+        hdelta_cont1_flux = np.mean(specflam[hdelta_mask])
+        hdelta_mask = (lam > 4122.0) & (lam < 4170.00)
+        hdelta_cont2_flux = np.mean(specflam[hdelta_mask])
+        hdelta_cont_flux_av = (hdelta_cont1_flux + hdelta_cont2_flux)/2
+
+        hdelta_mask = (lam > 4083.5) & (lam < 4122.5)
+        hdelta_emline_fluxes = np.trapz(x=lam[hdelta_mask],
+                                        y = (hdelta_cont_flux_av - specflam[hdelta_mask])/hdelta_cont_flux_av)
+
+        hdelta_emline_fluxratios = hdelta_emline_fluxes / hdelta_cont_flux_av
+
+        hdelta_ew = hdelta_emline_fluxes
+        hdelta_ews.append(hdelta_ew)
+
+        lam_index_caK = np.argmin(np.abs(lam - 3933.66))
+        lam_index_caH = np.argmin(np.abs(lam - 3968.47))
+
+        caK_mask = (lam > 3907.0064) & (lam <  3929.5122)
+        caK_cont1_flux = np.mean(specflam[caK_mask])
+        caK_mask = (lam > 3941.2155) & (lam < 3961.0205)
+        caK_cont2_flux = np.mean(specflam[caK_mask])
+        caK_cont_flux_av = (caK_cont1_flux + caK_cont2_flux)/2
+
+        caK_mask = (lam > 3929.5122) & (lam < 3941.2155)
+        caK_emline_fluxes = np.trapz(x=lam[caK_mask],
+                                y = (caK_cont_flux_av - specflam[caK_mask])/caK_cont_flux_av)
+        caK_ew = caK_emline_fluxes
+        caK_ews.append(caK_ew)
+
+        caH_mask = (lam > 3941.2155) & (lam < 3961.0205)
+        caH_cont1_flux = np.mean(specflam[caH_mask])
+        caH_mask = (lam > 3980.8257) & (lam < 3997.0299)
+        caH_cont2_flux = np.mean(specflam[caH_mask])
+        caH_cont_flux_av = (caH_cont1_flux + caH_cont2_flux)/2
+
+        caH_mask = (lam > 3961.0205) & (lam < 3980.8257)
+        caH_emline_fluxes = np.trapz(x=lam[caH_mask],
+                                y = (caH_cont_flux_av - specflam[caH_mask])/caH_cont_flux_av)
+        caH_ew = caH_emline_fluxes
+        caH_ews.append(caH_ew)
+
+
+#         if i<10:
+#             plt.plot(lam[(lam>4030) & (lam<4170)], specflam[(lam>4030) & (lam<4170)])
+#             plt.plot(lam[hdelta_mask], specflam[hdelta_mask])
+#             plt.plot(lam[hdelta_mask], np.ones((np.sum(hdelta_mask)))*hdelta_cont_flux_av)
+#             plt.show()
+#             print(hdelta_ew)
+
+
+#         specflam = spectra[i]
+        dn4000_mask1 = (lam>3850) & (lam < 3950)
+        dn4000_flux1 = np.mean(specflam[dn4000_mask1])
+        dn4000_mask2 = (lam>4000) & (lam < 4100)
+        dn4000_flux2 = np.mean(specflam[dn4000_mask2])
+#         dn4000_mask1 = (lam>3850) & (lam < 3950)
+#         dn4000_flux1 = np.mean(spectra[i][dn4000_mask1])
+#         dn4000_mask2 = (lam>4000) & (lam < 4100)
+#         dn4000_flux2 = np.mean(spectra[i][dn4000_mask2])
+        dn4000 = dn4000_flux2/dn4000_flux1
+        dn4000_vals.append(dn4000)
+
+        fuv_lum_mask = (lam > 1300) & (lam < 1700)
+        fuv_flux1 = np.mean(specflam[fuv_lum_mask])
+        fuv_vals.append(fuv_flux1)
+
+        nuv_lum_mask = (lam > 1800) & (lam < 2600)
+        nuv_flux1 = np.mean(specflam[nuv_lum_mask])
+        nuv_vals.append(nuv_flux1)
+
+        u_lum_mask = (lam > 3000) & (lam < 3800)
+        u_flux1 = np.mean(specflam[u_lum_mask])
+        u_vals.append(u_flux1)
+
+    return ha_lums, hdelta_ews, dn4000_vals, fuv_vals, nuv_vals, u_vals, caH_ews, caK_ews
\ No newline at end of file
diff --git a/prospect/models/gp_sfh_kernels.py b/prospect/models/gp_sfh_kernels.py
new file mode 100644
index 00000000..07e3e484
--- /dev/null
+++ b/prospect/models/gp_sfh_kernels.py
@@ -0,0 +1,233 @@
+# kernels corresponding to the various models used in the paper
+# 1. White kernel: white_kernel
+# 2. Damped RW: damped_random_walk_kernel
+# 3. Regulator model: regulator_model_kernel
+# 4b. extended_regulator_model_kernel
+# 4b. extended_regulator_model_kernel_old
+# 4c. extended_regulator_model_kernel_paramlist_old
+
+import numpy as np
+
+# ---------------- suggested model kernel values -------------------------------
+
+kernel_params_MW_1dex = [1.0, 2500/1e3, 150/1e3, 0.03, 25/1e3]
+kernel_params_dwarf_1dex = [1.0, 30/1e3, 150/1e3, 0.03, 10/1e3]
+kernel_params_noon_1dex = [1.0, 200/1e3, 100/1e3, 0.03, 50/1e3]
+kernel_params_highz_1dex = [1.0, 15/1e3, 16/1e3, 0.03, 6/1e3]
+
+def convert_sigma_obs_to_ExReg(sigma_target, sigma_GMC_to_reg_ratio = 0.03):
+    return np.sqrt(sigma_target**2/(1 + (sigma_GMC_to_reg_ratio)**2)), sigma_GMC_to_reg_ratio*np.sqrt(sigma_target**2/(1 + (sigma_GMC_to_reg_ratio)**2))
+
+TCF20_scattervals = [0.17, 0.53, 0.24, 0.27]
+TCF20_GMC_to_reg_ratio = 0.03
+
+temp_sigma, temp_sigma_GMC = convert_sigma_obs_to_ExReg(TCF20_scattervals[0], TCF20_GMC_to_reg_ratio)
+kernel_params_MW_TCF20 = [temp_sigma, 2500/1e3, 150/1e3, temp_sigma_GMC, 25/1e3]
+temp_sigma, temp_sigma_GMC = convert_sigma_obs_to_ExReg(TCF20_scattervals[1], TCF20_GMC_to_reg_ratio)
+kernel_params_dwarf_TCF20 = [temp_sigma, 30/1e3, 150/1e3, temp_sigma_GMC, 10/1e3]
+temp_sigma, temp_sigma_GMC = convert_sigma_obs_to_ExReg(TCF20_scattervals[2], TCF20_GMC_to_reg_ratio)
+kernel_params_noon_TCF20 = [temp_sigma, 200/1e3, 100/1e3, temp_sigma_GMC, 50/1e3]
+temp_sigma, temp_sigma_GMC = convert_sigma_obs_to_ExReg(TCF20_scattervals[3], TCF20_GMC_to_reg_ratio)
+kernel_params_highz_TCF20 = [temp_sigma, 15/1e3, 16/1e3, temp_sigma_GMC, 6/1e3]
+
+# --------------------- kernels -------------------------------------
+
+def white_kernel(delta_t, sigma=1.0, base_e_to_10 = False):
+    """
+    A basic implementation of a white noise kernel, with one parameter:
+    A: sigma (not a real parameter in this case)
+    """
+    if base_e_to_10 == True:
+        sigma = sigma*np.log10(np.e)
+
+    kernel_val = np.zeros_like(delta_t)
+    kernel_val[delta_t == 0] = sigma**2
+    return kernel_val
+
+def damped_random_walk_kernel(delta_t, sigma=1.0, tau_eq = 1.0, base_e_to_10 = False):
+    """
+    A basic implementation of a damped random walk kernel, with two parameters:
+    sigma: \sigma, the amount of overall variance
+    tau_eq: equilibrium timescale
+
+    """
+    if base_e_to_10 == True:
+        sigma = sigma*np.log10(np.e)
+
+    tau = np.abs(delta_t)
+    kernel_val = (sigma**2) * np.exp(- tau / tau_eq)
+    return kernel_val
+
+def regulator_model_kernel(delta_t, sigma=1.0, tau_eq = 1.0, tau_in = 0.5, base_e_to_10 = False):
+    """
+    A basic implementation of the regulator model kernel, with five parameters:
+    sigma: \sigma, the amount of overall variance
+    tau_eq: equilibrium timescale
+    tau_x: inflow correlation timescale (includes 2pi factor)
+    sigma_gmc: gmc variability
+    tau_l: cloud lifetime
+
+    """
+
+    # in TCF20, this is defined in base e, so convert to base 10
+    if base_e_to_10 == True:
+        sigma = sigma*np.log10(np.e)
+
+    tau = np.abs(delta_t)
+
+    if tau_in == tau_eq:
+        c_reg = sigma**2 * (1 + tau/tau_eq) * (np.exp(-tau/tau_eq))
+    else:
+        c_reg = sigma**2 / (tau_in - tau_eq) * (tau_in*np.exp(-tau/tau_in) - tau_eq*np.exp(-tau/tau_eq))
+
+    # if tau_in == tau_eq:
+    #     c_reg = sigma**2 * (1+ np.abs(delta_t)/tau_eq) * (np.exp(-np.abs(delta_t)/tau_eq)/(2*tau_eq))
+    # else:
+    #     c_reg = sigma**2 / (tau_in**2 - tau_eq**2) * (tau_in * np.exp(-np.abs(delta_t) / tau_in) - tau_eq * np.exp(-np.abs(delta_t) / tau_eq))
+
+    return c_reg
+
+def extended_regulator_model_kernel(delta_t, sigma=1.0, tau_eq = 1.0, tau_in = 0.5, sigma_gmc = 0.01, tau_gmc = 0.001, base_e_to_10 = False, return_components = False):
+    """
+    A basic implementation of the regulator model kernel, with five parameters:
+    sigma: \sigma_{gas}, the amount of overall variance
+    tau_eq: equilibrium timescale
+    tau_x: inflow correlation timescale (includes 2pi factor)
+    sigma_gmc: gmc variability
+    tau_l: cloud lifetime
+
+    """
+
+    if base_e_to_10 == True:
+        # in TCF20, this is defined in base e, so convert to base 10
+        sigma = sigma*np.log10(np.e)
+        sigma_gmc = sigma_gmc*np.log10(np.e)
+
+    tau = np.abs(delta_t)
+
+    if tau_in == tau_eq:
+        c_reg = sigma**2 * (1 + tau/tau_eq) * (np.exp(-tau/tau_eq))
+    else:
+        c_reg = sigma**2 / (tau_in - tau_eq) * (tau_in*np.exp(-tau/tau_in) - tau_eq*np.exp(-tau/tau_eq))
+
+    c_gmc = sigma_gmc**2 * np.exp(-tau/tau_gmc)
+
+    kernel_val = (c_reg + c_gmc)
+
+    if return_components == True:
+        return kernel_val, c_reg, c_gmc
+    else:
+        return kernel_val
+
+def extended_regulator_model_kernel_paramlist(delta_t, kernel_params, base_e_to_10 = False):
+    """
+    A basic implementation of the regulator model kernel, with five parameters:
+    kernel_params = [sigma, tau_eq, tau_in, sigma_gmc, tau_gmc]
+    sigma: \sigma, the amount of overall variance
+    tau_eq: equilibrium timescale
+    tau_x: inflow correlation timescale (includes 2pi factor)
+    sigma_gmc: gmc variability
+    tau_l: cloud lifetime
+
+    """
+
+    sigma, tau_eq, tau_in, sigma_gmc, tau_gmc = kernel_params
+
+    if base_e_to_10 == True:
+        # in TCF20, this is defined in base e, so convert to base 10
+        sigma = sigma*np.log10(np.e)
+        sigma_gmc = sigma_gmc*np.log10(np.e)
+
+    tau = np.abs(delta_t)
+
+    if tau_in == tau_eq:
+        c_reg = sigma**2 * (1 + tau/tau_eq) * (np.exp(-tau/tau_eq))
+    else:
+        c_reg = sigma**2 / (tau_in - tau_eq) * (tau_in*np.exp(-tau/tau_in) - tau_eq*np.exp(-tau/tau_eq))
+
+    c_gmc = sigma_gmc**2 * np.exp(-tau/tau_gmc)
+
+    kernel_val = (c_reg + c_gmc)
+    return kernel_val
+
+def extended_regulator_model_PSD(f, sigma=1.0, tau_eq = 1.0, tau_in = 0.5, sigma_gmc = 0.01, tau_gmc = 0.001, base_e_to_10 = False):
+    """
+    A basic implementation of the regulator model kernel, with five parameters:
+    sigma: \sigma, the amount of overall variance
+    tau_eq: equilibrium timescale
+    tau_x: inflow correlation timescale (includes 2pi factor)
+    sigma_gmc: gmc variability
+    tau_l: cloud lifetime
+
+    """
+
+    if base_e_to_10 == True:
+        # in TCF20, this is defined in base e, so convert to base 10
+        sigma_base10 = sigma*np.log10(np.e)
+        sigma_gmc_base10 = sigma_gmc*np.log10(np.e)
+    else:
+        sigma_base10 = sigma
+        sigma_gmc_base10 = sigma_gmc
+
+    tpi = 2*np.pi
+
+    psd_reg = sigma_base10**2 / (1 + ((tpi*tau_eq*1e3)**2 + (tpi*tau_in*1e3)**2)*(f**2) + ((tpi*tau_eq*1e3)**2 * (tpi*tau_in*1e3)**2)*(f**4))
+    psd_gmc = sigma_gmc_base10**2 / (1 + (tpi*tau_gmc*1e3*f)**2)
+    psd_val = psd_reg + psd_gmc
+
+    return psd_val, psd_reg, psd_gmc
+
+# ---------------------------------------------------------------------
+# ------------------------ deprecated ---------------------------------
+# ---------------------------------------------------------------------
+
+def extended_regulator_model_kernel_old(delta_t, sigma=1.0, tau_eq = 1.0, tau_in = 0.5, sigma_gmc = 0.01, tau_gmc = 0.001, base_e_to_10 = False):
+    """
+    A basic implementation of the regulator model kernel, with five parameters:
+    sigma: \sigma_{gas}, the amount of overall variance
+    tau_eq: equilibrium timescale
+    tau_x: inflow correlation timescale (includes 2pi factor)
+    sigma_gmc: gmc variability
+    tau_l: cloud lifetime
+
+    """
+
+    if base_e_to_10 == True:
+        # in TCF20, this is defined in base e, so convert to base 10
+        sigma = sigma*np.log10(np.e)
+        sigma_gmc = sigma_gmc*np.log10(np.e)
+
+    if tau_in == tau_eq:
+        c_reg = sigma**2 * (1+ np.abs(delta_t)/tau_eq) * (np.exp(-np.abs(delta_t)/tau_eq)/(2*tau_eq))
+    else:
+        c_reg = sigma**2 / (tau_in**2 - tau_eq**2) * (tau_in * np.exp(-np.abs(delta_t) / tau_in) - tau_eq * np.exp(-np.abs(delta_t) / tau_eq))
+    c_gmc = sigma_gmc**2 / (2*tau_gmc) * np.exp(-np.abs(delta_t)/tau_gmc)
+    kernel_val = (c_reg + c_gmc)
+    return kernel_val
+
+def extended_regulator_model_kernel_paramlist_old(delta_t, kernel_params, base_e_to_10 = False):
+    """
+    A basic implementation of the regulator model kernel, with five parameters:
+    kernel_params = [sigma, tau_eq, tau_in, sigma_gmc, tau_gmc]
+    sigma: \sigma, the amount of overall variance
+    tau_eq: equilibrium timescale
+    tau_x: inflow correlation timescale (includes 2pi factor)
+    sigma_gmc: gmc variability
+    tau_l: cloud lifetime
+
+    """
+
+    sigma, tau_eq, tau_in, sigma_gmc, tau_gmc = kernel_params
+
+    if base_e_to_10 == True:
+        # in TCF20, this is defined in base e, so convert to base 10
+        sigma = sigma*np.log10(np.e)
+        sigma_gmc = sigma_gmc*np.log10(np.e)
+
+    if tau_in == tau_eq:
+        c_reg = sigma**2 * (1+ np.abs(delta_t)/tau_eq) * (np.exp(-np.abs(delta_t)/tau_eq)/(2*tau_eq))
+    else:
+        c_reg = sigma**2 / (tau_in**2 - tau_eq**2) * (tau_in * np.exp(-np.abs(delta_t) / tau_in) - tau_eq * np.exp(-np.abs(delta_t) / tau_eq))
+    c_gmc = sigma_gmc**2 / (2*tau_gmc) * np.exp(-np.abs(delta_t)/tau_gmc)
+    kernel_val = (c_reg + c_gmc)
+    return kernel_val
\ No newline at end of file

From 43ae91a27def40e18cda431ee68bd7403a3820c8 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 26 Mar 2024 11:35:32 -0400
Subject: [PATCH 063/132] updating changelog for version 1.3.0

---
 CHANGELOG.rst | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 7de0ee6f..42b1419f 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -1,5 +1,15 @@
 .. :changelog:
 
+v1.3.0 (2024-03-27)
++++++++++++++++++++
+- Adds the prospector-beta SFH priors and documentation courtesy @wangbingjie
+- Bugfixes in emission line masking, polynomial regularization, sfr_ratio
+  clipping (h/t @mjastro, @wangbingjie, @davidjsetton)
+- Documentation updates
+
+`Full Changelog <https://github.com/bd-j/prospector/compare/v1.2.0...v1.3.0>`_
+
+
 v1.2.0 (2022-12-31)
 +++++++++++++++++++
 
@@ -10,7 +20,7 @@ v1.2.0 (2022-12-31)
 - Fixes to the dynesty interface for dynesty >= 2.0 (h/t @mjastro)
 - Fix sign error in Powell minimization (h/t @blanton144)
 - Fix bugs in parameter template for emission line fitting.
-- numeropus documentation updates including nebular emission details.
+- numerous documentation updates including nebular emission details.
 
 
 v1.1.0 (2022-02-20)

From 9ef8fcb7f31fd13dc0b8039ccebbb5f4c92a5f25 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 26 Mar 2024 12:31:24 -0400
Subject: [PATCH 064/132] doc tweaks.

---
 AUTHORS.rst          | 27 +--------------------------
 doc/installation.rst |  6 ++++--
 doc/quickstart.rst   |  9 +++++----
 doc/requirements.txt |  1 +
 pyproject.toml       |  3 +--
 5 files changed, 12 insertions(+), 34 deletions(-)

diff --git a/AUTHORS.rst b/AUTHORS.rst
index afe47f28..bc2b2c50 100644
--- a/AUTHORS.rst
+++ b/AUTHORS.rst
@@ -1,26 +1 @@
-Author:
-
-- `Ben Johnson (Harvard) <https://github.com/bd-j>`_
-
-Direct contributions to the code base:
-
-- `Gabe Brammer <https://github.com/gbrammer>`_
-- `James Guillochon <https://github.com/guillochon>`_
-- `Joel Leja <https://github.com/jrleja>`_
-- `John Moustakas <https://github.com/moustakas>`_
-- `Josh Speagle <https://github.com/joshspeagle>`_
-
-Comments, corrections & suggestions:
-
-- Antara Basu-Zych
-- Kevin Bundy
-- Phill Cargile
-- Charlie Conroy
-- Johnny Greco
-- Song Huang
-- Gourav Khullar
-- Sidney Lower
-- Dylan Nelson
-- Imad Pasha
-- Dan Weisz
-- Tom Zick
\ No newline at end of file
+The list of contributors can be found `on GitHub <https://github.com/bd-j/prospector/graphs/contributors>`_.
diff --git a/doc/installation.rst b/doc/installation.rst
index 0174c40f..a390a1cf 100644
--- a/doc/installation.rst
+++ b/doc/installation.rst
@@ -1,7 +1,8 @@
 Installation
 ============
 
-|Codename| itself is is pure python.  To install a released version of just |Codename|, use ``pip``
+|Codename| itself is is pure python.  To install a released version of just
+|Codename|, use ``pip``
 
 .. code-block:: shell
 
@@ -52,7 +53,8 @@ environment, use the following procedure:
 Requirements
 ------------
 
-|Codename| works with Python3, and requires `numpy <http://www.numpy.org>`_ and `SciPy <http://www.scipy.org>`_
+|Codename| works with ``python>=3.9``, and requires `numpy
+<http://www.numpy.org>`_ and `SciPy <http://www.scipy.org>`_
 
 You will also need:
 
diff --git a/doc/quickstart.rst b/doc/quickstart.rst
index 773d6b2d..47203341 100644
--- a/doc/quickstart.rst
+++ b/doc/quickstart.rst
@@ -19,8 +19,8 @@ ingrediants; for more realistic usage see :ref:`demo` or the :ref:`tutorial`.
 Build an observation
 --------------------
 
-First we'll get some data, using ``astroquery`` to get SDSS photometry of a galaxy.  We'll also
-get spectral data so we know the redshift.
+First we'll get some data, using ``astroquery`` to get SDSS photometry of a
+galaxy.  We'll also get spectral data so we know the redshift.
 
 .. code:: python
 
@@ -49,7 +49,7 @@ for this example we do *not* attempt to fit the spectrum at the same time.
     filters = load_filters([f"sdss_{b}0" for b in bands])
     maggies = np.array([10**(-0.4 * cat[0][f"cModelMag_{b}"]) for b in bands])
     magerr = np.array([cat[0][f"cModelMagErr_{b}"] for b in bands])
-    magerr = np.clip(magerr, 0.05, np.inf)
+    magerr = np.hypot(magerr, 0.05)
 
     obs = dict(wavelength=None, spectrum=None, unc=None, redshift=shdus[2].data[0]["z"],
                maggies=maggies, maggies_unc=magerr * maggies / 1.086, filters=filters)
@@ -78,7 +78,8 @@ should be replaced or adjusted depending on your particular science question.
     print(model)
 
 In principle we could also add noise models for the spectral and photometric
-data, but we'll make the default assumption of independent Gaussian noise for the moment.
+data, but we'll make the default assumption of independent Gaussian noise for
+the moment.
 
 .. code:: python
 
diff --git a/doc/requirements.txt b/doc/requirements.txt
index a2d257eb..a2648b15 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -1,3 +1,4 @@
+python >= 3.9
 numpy >= 1.16
 scipy >= 1.1.0
 matplotlib >= 3.0
diff --git a/pyproject.toml b/pyproject.toml
index e83a3d11..2c7a41cb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ authors = [
     { name="Ben Johnson", email="benjamin.johnson@cfa.harvard.edu" },
 ]
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.9"
 license = { text = "MIT License" }
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -21,7 +21,6 @@ dependencies = ["numpy", "h5py"]
 [project.optional-dependencies]
 test = ["pytest", "pytest-xdist"]
 
-
 [tool.setuptools]
 packages = ["prospect",
             "prospect.models", "prospect.sources",

From b20756b5bdb1adc927ddd7e45c7fdd0fed08fabf Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 26 Mar 2024 19:08:35 -0400
Subject: [PATCH 065/132] remove six requirement; fix toml bug; start on
 release workflow.

---
 .github/workflows/release.yml | 77 +++++++++++++++++++++++++++++++++++
 .github/workflows/tests.yml   |  8 ++--
 prospect/fitting/nested.py    |  1 -
 pyproject.toml                |  2 +-
 requirements.txt              |  3 +-
 5 files changed, 83 insertions(+), 8 deletions(-)
 create mode 100644 .github/workflows/release.yml

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000..c181a8b1
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,77 @@
+name: Release
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "*"
+  # pull_request:
+  workflow_dispatch:
+    inputs:
+      prerelease:
+        description: "Run a pre-release, testing the build"
+        required: false
+        type: boolean
+        default: false
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build_wheels:
+    name: Build wheel for ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - "ubuntu-22.04"
+          - "macos-14"
+    steps:
+      - uses: pypa/cibuildwheel@v2.16.5
+      - uses: actions/upload-artifact@v4
+        with:
+          name: binary-${{ matrix.os }}
+          path: ./wheelhouse/*.whl
+
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        name: Install Python
+        with:
+          python-version: "3.10"
+      - name: Install dependencies
+        run: |
+            python -m pip install -U pip
+            python -m pip install -U build twine
+      - name: Build sdist
+        run: |
+          python -m pip install -U pip
+          python -m build --sdist .
+      - uses: actions/upload-artifact@v4
+        with:
+          path: dist/*.tar.gz
+
+  publish:
+    environment:
+      name: pypi
+      url: https://pypi.org/p/fsps
+    permissions:
+      id-token: write
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@v1.8.12
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index ec6e8e71..20806e1f 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -16,13 +16,13 @@ jobs:
         os: [ubuntu-latest, macos-latest]
     steps:
       - name: Clone the repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
       - name: Clone fsps
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           repository: cconroy20/fsps
           path: fsps
@@ -31,7 +31,7 @@ jobs:
           python -m pip install -U pip pytest
           python -m pip install -U fsps astro-sedpy astropy
           python -m pip install -U scipy
-          python -m pip install -U six dynesty
+          python -m pip install -U dynesty
           python -m pip install .
         env:
           SPS_HOME: ${{ github.workspace }}/fsps
diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index 26ef52fe..73d7ed1e 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -1,7 +1,6 @@
 import sys, time
 import numpy as np
 from numpy.random import normal, multivariate_normal
-from six.moves import range
 
 try:
     import nestle
diff --git a/pyproject.toml b/pyproject.toml
index 2c7a41cb..f1d1e2a3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ authors = [
     { name="Ben Johnson", email="benjamin.johnson@cfa.harvard.edu" },
 ]
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">= 3.9"
 license = { text = "MIT License" }
 classifiers = [
     "Development Status :: 5 - Production/Stable",
diff --git a/requirements.txt b/requirements.txt
index 8947ebd2..f22d33ae 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,5 +2,4 @@ numpy >= 1.14.2
 scipy >= 1.1.0
 astropy
 h5py
-astro-sedpy
-six
\ No newline at end of file
+astro-sedpy
\ No newline at end of file

From e5d10223694478bf514ce982d9b69b3f2101b878 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 26 Mar 2024 19:28:41 -0400
Subject: [PATCH 066/132] revert pyproject.toml changes.

---
 .github/workflows/release.yml | 17 ++---------------
 pyproject.toml                |  2 +-
 2 files changed, 3 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index c181a8b1..5054e3d0 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,18 +1,7 @@
 name: Release
 on:
-  push:
-    branches:
-      - main
-    tags:
-      - "*"
-  # pull_request:
-  workflow_dispatch:
-    inputs:
-      prerelease:
-        description: "Run a pre-release, testing the build"
-        required: false
-        type: boolean
-        default: false
+  release:
+    types: [created]
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -34,8 +23,6 @@ jobs:
         with:
           name: binary-${{ matrix.os }}
           path: ./wheelhouse/*.whl
-
-
   build_sdist:
     name: Build source distribution
     runs-on: ubuntu-latest
diff --git a/pyproject.toml b/pyproject.toml
index f1d1e2a3..9526c56b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ authors = [
     { name="Ben Johnson", email="benjamin.johnson@cfa.harvard.edu" },
 ]
 readme = "README.md"
-requires-python = ">= 3.9"
+requires-python = ">=3.7"
 license = { text = "MIT License" }
 classifiers = [
     "Development Status :: 5 - Production/Stable",

From 0fb694cd1a5b1f4bc79c7c4b95195d00a41928c7 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 26 Mar 2024 19:31:44 -0400
Subject: [PATCH 067/132] fixing doc builds.

---
 doc/requirements.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/doc/requirements.txt b/doc/requirements.txt
index a2648b15..a2d257eb 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -1,4 +1,3 @@
-python >= 3.9
 numpy >= 1.16
 scipy >= 1.1.0
 matplotlib >= 3.0

From 899e30e314860de6fe9c66e7c44167d58229f924 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 26 Mar 2024 19:34:52 -0400
Subject: [PATCH 068/132] bumping python requirement; closes #323

---
 pyproject.toml   | 2 +-
 requirements.txt | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 9526c56b..2c7a41cb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ authors = [
     { name="Ben Johnson", email="benjamin.johnson@cfa.harvard.edu" },
 ]
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.9"
 license = { text = "MIT License" }
 classifiers = [
     "Development Status :: 5 - Production/Stable",
diff --git a/requirements.txt b/requirements.txt
index f22d33ae..a4ddcc42 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,4 @@
+python >= 3.9
 numpy >= 1.14.2
 scipy >= 1.1.0
 astropy

From e6924e1e99809b1d4fddeef281cf52983bd906f8 Mon Sep 17 00:00:00 2001
From: Bingjie Wang <bwang.jhu@gmail.com>
Date: Tue, 2 Apr 2024 20:56:16 -0400
Subject: [PATCH 069/132] bugfixes in p-beta when const_phi=True: update data
 file names, ensure logm is an array before item assignment

---
 prospect/models/priors_beta.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/prospect/models/priors_beta.py b/prospect/models/priors_beta.py
index 6b256b6d..532bd04f 100644
--- a/prospect/models/priors_beta.py
+++ b/prospect/models/priors_beta.py
@@ -223,9 +223,9 @@ def __init__(self, parnames=[], name='', **kwargs):
         self.update(**kwargs)
 
         if self.params['const_phi']:
-            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z_l20.txt'), unpack=True)
+            zreds, pdf_zred = np.loadtxt(file_pdf_of_z_l20, unpack=True)
         else:
-            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z.txt'), unpack=True)
+            zreds, pdf_zred = np.loadtxt(file_pdf_of_z_l20t18, unpack=True)
 
         self.finterp_z_pdf, self.finterp_cdf_z = norm_pz(self.params['zred_mini'], self.params['zred_maxi'], zreds, pdf_zred)
         self.mgrid = np.linspace(self.params['mass_mini'], self.params['mass_maxi'], 101)
@@ -768,9 +768,9 @@ def __init__(self, parnames=[], name='', **kwargs):
         self.update(**kwargs)
 
         if self.params['const_phi']:
-            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z_l20.txt'), unpack=True)
+            zreds, pdf_zred = np.loadtxt(file_pdf_of_z_l20, unpack=True)
         else:
-            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z.txt'), unpack=True)
+            zreds, pdf_zred = np.loadtxt(file_pdf_of_z_l20t18, unpack=True)
 
         self.finterp_z_pdf, self.finterp_cdf_z = norm_pz(self.params['zred_mini'], self.params['zred_maxi'], zreds, pdf_zred)
 
@@ -1160,9 +1160,9 @@ def __init__(self, parnames=[], name='', **kwargs):
         # the tables were calculated in pdf_z_tables.ipynb
         # redshift range is 0 - 20
         if self.params['const_phi']:
-            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z_l20.txt'), unpack=True)
+            zreds, pdf_zred = np.loadtxt(file_pdf_of_z_l20, unpack=True)
         else:
-            zreds, pdf_zred = np.loadtxt(os.path.join(prior_data_dir, 'pdf_of_z.txt'), unpack=True)
+            zreds, pdf_zred = np.loadtxt(file_pdf_of_z_l20t18, unpack=True)
 
         self.finterp_z_pdf, self.finterp_cdf_z = norm_pz(self.params['zred_mini'], self.params['zred_maxi'], zreds, pdf_zred)
 
@@ -1514,8 +1514,9 @@ def mass_func_at_z(z, this_logm, const_phi=False, bounds=[6.0, 12.5]):
         else:
             phi = high_z_mass_func(z0=12, this_m=10**this_logm)
 
-    phi[this_logm < bounds[0]] = 0
-    phi[this_logm > bounds[1]] = 0
+    if hasattr(this_logm, "__len__"):
+        phi[this_logm < bounds[0]] = 0
+        phi[this_logm > bounds[1]] = 0
     return np.squeeze(phi)
 
 

From 9a4a5ef35448a7ba794bee4ba86d1d0da5c6345b Mon Sep 17 00:00:00 2001
From: Jenny Wan <jtw.cpc@gmail.com>
Date: Sun, 14 Apr 2024 21:20:21 -0700
Subject: [PATCH 070/132] Delete prospect/models/gp_sfh.py

---
 prospect/models/gp_sfh.py | 638 --------------------------------------
 1 file changed, 638 deletions(-)
 delete mode 100644 prospect/models/gp_sfh.py

diff --git a/prospect/models/gp_sfh.py b/prospect/models/gp_sfh.py
deleted file mode 100644
index 282a17b8..00000000
--- a/prospect/models/gp_sfh.py
+++ /dev/null
@@ -1,638 +0,0 @@
-# main functions for the GP-SFH module.
-# contents:
-#   class simple_GP_sfh()
-
-import numpy as np
-from tqdm import tqdm
-import matplotlib.pyplot as plt
-import scipy.special as ssp
-import fsps
-
-from astropy.cosmology import FlatLambdaCDM
-cosmo = FlatLambdaCDM(H0=70, Om0=0.3)
-
-import seaborn as sns
-sns.set(font_scale=1.8)
-sns.set_style('white')
-
-try:
-    import fsps
-except:
-    print('Failed to load FSPS. Install if spectral generation modules are needed.')
-
-def ujy_to_flam(data,lam):
-    flam = ((3e-5)*data)/((lam**2.)*(1e6))
-    return flam/1e-19
-
-def get_sigma_GMC_scale(sigma=1.0, tau_eq = 1.0, tau_in = 0.5, sigma_gmc = 0.01, tau_gmc = 0.001):
-    """
-    function to calculate relative GMC burstiness factoring in timescale effects
-    """
-
-    C0_norm_reg = sigma**2 / (tau_in + tau_eq)
-    C0_norm_gmc = sigma_gmc**2 / (2*tau_gmc)
-
-    effective_sigma_gmc_ratio = np.sqrt(C0_norm_gmc / C0_norm_reg)
-
-    return effective_sigma_gmc_ratio
-
-# Creating a base class that simplifies a lot of things.
-# The way this is set up, you can pass a kernel as an argument
-# to compute the covariance matrix and draw samples from it.
-class simple_GP_sfh():
-
-    """
-    A class that creates and holds information about a specific
-    kernel, and can generate samples from it.
-
-    Attributes
-    ----------
-    tarr: fiducial time array used to draw samples
-    kernel: accepts an input function as an argument,
-        of the format:
-
-            def kernel_function(delta_t, **kwargs):
-                ... function interior ...
-                return kernel_val[array of len(delta_t)]
-
-    Methods
-    -------
-    get_covariance_matrix
-        [although this has double for loops for maximum flexibility
-        with generic kernel functions, it only has to be computed once,
-        which makes drawing random samples super fast once it's computed.]
-    sample_kernel
-    plot_samples
-    plot_kernel
-    [to-do] condition on data
-
-    """
-
-    def __init__(self, sp = 'none', cosmo = cosmo, zval = 0.1):
-
-
-        self.kernel = []
-        self.covariance_matrix = []
-        self.zval = zval
-        self.sp = sp
-        self.cosmo = cosmo
-        self.get_t_univ()
-        self.get_tarr()
-
-    def init_SPS():
-
-        mocksp = fsps.StellarPopulation(compute_vega_mags=False, zcontinuous=1,sfh=0, imf_type=1, logzsol=0.0, dust_type=2, dust2=0.0, add_neb_emission=True)
-        self.sp = mocksp
-        return
-
-    def make_MS_SFH(self, Mseed, timeax = np.arange(0,cosmo.age(0.0).value, 1e-3)):
-
-        # following the right skew peak function parametrization from Ciesla+17
-        # www.arxiv.org/pdf/1706.08531.pdf
-
-        # Mseed [int] is the seed mass of the SFH at z=5
-        # timeax [int, array] is any array of times along which the SFH is computed
-
-        Ap = 6e-3
-        taup = -0.84
-        A = Ap*np.exp(-np.log10(Mseed)/taup)
-
-        Ap = 47.39
-        taup = 3.12
-        mu = Ap*np.exp(-np.log10(Mseed)/taup)
-
-        Ap = 17.08
-        taup = 2.96
-        sigma = Ap*np.exp(-np.log10(Mseed)/taup)
-
-        slope = -0.56
-        norm = 7.03
-        rs = slope*np.log10(Mseed) + norm
-
-        sfh = A * (np.pi/2) * (sigma) * np.exp( -((timeax-mu)/rs) + (sigma/(2*rs))**2) * ssp.erfc( (sigma/(2*rs)) - ((timeax-mu)/sigma))
-        sfh[np.isnan(sfh)] = 1e-10
-        return sfh
-
-
-    def get_basesfh(self, sfhtype='const', mstar = None, mstar_seed = None):
-
-        if sfhtype == 'const':
-            self.basesfh = np.ones_like(self.tarr)* 1.0
-        elif sfhtype == 'MS':
-            sfh = self.make_MS_SFH(10**mstar_seed, self.tarr)
-            mtot = (np.trapz(x= self.tarr*1e9, y = sfh)*0.6)
-            sfh = sfh*(10**mstar)/mtot
-            if np.sum(sfh) == 0:
-                print(mstar, mstar_seed)
-            self.basesfh = np.log10(sfh)
-        else:
-            print('unknown basesfh type. set yourself with len of tarr.')
-        return
-
-
-    def get_t_univ(self):
-
-        self.t_univ = self.cosmo.age(self.zval).value
-        return
-
-    def get_tarr(self, n_tarr = 1000):
-
-        self.get_t_univ()
-        if n_tarr > 1:
-            self.tarr = np.linspace(0,self.t_univ, n_tarr)
-        elif n_tarr < 1:
-            self.tarr = np.arange(0,self.t_univ, n_tarr)
-        else:
-            raise('Undefined n_tarr: expected int or float.')
-        return
-
-
-    def get_covariance_matrix(self, show_prog = True, **kwargs):
-        """
-        Evaluate covariance matrix with a particular kernel
-        """
-
-        cov_matrix = np.zeros((len(self.tarr),len(self.tarr)))
-
-        if show_prog == True:
-            iterrange = tqdm(range(len(cov_matrix)))
-        else:
-            iterrange = range(len(cov_matrix))
-        for i in iterrange:
-            for j in range(len(cov_matrix)):
-                    cov_matrix[i,j] = self.kernel(self.tarr[i] - self.tarr[j], **kwargs)
-
-        return cov_matrix
-
-    def get_covariance_matrix_timedep(self, show_prog = True, **kwargs):
-        """
-        Evaluate covariance matrix with a particular kernel (NONSTATIONARY)
-        """
-
-        cov_matrix = np.zeros((len(self.tarr),len(self.tarr)))
-        if show_prog == True:
-            iterrange = tqdm(range(len(cov_matrix)))
-        else:
-            iterrange = range(len(cov_matrix))
-        for i in iterrange:
-            for j in range(len(cov_matrix)):
-                    cov_matrix[i,j] = self.kernel(self.tarr[i], self.tarr[j], **kwargs)
-
-        return cov_matrix
-
-    def sample_kernel(self, nsamp = 100, random_seed = 42, force_cov=False, stationary = True, show_prog = True, **kwargs):
-
-        mean_array = np.zeros_like(self.tarr)
-        if (len(self.covariance_matrix) == 0) or (force_cov == True):
-            if stationary == True:
-                self.covariance_matrix = self.get_covariance_matrix(show_prog = show_prog, **kwargs)
-            else:
-                self.covariance_matrix = self.get_covariance_matrix_timedep(show_prog = show_prog, **kwargs)
-#         else:
-#             print('using precomputed covariance matrix')
-
-        np.random.seed(random_seed)
-        samples = np.random.multivariate_normal(mean_array,self.covariance_matrix,size=nsamp)
-
-        return samples
-
-    def get_spec(self, nsamp, show_prog = False, calc_bands = True):
-
-        bands = fsps.list_filters()
-        filter_wavelengths = [fsps.filters.get_filter(bands[i]).lambda_eff for i in range(len(bands))]
-
-        all_lam, all_spec, all_spec_massnorm, all_mstar, all_emline_wav, all_emline_lum, all_emline_lum_massnorm, all_filtmags = [], [], [], [], [], [], [], []
-
-        if show_prog == True:
-            iterrange = tqdm(range(nsamp))
-        else:
-            iterrange = range(nsamp)
-        for i in iterrange:
-
-            specsfh = 10**(self.basesfh+self.samples[i, 0:])
-            if np.sum(specsfh) > 0:
-
-                self.sp.set_tabular_sfh(self.tarr, specsfh)
-                lam, spec = self.sp.get_spectrum(tage = self.t_univ)
-                mstar = self.sp.stellar_mass
-                if calc_bands == True:
-                    bandmags = self.sp.get_mags(tage = self.cosmo.age(self.zval).value, redshift = self.zval, bands = bands)
-
-                all_lam.append(lam)
-                all_spec.append(spec)
-                all_spec_massnorm.append(spec/mstar)
-                all_mstar.append(mstar)
-                all_emline_wav.append(self.sp.emline_wavelengths)
-                all_emline_lum.append(self.sp.emline_luminosity)
-                all_emline_lum_massnorm.append(self.sp.emline_luminosity / mstar)
-
-                if calc_bands == True:
-                    all_filtmags.append(bandmags)
-            else:
-                print(self.basesfh, self.samples[i,0:])
-
-        self.lam = all_lam
-        self.spec = all_spec
-        self.spec_massnorm = all_spec_massnorm
-        self.mstar = all_mstar
-        self.emline_wav = all_emline_wav
-        self.emline_lum = all_emline_lum
-        self.emline_lum_massnorm = all_emline_lum_massnorm
-
-        # not mass normalized
-        self.bands = bands
-        self.filter_wavelengths = filter_wavelengths
-        self.filtmags = all_filtmags
-
-        return
-
-
-    def calc_spectral_features_case(self, massnorm = True):
-
-        if massnorm == True:
-            spectra = self.spec_massnorm
-            emline_lum = self.emline_lum_massnorm
-        else:
-            spectra = self.spec
-            emline_lum = self.emline_lum
-
-        lam = self.lam[0]
-        emline_wavs = self.emline_wav
-
-        ha_lums = []
-        hdelta_ews = []
-        dn4000_vals = []
-
-        ha_lambda = 6562 # in angstrom
-
-        for i in (range(len(spectra))):
-
-    #         specflam = ujy_to_flam(spectra[i], lam)
-            specflam = spectra[i]
-
-            ha_line_index = np.argmin(np.abs(emline_wavs[i] - ha_lambda))
-            ha_lum = emline_lum[i][ha_line_index]
-            ha_lums.append(ha_lum)
-
-            hdelta_mask = (lam > 4030.) & (lam < 4082.)
-            hdelta_cont1_flux = np.mean(specflam[hdelta_mask])
-            hdelta_mask = (lam > 4122.0) & (lam < 4170.00)
-            hdelta_cont2_flux = np.mean(specflam[hdelta_mask])
-            hdelta_cont_flux_av = (hdelta_cont1_flux + hdelta_cont2_flux)/2
-            hdelta_mask = (lam > 4083.5) & (lam < 4122.5)
-            hdelta_emline_fluxes = np.trapz(x=lam[hdelta_mask],
-                                            y = (hdelta_cont_flux_av - specflam[hdelta_mask])/hdelta_cont_flux_av)
-            hdelta_emline_fluxratios = hdelta_emline_fluxes / hdelta_cont_flux_av
-            hdelta_ew = hdelta_emline_fluxes
-            hdelta_ews.append(hdelta_ew)
-
-            dn4000_mask1 = (lam>3850) & (lam < 3950)
-            dn4000_flux1 = np.mean(specflam[dn4000_mask1])
-            dn4000_mask2 = (lam>4000) & (lam < 4100)
-            dn4000_flux2 = np.mean(specflam[dn4000_mask2])
-            dn4000 = dn4000_flux2/dn4000_flux1
-            dn4000_vals.append(dn4000)
-
-            self.ha_lums = ha_lums
-            self.hdelta_ews = hdelta_ews
-            self.dn4000_vals = dn4000_vals
-
-        return
-
-    def calc_spectral_features(self, massnorm = True):
-
-        if massnorm == True:
-            spectra = self.spec_massnorm
-            emline_lum = self.emline_lum_massnorm
-        else:
-            spectra = self.spec
-            emline_lum = self.emline_lum
-
-        lam = self.lam[0]
-        emline_wavs = self.emline_wav
-
-        ha_lums = []
-        hdelta_ews = []
-        dn4000_vals = []
-        fuv_vals = []
-        nuv_vals = []
-        u_vals = []
-        caH_ews = []
-        caK_ews = []
-
-        ha_lambda = 6562 # in angstrom
-
-        for i in (range(len(spectra))):
-
-    #         specflam = ujy_to_flam(spectra[i], lam)
-            specflam = spectra[i]
-
-            ha_line_index = np.argmin(np.abs(emline_wavs[i] - ha_lambda))
-            ha_lum = emline_lum[i][ha_line_index]
-            ha_lums.append(ha_lum)
-
-            hdelta_mask = (lam > 4030.) & (lam < 4082.)
-            hdelta_cont1_flux = np.mean(specflam[hdelta_mask])
-            hdelta_mask = (lam > 4122.0) & (lam < 4170.00)
-            hdelta_cont2_flux = np.mean(specflam[hdelta_mask])
-            hdelta_cont_flux_av = (hdelta_cont1_flux + hdelta_cont2_flux)/2
-            hdelta_mask = (lam > 4083.5) & (lam < 4122.5)
-            hdelta_emline_fluxes = np.trapz(x=lam[hdelta_mask],
-                                            y = (hdelta_cont_flux_av - specflam[hdelta_mask])/hdelta_cont_flux_av)
-            hdelta_emline_fluxratios = hdelta_emline_fluxes / hdelta_cont_flux_av
-            hdelta_ew = hdelta_emline_fluxes
-            hdelta_ews.append(hdelta_ew)
-
-            lam_index_caK = np.argmin(np.abs(lam - 3933.66))
-            lam_index_caH = np.argmin(np.abs(lam - 3968.47))
-
-            caK_mask = (lam > 3907.0064) & (lam <  3929.5122)
-            caK_cont1_flux = np.mean(specflam[caK_mask])
-            caK_mask = (lam > 3941.2155) & (lam < 3961.0205)
-            caK_cont2_flux = np.mean(specflam[caK_mask])
-            caK_cont_flux_av = (caK_cont1_flux + caK_cont2_flux)/2
-
-            caK_mask = (lam > 3929.5122) & (lam < 3941.2155)
-            caK_emline_fluxes = np.trapz(x=lam[caK_mask],
-                                    y = (caK_cont_flux_av - specflam[caK_mask])/caK_cont_flux_av)
-            caK_ew = caK_emline_fluxes
-            caK_ews.append(caK_ew)
-
-            caH_mask = (lam > 3941.2155) & (lam < 3961.0205)
-            caH_cont1_flux = np.mean(specflam[caH_mask])
-            caH_mask = (lam > 3980.8257) & (lam < 3997.0299)
-            caH_cont2_flux = np.mean(specflam[caH_mask])
-            caH_cont_flux_av = (caH_cont1_flux + caH_cont2_flux)/2
-
-            caH_mask = (lam > 3961.0205) & (lam < 3980.8257)
-            caH_emline_fluxes = np.trapz(x=lam[caH_mask],
-                                    y = (caH_cont_flux_av - specflam[caH_mask])/caH_cont_flux_av)
-            caH_ew = caH_emline_fluxes
-            caH_ews.append(caH_ew)
-
-            dn4000_mask1 = (lam>3850) & (lam < 3950)
-            dn4000_flux1 = np.mean(specflam[dn4000_mask1])
-            dn4000_mask2 = (lam>4000) & (lam < 4100)
-            dn4000_flux2 = np.mean(specflam[dn4000_mask2])
-            dn4000 = dn4000_flux2/dn4000_flux1
-            dn4000_vals.append(dn4000)
-
-            fuv_lum_mask = (lam > 1300) & (lam < 1700)
-            fuv_flux1 = np.mean(specflam[fuv_lum_mask])
-            fuv_vals.append(fuv_flux1)
-
-            nuv_lum_mask = (lam > 1800) & (lam < 2600)
-            nuv_flux1 = np.mean(specflam[nuv_lum_mask])
-            nuv_vals.append(nuv_flux1)
-
-            u_lum_mask = (lam > 3000) & (lam < 3800)
-            u_flux1 = np.mean(specflam[u_lum_mask])
-            u_vals.append(u_flux1)
-
-        self.ha_lums = ha_lums
-        self.hdelta_ews = hdelta_ews
-        self.dn4000_vals = dn4000_vals
-        self.fuv_vals = fuv_vals
-        self.nuv_vals = nuv_vals
-        self.u_vals = u_vals
-        self.caH_ews = caH_ews
-        self.caK_ews = caK_ews
-
-        return ha_lums, hdelta_ews, dn4000_vals, fuv_vals, nuv_vals, u_vals, caH_ews, caK_ews
-
-
-    def plot_samples(self, nsamp = 100, random_seed = 42, plot_samples=5,plim=2, plotlog=False,save_fname = 'none', **kwargs):
-
-        samples = self.sample_kernel(nsamp = nsamp, random_seed = random_seed, **kwargs)
-
-        plt.figure(figsize=(12,6))
-        if plotlog == True:
-            plt.plot(self.tarr, 10**samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
-            plt.plot(self.tarr, 10**np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
-            plt.xlabel('time [arbitrary units]')
-            plt.ylabel('some quantity of interest')
-        else:
-            plt.plot(self.tarr, samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
-            plt.plot(self.tarr, np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
-            plt.fill_between(self.tarr, np.nanpercentile(samples.T,16,axis=1),
-                            np.nanpercentile(samples.T,84,axis=1),color='k',alpha=0.1,label='1$\sigma$')
-            plt.xlabel('time [arbitrary units]')
-            plt.ylabel('some quantity of interest')
-            plt.legend(edgecolor='w');
-            plt.ylim(-plim,plim);plt.title([kwargs])
-
-        if save_fname is not 'none':
-            print('saving figure as: ',save_fname)
-            plt.savefig(save_fname, bbox_inches='tight')
-        plt.show()
-
-    def plot_kernel(self, deltat = np.round(np.arange(-10,10,0.1),1),save_fname = 'none', **kwargs):
-
-        plt.figure(figsize=(12,6))
-        plt.plot(deltat, self.kernel(deltat, **kwargs),lw=3,
-                 label=kwargs)
-        plt.xlabel('$\Delta t$')
-        plt.ylabel('covariance');plt.title(kwargs)
-        #plt.text(-9,0.23,'Past');plt.text(7,0.23,'Future')
-        if save_fname is not 'none':
-            print('saving figure as: ',save_fname)
-            plt.savefig(save_fname, bbox_inches='tight')
-        plt.show()
-
-    def plot_kernel_and_draws(self, deltat = np.round(np.arange(-10,10,0.1),1), nsamp = 100, random_seed = 42, plot_samples=5,plim=2, plotlog=False,save_fname = 'none', **kwargs):
-
-
-        plt.figure(figsize=(24,6))
-
-        plt.subplot(1,2,1)
-        plt.plot(deltat, self.kernel(deltat, **kwargs),lw=3,
-                 label=kwargs)
-        plt.xlabel('$\Delta t$')
-        plt.ylabel('covariance');plt.title(['(kernel)',kwargs])
-        plt.xlim(-np.amax(self.tarr),np.amax(self.tarr));
-        #plt.text(-9,0.23,'Past');plt.text(7,0.23,'Future')
-
-        plt.subplot(1,2,2)
-
-        samples = self.sample_kernel(nsamp = nsamp, random_seed = random_seed, **kwargs)
-
-        if plotlog == True:
-            plt.plot(self.tarr, 10**samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
-            plt.plot(self.tarr, 10**np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
-            plt.xlabel('time [arbitrary units]')
-            plt.ylabel('log SFR(t)')
-        else:
-            plt.plot(self.tarr, samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
-            plt.plot(self.tarr, np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
-            plt.fill_between(self.tarr, np.nanpercentile(samples.T,16,axis=1),
-                            np.nanpercentile(samples.T,84,axis=1),color='k',alpha=0.1,label='1$\sigma$')
-            plt.xlabel('time [arbitrary units]')
-            plt.ylabel('log SFR(t)')
-            plt.legend(edgecolor='w');
-            plt.ylim(-plim,plim);
-        plt.title('samples drawn from kernel')
-
-        if save_fname is not 'none':
-            print('saving figure as: ',save_fname)
-            plt.savefig(save_fname, bbox_inches='tight')
-        plt.show()
-
-    def plot_kernel_sfhs_spec(self, deltat = np.round(np.arange(-10,10,0.1),1), nsamp = 100, random_seed = 42, plot_samples=5,plim=2, plotlog=False,save_fname = 'none', titlestr = '', massnorm = True, **kwargs):
-
-        plt.figure(figsize=(24,6))
-
-        plt.subplot(1,3,1)
-        plt.plot(deltat, self.kernel(deltat, **kwargs),lw=3,
-                 label=kwargs)
-        plt.xlabel('$\Delta t$ [Gyr]')
-        plt.ylabel('covariance');#plt.title(['(kernel)',kwargs])
-        plt.title(titlestr)
-        plt.xlim(-np.amax(self.tarr),np.amax(self.tarr));
-        #plt.text(-9,0.23,'Past');plt.text(7,0.23,'Future')
-
-        plt.subplot(1,3,2)
-
-        samples = self.sample_kernel(nsamp = nsamp, random_seed = random_seed, **kwargs)
-
-        if plotlog == True:
-            plt.plot(self.tarr, 10**samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
-            plt.plot(self.tarr, 10**np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
-            plt.xlabel('time [arbitrary units]')
-            plt.ylabel('log SFR(t)')
-        else:
-            plt.plot(self.tarr, samples.T[0:,0:plot_samples],'-',alpha=0.7,lw=1)
-            plt.plot(self.tarr, np.nanpercentile(samples.T,50,axis=1),'k',lw=3,label='median')
-            plt.fill_between(self.tarr, np.nanpercentile(samples.T,16,axis=1),
-                            np.nanpercentile(samples.T,84,axis=1),color='k',alpha=0.1,label='1$\sigma$')
-            plt.xlabel('time [Gyr]')
-            plt.ylabel('log SFR(t)')
-            plt.legend(edgecolor='w');
-            plt.ylim(-plim,plim);
-            #plt.xlim(0,1)
-        plt.title('samples drawn from kernel')
-
-        plt.subplot(1,3,3)
-
-        for i in range(plot_samples):
-            specsfh = 10**(self.basesfh+samples[i, 0:])
-            self.sp.set_tabular_sfh(self.tarr, specsfh)
-            lam, spec = self.sp.get_spectrum(tage = self.t_univ)
-            mstar = self.sp.stellar_mass
-
-            if massnorm == True:
-                plt.plot(lam, spec/mstar*1e10,alpha=0.7,lw=1)
-            else:
-                plt.plot(lam, spec,alpha=0.7,lw=1)
-
-        plt.xscale('log');plt.yscale('log')
-        plt.xlabel(r'$\lambda$ [rest-frame]')
-        plt.ylabel(r'$L_\nu$ [L$_\odot~/~$Hz]')
-        #plt.ylim(1e-6,1e-1)
-        plt.xlim(1e3,1e5)
-
-        plt.tight_layout()
-        if save_fname is not 'none':
-            print('saving figure as: ',save_fname)
-            plt.savefig(save_fname, bbox_inches='tight')
-        plt.show()
-
-
-
-def calc_spectral_features(spectra, emline_lum, lam, emline_wavs):
-
-    ha_lums = []
-    hdelta_ews = []
-    dn4000_vals = []
-    fuv_vals = []
-    nuv_vals = []
-    u_vals = []
-    caH_ews = []
-    caK_ews = []
-
-    ha_lambda = 6562 # in angstrom
-
-    for i in (range(len(spectra))):
-
-#         specflam = ujy_to_flam(spectra[i], lam)
-        specflam = spectra[i]
-
-        ha_line_index = np.argmin(np.abs(emline_wavs[i] - ha_lambda))
-        ha_lum = emline_lum[i][ha_line_index]
-        ha_lums.append(ha_lum)
-
-        hdelta_mask = (lam > 4030.) & (lam < 4082.)
-        hdelta_cont1_flux = np.mean(specflam[hdelta_mask])
-        hdelta_mask = (lam > 4122.0) & (lam < 4170.00)
-        hdelta_cont2_flux = np.mean(specflam[hdelta_mask])
-        hdelta_cont_flux_av = (hdelta_cont1_flux + hdelta_cont2_flux)/2
-
-        hdelta_mask = (lam > 4083.5) & (lam < 4122.5)
-        hdelta_emline_fluxes = np.trapz(x=lam[hdelta_mask],
-                                        y = (hdelta_cont_flux_av - specflam[hdelta_mask])/hdelta_cont_flux_av)
-
-        hdelta_emline_fluxratios = hdelta_emline_fluxes / hdelta_cont_flux_av
-
-        hdelta_ew = hdelta_emline_fluxes
-        hdelta_ews.append(hdelta_ew)
-
-        lam_index_caK = np.argmin(np.abs(lam - 3933.66))
-        lam_index_caH = np.argmin(np.abs(lam - 3968.47))
-
-        caK_mask = (lam > 3907.0064) & (lam <  3929.5122)
-        caK_cont1_flux = np.mean(specflam[caK_mask])
-        caK_mask = (lam > 3941.2155) & (lam < 3961.0205)
-        caK_cont2_flux = np.mean(specflam[caK_mask])
-        caK_cont_flux_av = (caK_cont1_flux + caK_cont2_flux)/2
-
-        caK_mask = (lam > 3929.5122) & (lam < 3941.2155)
-        caK_emline_fluxes = np.trapz(x=lam[caK_mask],
-                                y = (caK_cont_flux_av - specflam[caK_mask])/caK_cont_flux_av)
-        caK_ew = caK_emline_fluxes
-        caK_ews.append(caK_ew)
-
-        caH_mask = (lam > 3941.2155) & (lam < 3961.0205)
-        caH_cont1_flux = np.mean(specflam[caH_mask])
-        caH_mask = (lam > 3980.8257) & (lam < 3997.0299)
-        caH_cont2_flux = np.mean(specflam[caH_mask])
-        caH_cont_flux_av = (caH_cont1_flux + caH_cont2_flux)/2
-
-        caH_mask = (lam > 3961.0205) & (lam < 3980.8257)
-        caH_emline_fluxes = np.trapz(x=lam[caH_mask],
-                                y = (caH_cont_flux_av - specflam[caH_mask])/caH_cont_flux_av)
-        caH_ew = caH_emline_fluxes
-        caH_ews.append(caH_ew)
-
-
-#         if i<10:
-#             plt.plot(lam[(lam>4030) & (lam<4170)], specflam[(lam>4030) & (lam<4170)])
-#             plt.plot(lam[hdelta_mask], specflam[hdelta_mask])
-#             plt.plot(lam[hdelta_mask], np.ones((np.sum(hdelta_mask)))*hdelta_cont_flux_av)
-#             plt.show()
-#             print(hdelta_ew)
-
-
-#         specflam = spectra[i]
-        dn4000_mask1 = (lam>3850) & (lam < 3950)
-        dn4000_flux1 = np.mean(specflam[dn4000_mask1])
-        dn4000_mask2 = (lam>4000) & (lam < 4100)
-        dn4000_flux2 = np.mean(specflam[dn4000_mask2])
-#         dn4000_mask1 = (lam>3850) & (lam < 3950)
-#         dn4000_flux1 = np.mean(spectra[i][dn4000_mask1])
-#         dn4000_mask2 = (lam>4000) & (lam < 4100)
-#         dn4000_flux2 = np.mean(spectra[i][dn4000_mask2])
-        dn4000 = dn4000_flux2/dn4000_flux1
-        dn4000_vals.append(dn4000)
-
-        fuv_lum_mask = (lam > 1300) & (lam < 1700)
-        fuv_flux1 = np.mean(specflam[fuv_lum_mask])
-        fuv_vals.append(fuv_flux1)
-
-        nuv_lum_mask = (lam > 1800) & (lam < 2600)
-        nuv_flux1 = np.mean(specflam[nuv_lum_mask])
-        nuv_vals.append(nuv_flux1)
-
-        u_lum_mask = (lam > 3000) & (lam < 3800)
-        u_flux1 = np.mean(specflam[u_lum_mask])
-        u_vals.append(u_flux1)
-
-    return ha_lums, hdelta_ews, dn4000_vals, fuv_vals, nuv_vals, u_vals, caH_ews, caK_ews
\ No newline at end of file

From e9b800d9df2c698c866cef66aa6029dcaba7e196 Mon Sep 17 00:00:00 2001
From: Jenny Wan <jtw.cpc@gmail.com>
Date: Sun, 14 Apr 2024 21:20:32 -0700
Subject: [PATCH 071/132] Delete prospect/models/gp_sfh_kernels.py

---
 prospect/models/gp_sfh_kernels.py | 233 ------------------------------
 1 file changed, 233 deletions(-)
 delete mode 100644 prospect/models/gp_sfh_kernels.py

diff --git a/prospect/models/gp_sfh_kernels.py b/prospect/models/gp_sfh_kernels.py
deleted file mode 100644
index 07e3e484..00000000
--- a/prospect/models/gp_sfh_kernels.py
+++ /dev/null
@@ -1,233 +0,0 @@
-# kernels corresponding to the various models used in the paper
-# 1. White kernel: white_kernel
-# 2. Damped RW: damped_random_walk_kernel
-# 3. Regulator model: regulator_model_kernel
-# 4b. extended_regulator_model_kernel
-# 4b. extended_regulator_model_kernel_old
-# 4c. extended_regulator_model_kernel_paramlist_old
-
-import numpy as np
-
-# ---------------- suggested model kernel values -------------------------------
-
-kernel_params_MW_1dex = [1.0, 2500/1e3, 150/1e3, 0.03, 25/1e3]
-kernel_params_dwarf_1dex = [1.0, 30/1e3, 150/1e3, 0.03, 10/1e3]
-kernel_params_noon_1dex = [1.0, 200/1e3, 100/1e3, 0.03, 50/1e3]
-kernel_params_highz_1dex = [1.0, 15/1e3, 16/1e3, 0.03, 6/1e3]
-
-def convert_sigma_obs_to_ExReg(sigma_target, sigma_GMC_to_reg_ratio = 0.03):
-    return np.sqrt(sigma_target**2/(1 + (sigma_GMC_to_reg_ratio)**2)), sigma_GMC_to_reg_ratio*np.sqrt(sigma_target**2/(1 + (sigma_GMC_to_reg_ratio)**2))
-
-TCF20_scattervals = [0.17, 0.53, 0.24, 0.27]
-TCF20_GMC_to_reg_ratio = 0.03
-
-temp_sigma, temp_sigma_GMC = convert_sigma_obs_to_ExReg(TCF20_scattervals[0], TCF20_GMC_to_reg_ratio)
-kernel_params_MW_TCF20 = [temp_sigma, 2500/1e3, 150/1e3, temp_sigma_GMC, 25/1e3]
-temp_sigma, temp_sigma_GMC = convert_sigma_obs_to_ExReg(TCF20_scattervals[1], TCF20_GMC_to_reg_ratio)
-kernel_params_dwarf_TCF20 = [temp_sigma, 30/1e3, 150/1e3, temp_sigma_GMC, 10/1e3]
-temp_sigma, temp_sigma_GMC = convert_sigma_obs_to_ExReg(TCF20_scattervals[2], TCF20_GMC_to_reg_ratio)
-kernel_params_noon_TCF20 = [temp_sigma, 200/1e3, 100/1e3, temp_sigma_GMC, 50/1e3]
-temp_sigma, temp_sigma_GMC = convert_sigma_obs_to_ExReg(TCF20_scattervals[3], TCF20_GMC_to_reg_ratio)
-kernel_params_highz_TCF20 = [temp_sigma, 15/1e3, 16/1e3, temp_sigma_GMC, 6/1e3]
-
-# --------------------- kernels -------------------------------------
-
-def white_kernel(delta_t, sigma=1.0, base_e_to_10 = False):
-    """
-    A basic implementation of a white noise kernel, with one parameter:
-    A: sigma (not a real parameter in this case)
-    """
-    if base_e_to_10 == True:
-        sigma = sigma*np.log10(np.e)
-
-    kernel_val = np.zeros_like(delta_t)
-    kernel_val[delta_t == 0] = sigma**2
-    return kernel_val
-
-def damped_random_walk_kernel(delta_t, sigma=1.0, tau_eq = 1.0, base_e_to_10 = False):
-    """
-    A basic implementation of a damped random walk kernel, with two parameters:
-    sigma: \sigma, the amount of overall variance
-    tau_eq: equilibrium timescale
-
-    """
-    if base_e_to_10 == True:
-        sigma = sigma*np.log10(np.e)
-
-    tau = np.abs(delta_t)
-    kernel_val = (sigma**2) * np.exp(- tau / tau_eq)
-    return kernel_val
-
-def regulator_model_kernel(delta_t, sigma=1.0, tau_eq = 1.0, tau_in = 0.5, base_e_to_10 = False):
-    """
-    A basic implementation of the regulator model kernel, with five parameters:
-    sigma: \sigma, the amount of overall variance
-    tau_eq: equilibrium timescale
-    tau_x: inflow correlation timescale (includes 2pi factor)
-    sigma_gmc: gmc variability
-    tau_l: cloud lifetime
-
-    """
-
-    # in TCF20, this is defined in base e, so convert to base 10
-    if base_e_to_10 == True:
-        sigma = sigma*np.log10(np.e)
-
-    tau = np.abs(delta_t)
-
-    if tau_in == tau_eq:
-        c_reg = sigma**2 * (1 + tau/tau_eq) * (np.exp(-tau/tau_eq))
-    else:
-        c_reg = sigma**2 / (tau_in - tau_eq) * (tau_in*np.exp(-tau/tau_in) - tau_eq*np.exp(-tau/tau_eq))
-
-    # if tau_in == tau_eq:
-    #     c_reg = sigma**2 * (1+ np.abs(delta_t)/tau_eq) * (np.exp(-np.abs(delta_t)/tau_eq)/(2*tau_eq))
-    # else:
-    #     c_reg = sigma**2 / (tau_in**2 - tau_eq**2) * (tau_in * np.exp(-np.abs(delta_t) / tau_in) - tau_eq * np.exp(-np.abs(delta_t) / tau_eq))
-
-    return c_reg
-
-def extended_regulator_model_kernel(delta_t, sigma=1.0, tau_eq = 1.0, tau_in = 0.5, sigma_gmc = 0.01, tau_gmc = 0.001, base_e_to_10 = False, return_components = False):
-    """
-    A basic implementation of the regulator model kernel, with five parameters:
-    sigma: \sigma_{gas}, the amount of overall variance
-    tau_eq: equilibrium timescale
-    tau_x: inflow correlation timescale (includes 2pi factor)
-    sigma_gmc: gmc variability
-    tau_l: cloud lifetime
-
-    """
-
-    if base_e_to_10 == True:
-        # in TCF20, this is defined in base e, so convert to base 10
-        sigma = sigma*np.log10(np.e)
-        sigma_gmc = sigma_gmc*np.log10(np.e)
-
-    tau = np.abs(delta_t)
-
-    if tau_in == tau_eq:
-        c_reg = sigma**2 * (1 + tau/tau_eq) * (np.exp(-tau/tau_eq))
-    else:
-        c_reg = sigma**2 / (tau_in - tau_eq) * (tau_in*np.exp(-tau/tau_in) - tau_eq*np.exp(-tau/tau_eq))
-
-    c_gmc = sigma_gmc**2 * np.exp(-tau/tau_gmc)
-
-    kernel_val = (c_reg + c_gmc)
-
-    if return_components == True:
-        return kernel_val, c_reg, c_gmc
-    else:
-        return kernel_val
-
-def extended_regulator_model_kernel_paramlist(delta_t, kernel_params, base_e_to_10 = False):
-    """
-    A basic implementation of the regulator model kernel, with five parameters:
-    kernel_params = [sigma, tau_eq, tau_in, sigma_gmc, tau_gmc]
-    sigma: \sigma, the amount of overall variance
-    tau_eq: equilibrium timescale
-    tau_x: inflow correlation timescale (includes 2pi factor)
-    sigma_gmc: gmc variability
-    tau_l: cloud lifetime
-
-    """
-
-    sigma, tau_eq, tau_in, sigma_gmc, tau_gmc = kernel_params
-
-    if base_e_to_10 == True:
-        # in TCF20, this is defined in base e, so convert to base 10
-        sigma = sigma*np.log10(np.e)
-        sigma_gmc = sigma_gmc*np.log10(np.e)
-
-    tau = np.abs(delta_t)
-
-    if tau_in == tau_eq:
-        c_reg = sigma**2 * (1 + tau/tau_eq) * (np.exp(-tau/tau_eq))
-    else:
-        c_reg = sigma**2 / (tau_in - tau_eq) * (tau_in*np.exp(-tau/tau_in) - tau_eq*np.exp(-tau/tau_eq))
-
-    c_gmc = sigma_gmc**2 * np.exp(-tau/tau_gmc)
-
-    kernel_val = (c_reg + c_gmc)
-    return kernel_val
-
-def extended_regulator_model_PSD(f, sigma=1.0, tau_eq = 1.0, tau_in = 0.5, sigma_gmc = 0.01, tau_gmc = 0.001, base_e_to_10 = False):
-    """
-    A basic implementation of the regulator model kernel, with five parameters:
-    sigma: \sigma, the amount of overall variance
-    tau_eq: equilibrium timescale
-    tau_x: inflow correlation timescale (includes 2pi factor)
-    sigma_gmc: gmc variability
-    tau_l: cloud lifetime
-
-    """
-
-    if base_e_to_10 == True:
-        # in TCF20, this is defined in base e, so convert to base 10
-        sigma_base10 = sigma*np.log10(np.e)
-        sigma_gmc_base10 = sigma_gmc*np.log10(np.e)
-    else:
-        sigma_base10 = sigma
-        sigma_gmc_base10 = sigma_gmc
-
-    tpi = 2*np.pi
-
-    psd_reg = sigma_base10**2 / (1 + ((tpi*tau_eq*1e3)**2 + (tpi*tau_in*1e3)**2)*(f**2) + ((tpi*tau_eq*1e3)**2 * (tpi*tau_in*1e3)**2)*(f**4))
-    psd_gmc = sigma_gmc_base10**2 / (1 + (tpi*tau_gmc*1e3*f)**2)
-    psd_val = psd_reg + psd_gmc
-
-    return psd_val, psd_reg, psd_gmc
-
-# ---------------------------------------------------------------------
-# ------------------------ deprecated ---------------------------------
-# ---------------------------------------------------------------------
-
-def extended_regulator_model_kernel_old(delta_t, sigma=1.0, tau_eq = 1.0, tau_in = 0.5, sigma_gmc = 0.01, tau_gmc = 0.001, base_e_to_10 = False):
-    """
-    A basic implementation of the regulator model kernel, with five parameters:
-    sigma: \sigma_{gas}, the amount of overall variance
-    tau_eq: equilibrium timescale
-    tau_x: inflow correlation timescale (includes 2pi factor)
-    sigma_gmc: gmc variability
-    tau_l: cloud lifetime
-
-    """
-
-    if base_e_to_10 == True:
-        # in TCF20, this is defined in base e, so convert to base 10
-        sigma = sigma*np.log10(np.e)
-        sigma_gmc = sigma_gmc*np.log10(np.e)
-
-    if tau_in == tau_eq:
-        c_reg = sigma**2 * (1+ np.abs(delta_t)/tau_eq) * (np.exp(-np.abs(delta_t)/tau_eq)/(2*tau_eq))
-    else:
-        c_reg = sigma**2 / (tau_in**2 - tau_eq**2) * (tau_in * np.exp(-np.abs(delta_t) / tau_in) - tau_eq * np.exp(-np.abs(delta_t) / tau_eq))
-    c_gmc = sigma_gmc**2 / (2*tau_gmc) * np.exp(-np.abs(delta_t)/tau_gmc)
-    kernel_val = (c_reg + c_gmc)
-    return kernel_val
-
-def extended_regulator_model_kernel_paramlist_old(delta_t, kernel_params, base_e_to_10 = False):
-    """
-    A basic implementation of the regulator model kernel, with five parameters:
-    kernel_params = [sigma, tau_eq, tau_in, sigma_gmc, tau_gmc]
-    sigma: \sigma, the amount of overall variance
-    tau_eq: equilibrium timescale
-    tau_x: inflow correlation timescale (includes 2pi factor)
-    sigma_gmc: gmc variability
-    tau_l: cloud lifetime
-
-    """
-
-    sigma, tau_eq, tau_in, sigma_gmc, tau_gmc = kernel_params
-
-    if base_e_to_10 == True:
-        # in TCF20, this is defined in base e, so convert to base 10
-        sigma = sigma*np.log10(np.e)
-        sigma_gmc = sigma_gmc*np.log10(np.e)
-
-    if tau_in == tau_eq:
-        c_reg = sigma**2 * (1+ np.abs(delta_t)/tau_eq) * (np.exp(-np.abs(delta_t)/tau_eq)/(2*tau_eq))
-    else:
-        c_reg = sigma**2 / (tau_in**2 - tau_eq**2) * (tau_in * np.exp(-np.abs(delta_t) / tau_in) - tau_eq * np.exp(-np.abs(delta_t) / tau_eq))
-    c_gmc = sigma_gmc**2 / (2*tau_gmc) * np.exp(-np.abs(delta_t)/tau_gmc)
-    kernel_val = (c_reg + c_gmc)
-    return kernel_val
\ No newline at end of file

From 4f432d1829b3b3f59f8e6dd729af7c765487c6fc Mon Sep 17 00:00:00 2001
From: Jenny Wan <jtw.cpc@gmail.com>
Date: Sun, 14 Apr 2024 21:23:01 -0700
Subject: [PATCH 072/132] Added modules to handle the stochastic SFH prior

---
 prospect/models/hyperparam_transforms.py | 176 +++++++++++++++++++++++
 prospect/models/hyperparameters.py       | 109 ++++++++++++++
 prospect/models/parameters.py            | 115 ++++-----------
 prospect/models/sedmodel.py              |  14 +-
 prospect/models/templates.py             |  20 +--
 prospect/models/transforms.py            |  71 ++++-----
 6 files changed, 373 insertions(+), 132 deletions(-)
 create mode 100644 prospect/models/hyperparam_transforms.py
 create mode 100644 prospect/models/hyperparameters.py

diff --git a/prospect/models/hyperparam_transforms.py b/prospect/models/hyperparam_transforms.py
new file mode 100644
index 00000000..37a273dc
--- /dev/null
+++ b/prospect/models/hyperparam_transforms.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""hyperparam_transforms.py -- This module contains parameter transformations that are
+used in the stochastic SFH prior.
+
+They can be used as ``"depends_on"`` entries in parameter specifications.
+"""
+
+import numpy as np
+from astropy.cosmology import FlatLambdaCDM
+
+__all__ = ["get_sfr_covar", "sfr_covar_to_sfr_ratio_covar"]
+           
+           
+# --------------------------------------
+# --- Functions/transforms for stochastic SFH prior ---
+# --------------------------------------
+
+
+# Creating a base class that simplifies a lot of things.
+# The way this is set up, you can pass a kernel as an argument
+# to compute the covariance matrix and draw samples from it.
+class simple_GP_sfh():
+
+    """
+    A class that creates and holds information about a specific
+    kernel, and can generate samples from it.
+
+    Attributes
+    ----------
+    tarr: fiducial time array used to draw samples
+    kernel: accepts an input function as an argument,
+        of the format:
+
+            def kernel_function(delta_t, **kwargs):
+                ... function interior ...
+                return kernel_val[array of len(delta_t)]
+
+    Methods
+    -------
+    get_covariance_matrix
+        [although this has double for loops for maximum flexibility
+        with generic kernel functions, it only has to be computed once,
+        which makes drawing random samples super fast once it's computed.]
+    sample_kernel
+    plot_samples
+    plot_kernel
+    [to-do] condition on data
+
+    """
+
+    def __init__(self, sp = 'none', cosmo = FlatLambdaCDM(H0=70, Om0=0.3), zval = 0.1):
+
+
+        self.kernel = []
+        self.covariance_matrix = []
+        self.zval = zval
+        self.sp = sp
+        self.cosmo = cosmo
+        self.get_t_univ()
+        self.get_tarr()
+
+
+    def get_t_univ(self):
+
+        self.t_univ = self.cosmo.age(self.zval).value
+        return
+
+    def get_tarr(self, n_tarr = 1000):
+
+        self.get_t_univ()
+        if n_tarr > 1:
+            self.tarr = np.linspace(0,self.t_univ, n_tarr)
+        elif n_tarr < 1:
+            self.tarr = np.arange(0,self.t_univ, n_tarr)
+        else:
+            raise('Undefined n_tarr: expected int or float.')
+        return
+
+
+    def get_covariance_matrix(self, show_prog = True, **kwargs):
+        """
+        Evaluate covariance matrix with a particular kernel
+        """
+
+        cov_matrix = np.zeros((len(self.tarr),len(self.tarr)))
+
+        if show_prog == True:
+            iterrange = range(len(cov_matrix))
+        else:
+            iterrange = range(len(cov_matrix))
+        for i in iterrange:
+            for j in range(len(cov_matrix)):
+                    cov_matrix[i,j] = self.kernel(self.tarr[i] - self.tarr[j], **kwargs)
+
+        return cov_matrix
+
+
+
+def extended_regulator_model_kernel_paramlist(delta_t, kernel_params, base_e_to_10 = False):
+    """
+    A basic implementation of the regulator model kernel, with five parameters:
+    kernel_params = [sigma, tau_eq, tau_in, sigma_gmc, tau_gmc]
+    sigma: \sigma, the amount of overall variance
+    tau_eq: equilibrium timescale
+    tau_x: inflow correlation timescale (includes 2pi factor)
+    sigma_gmc: gmc variability
+    tau_l: cloud lifetime
+
+    """
+
+    sigma, tau_eq, tau_in, sigma_gmc, tau_gmc = kernel_params
+
+    if base_e_to_10 == True:
+        # in TCF20, this is defined in base e, so convert to base 10
+        sigma = sigma*np.log10(np.e)
+        sigma_gmc = sigma_gmc*np.log10(np.e)
+
+    tau = np.abs(delta_t)
+
+    if tau_in == tau_eq:
+        c_reg = sigma**2 * (1 + tau/tau_eq) * (np.exp(-tau/tau_eq))
+    else:
+        c_reg = sigma**2 / (tau_in - tau_eq) * (tau_in*np.exp(-tau/tau_in) - tau_eq*np.exp(-tau/tau_eq))
+
+    c_gmc = sigma_gmc**2 * np.exp(-tau/tau_gmc)
+
+    kernel_val = (c_reg + c_gmc)
+    return kernel_val
+
+
+
+def get_sfr_covar(psd_params, agebins=[], **extras):
+    
+    """
+    Caluclates SFR covariance matrix for a given set of PSD parameters and agebins
+    PSD parameters must be in the order: [sigma_reg, tau_eq, tau_in, sigma_dyn, tau_dyn]
+    
+    Returns
+    -------
+    covar_matrix: (Nbins, Nbins)-dim array of covariance values for SFR
+    """
+
+    bincenters = np.array([np.mean(agebins[i]) for i in range(len(agebins))])
+    bincenters = (10**bincenters)/1e9
+    case1 = simple_GP_sfh()
+    case1.tarr = bincenters
+    case1.kernel = extended_regulator_model_kernel_paramlist
+    covar_matrix = case1.get_covariance_matrix(kernel_params = psd_params, show_prog=False)
+    
+    return covar_matrix
+
+
+def sfr_covar_to_sfr_ratio_covar(covar_matrix):
+    
+    """
+    Caluclates log SFR ratio covariance matrix from SFR covariance matrix
+    
+    Returns
+    -------
+    sfr_ratio_covar: (Nbins-1, Nbins-1)-dim array of covariance values for log SFR
+    """
+    
+    dim = covar_matrix.shape[0]
+    
+    sfr_ratio_covar = []
+    
+    for i in range(dim-1):
+        row = []
+        for j in range(dim-1):
+            cov = covar_matrix[i][j] - covar_matrix[i+1][j] - covar_matrix[i][j+1] + covar_matrix[i+1][j+1]
+            row.append(cov)
+        sfr_ratio_covar.append(row)
+    
+    return np.array(sfr_ratio_covar)
\ No newline at end of file
diff --git a/prospect/models/hyperparameters.py b/prospect/models/hyperparameters.py
new file mode 100644
index 00000000..5c64815b
--- /dev/null
+++ b/prospect/models/hyperparameters.py
@@ -0,0 +1,109 @@
+"""
+hyperparameters.py 
+
+
+This class gets all all the ProspectorParams functionality, but it overrides the _prior_product and prior_transform methods
+to sample the hyperparameters & log SFR ratios of the stochastic SFH prior.
+"""
+
+import numpy as np
+import scipy
+from . import priors
+from . import hyperparam_transforms as transforms
+from .parameters import ProspectorParams
+
+__all__ = ["ProspectorHyperParams"]
+
+
+class ProspectorHyperParams(ProspectorParams):
+
+    def _prior_product(self, theta, **extras):
+        """Return a scalar which is the ln of the product of the prior
+        probabilities for each element of theta.  Requires that the prior
+        functions are defined in the theta descriptor.
+
+        :param theta:
+            Iterable containing the free model parameter values. ndarray of
+            shape ``(ndim,)``
+
+        :returns lnp_prior:
+            The natural log of the product of the prior probabilities for these
+            parameter values.
+        """
+        lnp_prior = 0
+                
+        hyper_params = ['sigma_reg', 'tau_eq', 'tau_in', 'sigma_dyn', 'tau_dyn']
+        psd_params = np.zeros(len(hyper_params))
+        
+        for i, p in enumerate(hyper_params):
+            if self.config_dict[p]['isfree']:
+                inds = self.theta_index[p]
+                psd_params[i] = theta[..., inds][0]
+                func = self.config_dict[p]['prior']
+                this_prior = np.sum(func(theta[..., inds]), axis=-1)
+                lnp_prior += this_prior
+            else:
+                psd_params[i] = self.config_dict[p]['init']
+                
+        sfr_covar_matrix = transforms.get_sfr_covar(psd_params, agebins=self.config_dict['agebins']['init'])
+        sfr_ratio_covar_matrix = transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar_matrix)
+        nbins = len(self.config_dict['agebins']['init'])
+        logsfr_ratio_prior = scipy.stats.multivariate_normal(mean=[0.]*(nbins-1), cov=sfr_ratio_covar_matrix)
+        inds = self.theta_index['logsfr_ratios']
+        this_prior = np.sum(np.log(logsfr_ratio_prior.pdf(theta[..., inds])))
+        lnp_prior += this_prior
+    
+        for k, inds in list(self.theta_index.items()):
+            if (k in hyper_params) or (k == 'logsfr_ratios'):
+                continue
+            func = self.config_dict[k]['prior']
+            this_prior = np.sum(func(theta[..., inds]), axis=-1)
+            lnp_prior += this_prior
+            
+        return lnp_prior
+    
+
+    def prior_transform(self, unit_coords):
+        """Go from unit cube to parameter space, for nested sampling.
+
+        :param unit_coords:
+            Coordinates in the unit hyper-cube. ndarray of shape ``(ndim,)``.
+
+        :returns theta:
+            The parameter vector corresponding to the location in prior CDF
+            corresponding to ``unit_coords``. ndarray of shape ``(ndim,)``
+        """
+        
+        theta = np.zeros(len(unit_coords))
+        
+        hyper_params = ['sigma_reg', 'tau_eq', 'tau_in', 'sigma_dyn', 'tau_dyn']
+        psd_params = np.zeros(len(hyper_params))
+        
+                
+        for i, p in enumerate(hyper_params):
+            if self.config_dict[p]['isfree']:
+                func = self.config_dict[p]['prior'].unit_transform
+                inds = self.theta_index[p]
+                psd_params[i] = func(unit_coords[inds])
+                theta[inds] = psd_params[i]
+            else:
+                psd_params[i] = self.config_dict[p]['init']
+            
+        sfr_covar_matrix = transforms.get_sfr_covar(psd_params, agebins=self.config_dict['agebins']['init'])
+        sfr_ratio_covar_matrix = transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar_matrix)
+        logsfr_ratio_prior = priors.MultiVariateNormal(mean=0, Sigma=sfr_ratio_covar_matrix)
+        x = unit_coords[self.theta_index['logsfr_ratios']]
+        logsfr_ratios = logsfr_ratio_prior.unit_transform(x)
+        theta[self.theta_index['logsfr_ratios']] = logsfr_ratios
+                    
+        for k, inds in list(self.theta_index.items()):
+            if (k in hyper_params) or (k == 'logsfr_ratios'):
+                continue
+            func = self.config_dict[k]['prior'].unit_transform
+            theta[inds] = func(unit_coords[inds])
+            
+        return theta
+        
+        
+        
+        
diff --git a/prospect/models/parameters.py b/prospect/models/parameters.py
index 249367ba..01b2509e 100644
--- a/prospect/models/parameters.py
+++ b/prospect/models/parameters.py
@@ -14,8 +14,9 @@
 from . import priors
 from .templates import describe
 import scipy
-from gp_sfh import *
-import gp_sfh_kernels
+from . import hyperparam_transforms as transforms
+#from gp_sfh import *
+#import gp_sfh_kernels
 
 __all__ = ["ProspectorParams"]
 
@@ -169,7 +170,6 @@ def prior_product(self, theta, nested=False, **extras):
             The natural log of the prior probability at ``theta``
         """
         lpp = self._prior_product(theta)
-        # print(lpp)
         if nested & np.any(np.isfinite(lpp)):
             return 0.0
         return lpp
@@ -189,40 +189,10 @@ def _prior_product(self, theta, **extras):
         """
         lnp_prior = 0
         
-        hyper_params = ['sigma_reg', 'tau_eq', 'tau_in', 'sigma_dyn', 'tau_dyn']
-        psd_params = np.zeros(len(hyper_params))
-        
-        if any(hp in self.theta_index.keys() for hp in hyper_params):
-            for i, p in enumerate(hyper_params):
-                if self.config_dict[p]['isfree']:
-                    inds = self.theta_index[p]
-                    psd_params[i] = theta[..., inds][0]
-                    func = self.config_dict[p]['prior']
-                    this_prior = np.sum(func(theta[..., inds]), axis=-1)
-                    lnp_prior += this_prior
-                else:
-                    psd_params[i] = self.config_dict[p]['init']
-                    
-            sfr_covar_matrix = get_sfr_covar(psd_params, agebins=self.config_dict['agebins']['init'])
-            sfr_ratio_covar_matrix = sfr_covar_to_sfr_ratio_covar(sfr_covar_matrix)
-            nbins = len(self.config_dict['agebins']['init'])
-            logsfr_ratio_prior = scipy.stats.multivariate_normal(mean=[0.]*(nbins-1), cov=sfr_ratio_covar_matrix)
-            inds = self.theta_index['logsfr_ratios']
-            this_prior = np.sum(np.log(logsfr_ratio_prior.pdf(theta[..., inds])))
-            #this_prior = np.sum(logsfr_ratio_prior(theta[..., inds]), axis=-1)
+        for k, inds in list(self.theta_index.items()):
+            func = self.config_dict[k]['prior']
+            this_prior = np.sum(func(theta[..., inds]), axis=-1)
             lnp_prior += this_prior
-        
-            for k, inds in list(self.theta_index.items()):
-                if (k in hyper_params) or (k == 'logsfr_ratios'):
-                    continue
-                func = self.config_dict[k]['prior']
-                this_prior = np.sum(func(theta[..., inds]), axis=-1)
-                lnp_prior += this_prior
-        else:
-            for k, inds in list(self.theta_index.items()):
-                func = self.config_dict[k]['prior']
-                this_prior = np.sum(func(theta[..., inds]), axis=-1)
-                lnp_prior += this_prior
 
         return lnp_prior
 
@@ -237,40 +207,11 @@ def prior_transform(self, unit_coords):
             corresponding to ``unit_coords``. ndarray of shape ``(ndim,)``
         """
         theta = np.zeros(len(unit_coords))
-        
-        hyper_params = ['sigma_reg', 'tau_eq', 'tau_in', 'sigma_dyn', 'tau_dyn']
-        psd_params = np.zeros(len(hyper_params))
-        
-        
-        if any(hp in self.theta_index.keys() for hp in hyper_params):
-        
-            for i, p in enumerate(hyper_params):
-                if self.config_dict[p]['isfree']:
-                    func = self.config_dict[p]['prior'].unit_transform
-                    inds = self.theta_index[p]
-                    psd_params[i] = func(unit_coords[inds])
-                    theta[inds] = psd_params[i]
-                else:
-                    psd_params[i] = self.config_dict[p]['init']
-                
-            sfr_covar_matrix = get_sfr_covar(psd_params, agebins=self.config_dict['agebins']['init'])#, **self.params)
-            sfr_ratio_covar_matrix = sfr_covar_to_sfr_ratio_covar(sfr_covar_matrix)
-            logsfr_ratio_prior = priors.MultiVariateNormal(mean=0, Sigma=sfr_ratio_covar_matrix)
-            x = unit_coords[self.theta_index['logsfr_ratios']]
-            logsfr_ratios = logsfr_ratio_prior.unit_transform(x)
-            theta[self.theta_index['logsfr_ratios']] = logsfr_ratios
-                        
-            for k, inds in list(self.theta_index.items()):
-                if (k in hyper_params) or (k == 'logsfr_ratios'):
-                    continue
-                func = self.config_dict[k]['prior'].unit_transform
-                theta[inds] = func(unit_coords[inds])
-            
-        else:
 
-            for k, inds in list(self.theta_index.items()):
-                func = self.config_dict[k]['prior'].unit_transform
-                theta[inds] = func(unit_coords[inds])
+        for k, inds in list(self.theta_index.items()):
+            
+            func = self.config_dict[k]['prior'].unit_transform
+            theta[inds] = func(unit_coords[inds])
         
         return theta
 
@@ -476,30 +417,30 @@ def pdict_to_plist(pdict, order=None):
     return plist
 
 
-def get_sfr_covar(psd_params, agebins=[], **extras):
+# def get_sfr_covar(psd_params, agebins=[], **extras):
 
-    bincenters = np.array([np.mean(agebins[i]) for i in range(len(agebins))])
-    bincenters = (10**bincenters)/1e9
-    case1 = simple_GP_sfh()
-    case1.tarr = bincenters
-    case1.kernel = gp_sfh_kernels.extended_regulator_model_kernel_paramlist
-    covar_matrix = case1.get_covariance_matrix(kernel_params = psd_params, show_prog=False)
+#     bincenters = np.array([np.mean(agebins[i]) for i in range(len(agebins))])
+#     bincenters = (10**bincenters)/1e9
+#     case1 = simple_GP_sfh()
+#     case1.tarr = bincenters
+#     case1.kernel = gp_sfh_kernels.extended_regulator_model_kernel_paramlist
+#     covar_matrix = case1.get_covariance_matrix(kernel_params = psd_params, show_prog=False)
 
-    return covar_matrix
+#     return covar_matrix
 
 
-def sfr_covar_to_sfr_ratio_covar(covar_matrix):
+# def sfr_covar_to_sfr_ratio_covar(covar_matrix):
     
-    dim = covar_matrix.shape[0]
+#     dim = covar_matrix.shape[0]
     
-    sfr_ratio_covar = []
+#     sfr_ratio_covar = []
     
-    for i in range(dim-1):
-        row = []
-        for j in range(dim-1):
-            cov = covar_matrix[i][j] - covar_matrix[i+1][j] - covar_matrix[i][j+1] + covar_matrix[i+1][j+1]
-            row.append(cov)
-        sfr_ratio_covar.append(row)
+#     for i in range(dim-1):
+#         row = []
+#         for j in range(dim-1):
+#             cov = covar_matrix[i][j] - covar_matrix[i+1][j] - covar_matrix[i][j+1] + covar_matrix[i+1][j+1]
+#             row.append(cov)
+#         sfr_ratio_covar.append(row)
     
-    return np.array(sfr_ratio_covar)
+#     return np.array(sfr_ratio_covar)
 
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index c41649c9..2f8bdc01 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -15,6 +15,7 @@
 from sedpy.observate import getSED
 
 from .parameters import ProspectorParams
+from .hyperparameters import ProspectorHyperParams
 from ..sources.constants import to_cgs_at_10pc as to_cgs
 from ..sources.constants import cosmo, lightspeed, ckms, jansky_cgs
 from ..utils.smoothing import smoothspec
@@ -22,7 +23,8 @@
 
 __all__ = ["SpecModel", "PolySpecModel", "SplineSpecModel",
            "LineSpecModel", "AGNSpecModel",
-           "SedModel", "PolySedModel", "PolyFitModel"]
+           "SedModel", "PolySedModel", "PolyFitModel",
+           "HyperSpecModel", "HyperPolySpecModel"]
 
 
 class SpecModel(ProspectorParams):
@@ -697,7 +699,7 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
             self._poly_coeffs = c
         else:
             poly = np.zeros_like(self._outwave)
-
+            
         return (1.0 + poly)
 
 
@@ -1298,6 +1300,14 @@ def spec_calibration(self, theta=None, obs=None, **kwargs):
                 return np.exp(self.params.get('spec_norm', 0) + poly)
         else:
             return 1.0 * self.params.get('spec_norm', 1.0)
+        
+        
+class HyperSpecModel(ProspectorHyperParams, SpecModel):
+    pass
+
+class HyperPolySpecModel(ProspectorHyperParams, PolySpecModel):
+    pass
+
 
 
 def ln_mvn(x, mean=None, cov=None):
diff --git a/prospect/models/templates.py b/prospect/models/templates.py
index dd188a3e..b76d5a37 100755
--- a/prospect/models/templates.py
+++ b/prospect/models/templates.py
@@ -10,7 +10,7 @@
 import os
 from . import priors
 from . import priors_beta
-from . import transforms
+from . import transforms, hyperparam_transforms
 
 __all__ = ["TemplateLibrary",
            "describe",
@@ -140,8 +140,8 @@ def adjust_stochastic_params(parset, tuniv=13.7):
     mean = np.zeros(ncomp - 1)
     psd_params = [parset['sigma_reg']['init'], parset['tau_eq']['init'], parset['tau_in']['init'],
                   parset['sigma_dyn']['init'], parset['tau_dyn']['init']]
-    sfr_covar = transforms.get_sfr_covar(psd_params, agebins=agebins)
-    sfr_ratio_covar = transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar)
+    sfr_covar = hyperparam_transforms.get_sfr_covar(psd_params, agebins=agebins)
+    sfr_ratio_covar = hyperparam_transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar)
     rprior = priors.MultiVariateNormal(mean=mean, Sigma=sfr_ratio_covar)
     
     parset['mass']['N'] = ncomp
@@ -720,14 +720,18 @@ def adjust_stochastic_params(parset, tuniv=13.7):
 _stochastic_["tau_dyn"] = {'name': 'tau_dyn', 'N': 1, 'isfree': True, 'init': 0.025, 
                            'prior': priors.ClippedNormal(mini=0.005, maxi=0.2, mean=0.01, sigma=0.02), 'units': 'Gyr'}
 
+_stochastic_["logsfr_ratios"] = {'N': 7, 'isfree': True, 'init': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                                 'prior': None}
+
+_stochastic_ = adjust_stochastic_params(_stochastic_)
 # calculates covariance matrix from the initial PSD parameter values to be used in log SFR ratios prior
-psd_params = [0.3, 2.5, 1.0, 0.01, 0.025]
-sfr_covar = transforms.get_sfr_covar(psd_params, agebins=agebins)
-sfr_ratio_covar = transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar)
+# psd_params = [0.3, 2.5, 1.0, 0.01, 0.025]
+# sfr_covar = hyperparam_transforms.get_sfr_covar(psd_params, agebins=agebins)
+# sfr_ratio_covar = hyperparam_transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar)
 
 # This controls the distribution of SFR(t) / SFR(t+dt). It has NBINS-1 components.
-_stochastic_["logsfr_ratios"] = {'N': 7, 'isfree': True, 'init': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
-                                 'prior': priors.MultiVariateNormal(mean=[0.]*7, Sigma=sfr_ratio_covar)}
+# _stochastic_["logsfr_ratios"] = {'N': 7, 'isfree': True, 'init': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                                  'prior': priors.MultiVariateNormal(mean=[0.]*7, Sigma=sfr_ratio_covar)}
 
 TemplateLibrary["stochastic_sfh"] = (_stochastic_,
                                      "Stochastic SFH which correlates the SFRs between time bins based on model in TFC2020")
diff --git a/prospect/models/transforms.py b/prospect/models/transforms.py
index ae505c05..9b78f136 100755
--- a/prospect/models/transforms.py
+++ b/prospect/models/transforms.py
@@ -10,8 +10,8 @@
 
 import numpy as np
 from ..sources.constants import cosmo
-from gp_sfh import *
-import gp_sfh_kernels
+#from gp_sfh import *
+#import gp_sfh_kernels
 
 
 __all__ = ["stellar_logzsol", "delogify_mass",
@@ -20,7 +20,8 @@
            "logsfr_ratios_to_masses", "logsfr_ratios_to_sfrs",
            "logsfr_ratios_to_masses_flex", "logsfr_ratios_to_agebins",
            "zfrac_to_masses", "zfrac_to_sfrac", "zfrac_to_sfr", "masses_to_zfrac",
-           "sfratio_to_sfr", "sfratio_to_mass", "get_sfr_covar", "sfr_covar_to_sfr_ratio_covar",
+           "sfratio_to_sfr", "sfratio_to_mass", 
+           #"get_sfr_covar", "sfr_covar_to_sfr_ratio_covar",
            "zred_to_agebins_pbeta",
            "zredmassmet_to_zred", "zredmassmet_to_logmass", "zredmassmet_to_mass", "zredmassmet_to_logzsol",
            "nzsfh_to_zred", "nzsfh_to_logmass", "nzsfh_to_mass", "nzsfh_to_logzsol", "nzsfh_to_logsfr_ratios"]
@@ -567,46 +568,46 @@ def nzsfh_to_logsfr_ratios(nzsfh=None, **extras):
 # --- Transforms for stochastic SFH prior ---
 # --------------------------------------
 
-def get_sfr_covar(psd_params, agebins=[], **extras):
+# def get_sfr_covar(psd_params, agebins=[], **extras):
     
-    """
-    Caluclates SFR covariance matrix for a given set of PSD parameters and agebins
-    PSD parameters must be in the order: [sigma_reg, tau_eq, tau_in, sigma_dyn, tau_dyn]
-    
-    Returns
-    -------
-    covar_matrix: (Nbins, Nbins)-dim array of covariance values for SFR
-    """
+#     """
+#     Caluclates SFR covariance matrix for a given set of PSD parameters and agebins
+#     PSD parameters must be in the order: [sigma_reg, tau_eq, tau_in, sigma_dyn, tau_dyn]
     
-    bincenters = np.array([np.mean(agebins[i]) for i in range(len(agebins))])
-    bincenters = (10**bincenters)/1e9
-    case1 = simple_GP_sfh()
-    case1.tarr = bincenters
-    case1.kernel = gp_sfh_kernels.extended_regulator_model_kernel_paramlist
-    covar_matrix = case1.get_covariance_matrix(kernel_params = psd_params, show_prog=False)
+#     Returns
+#     -------
+#     covar_matrix: (Nbins, Nbins)-dim array of covariance values for SFR
+#     """
+
+#     bincenters = np.array([np.mean(agebins[i]) for i in range(len(agebins))])
+#     bincenters = (10**bincenters)/1e9
+#     case1 = simple_GP_sfh()
+#     case1.tarr = bincenters
+#     case1.kernel = gp_sfh_kernels.extended_regulator_model_kernel_paramlist
+#     covar_matrix = case1.get_covariance_matrix(kernel_params = psd_params, show_prog=False)
     
-    return covar_matrix
+#     return covar_matrix
 
 
-def sfr_covar_to_sfr_ratio_covar(covar_matrix):
+# def sfr_covar_to_sfr_ratio_covar(covar_matrix):
     
-    """
-    Caluclates log SFR ratio covariance matrix from SFR covariance matrix
+#     """
+#     Caluclates log SFR ratio covariance matrix from SFR covariance matrix
     
-    Returns
-    -------
-    sfr_ratio_covar: (Nbins-1, Nbins-1)-dim array of covariance values for log SFR
-    """
+#     Returns
+#     -------
+#     sfr_ratio_covar: (Nbins-1, Nbins-1)-dim array of covariance values for log SFR
+#     """
     
-    dim = covar_matrix.shape[0]
+#     dim = covar_matrix.shape[0]
     
-    sfr_ratio_covar = []
+#     sfr_ratio_covar = []
     
-    for i in range(dim-1):
-        row = []
-        for j in range(dim-1):
-            cov = covar_matrix[i][j] - covar_matrix[i+1][j] - covar_matrix[i][j+1] + covar_matrix[i+1][j+1]
-            row.append(cov)
-        sfr_ratio_covar.append(row)
+#     for i in range(dim-1):
+#         row = []
+#         for j in range(dim-1):
+#             cov = covar_matrix[i][j] - covar_matrix[i+1][j] - covar_matrix[i][j+1] + covar_matrix[i+1][j+1]
+#             row.append(cov)
+#         sfr_ratio_covar.append(row)
     
-    return np.array(sfr_ratio_covar)
+#     return np.array(sfr_ratio_covar)

From 3e006ab84ad6b1b0e3717d914bd885fcd92d2cf3 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 18 Apr 2024 06:23:29 -0400
Subject: [PATCH 073/132] add some references for the gp-sfh methods;
 documentation updates for stochastic sfh prior.

---
 doc/prospector-beta_priors.rst           | 66 ++++++++++++++++++------
 doc/sfhs.rst                             | 19 +++++--
 prospect/models/hyperparam_transforms.py | 37 +++++++------
 prospect/models/hyperparameters.py       | 46 ++++++++++-------
 prospect/models/sedmodel.py              |  6 +--
 5 files changed, 117 insertions(+), 57 deletions(-)

diff --git a/doc/prospector-beta_priors.rst b/doc/prospector-beta_priors.rst
index df411b4b..ce920b76 100644
--- a/doc/prospector-beta_priors.rst
+++ b/doc/prospector-beta_priors.rst
@@ -2,13 +2,19 @@
 Prospector-beta Priors
 ==============
 
-This model is intended for fitting galaxy photometry where the redshift is unknown.
-The priors encode empirical constraints of redshifts, masses, and star formation histories in the galaxy population.
+This model is intended for fitting galaxy photometry where the redshift is
+unknown. The priors encode empirical constraints of redshifts, masses, and star
+formation histories in the galaxy population.
 
-N.B.: Please make sure to update to the Prospector-beta version post commit `09a83f2 <https://github.com/bd-j/prospector/commit/09a83f28cae3bcc0f0397b3a0b8d85aa4f96bf12>`_, merged on May 19, 2023. This is a major update to the SFH(M, z) prior, ensuring the expectation values of SFRs are well-behaved over the full prior space.
+N.B.: Please make sure to update to the Prospector-beta version post commit
+`09a83f2
+<https://github.com/bd-j/prospector/commit/09a83f28cae3bcc0f0397b3a0b8d85aa4f96bf12>`_,
+merged on May 19, 2023. This is a major update to the SFH(M, z) prior, ensuring
+the expectation values of SFRs are well-behaved over the full prior space.
 
-A set of prospector parameters implementing the full set of priors is available as the ``"beta"`` entry
-of :py:class:`prospect.models.templates.TemplateLibrary`.
+A set of prospector parameters implementing the full set of priors is available
+as the ``"beta"`` entry of
+:py:class:`prospect.models.templates.TemplateLibrary`.
 
 Additionally we provide different combinations of the priors for flexibility, which includes the following:
 
@@ -20,11 +26,13 @@ Additionally we provide different combinations of the priors for flexibility, wh
 * ``PhiSFHfixZred``  : same as above, but keeping zred fixed to a user-specified value, 'zred', during fitting
 * ``NzSFH``          : number density + mass function + mass-met + SFH(M, z); this is the full set of Prospector-beta priors.
 
-We describe each of the priors briefly below. Please cite `wang23 <https://ui.adsabs.harvard.edu/abs/2023ApJ...944L..58W/abstract>`_ and the relevant papers if any of the priors are used.
+We describe each of the priors briefly below. Please cite `wang23
+<https://ui.adsabs.harvard.edu/abs/2023ApJ...944L..58W/abstract>`_ and the
+relevant papers if any of the priors are used.
 
 
 Stellar Mass Function
------------
+---------------------
 
 Two options are available, the choice of which depends on the given scientific question.
 The relevant data files are ``prior_data/pdf_of_z_l20.txt`` & ``prior_data/pdf_of_z_l20t18.txt``.
@@ -32,31 +40,57 @@ These mass functions can also be replaced by supplying new data files to ``prior
 
 1. ``"const_phi = True"``
 
-The mass functions between 0.2 ≤ z ≤ 3.0 are taken from `leja20 <https://ui.adsabs.harvard.edu/abs/2020ApJ...893..111L/abstract>`_. Outside this redshift range, we adopt a nearest-neighbor solution, i.e., the z = 0.2 and z = 3 mass functions.
+The mass functions between 0.2 ≤ z ≤ 3.0 are taken from `leja20
+<https://ui.adsabs.harvard.edu/abs/2020ApJ...893..111L/abstract>`_. Outside this
+redshift range, we adopt a nearest-neighbor solution, i.e., the z = 0.2 and z =
+3 mass functions.
 
 2. ``"const_phi = False"``
 
-The mass functions are switched to those from `tacchella18 <https://ui.adsabs.harvard.edu/abs/2018ApJ...868...92T/abstract>`_ between 4 < z < 12, with the 3 < z < 4 transition from `leja20 <https://ui.adsabs.harvard.edu/abs/2020ApJ...893..111L/abstract>`_ managed with a smoothly-varying average in number density space. We use the z = 12 mass function for z > 12.
+The mass functions are switched to those from `tacchella18
+<https://ui.adsabs.harvard.edu/abs/2018ApJ...868...92T/abstract>`_ between 4 < z
+< 12, with the 3 < z < 4 transition from `leja20
+<https://ui.adsabs.harvard.edu/abs/2020ApJ...893..111L/abstract>`_ managed with
+a smoothly-varying average in number density space. We use the z = 12 mass
+function for z > 12.
 
 
 Galaxy Number Density
 -----------
 
-This prior informs the model about the survey volume being probed. It is sensitive to the mass-completeness limit of the data. We provide a default setting derived from a mock JWST catalog, which is contained in ``prior_data/mc_from_mocks.txt``.
-In practice one would likely need to obtain the mass-completeness limits from using SED-modeling heuristics based on the flux-completeness limits in a given catalog.
+This prior informs the model about the survey volume being probed. It is
+sensitive to the mass-completeness limit of the data. We provide a default
+setting derived from a mock JWST catalog, which is contained in
+``prior_data/mc_from_mocks.txt``.
+In practice one would likely need to obtain
+the mass-completeness limits from using SED-modeling heuristics based on the
+flux-completeness limits in a given catalog.
 
 
 Dynamic Star-formation History
 -----------
 
-The SFH is described non-parametrically as in Prospector-alpha; the number of age bins is set by ``"nbins_sfh"``.
+The SFH is described non-parametrically as in Prospector-alpha; the number of
+age bins is set by ``"nbins_sfh"``.
 
-In contrast to the null expectation assumed in Prospector-alpha, the expectation value in each age bin is matched to the cosmic star formation rate densities in `behroozi19 <https://ui.adsabs.harvard.edu/abs/2019MNRAS.488.3143B/abstract>`_, while the distribution about the mean remains to be the Student’s-t distribution. The sigma of the Student’s-t distribution is set by ``"logsfr_ratio_tscale"``, and the range is clipped to be within ``"logsfr_ratio_mini"`` and ``"logsfr_ratio_maxi"``.
+In contrast to the null expectation assumed in Prospector-alpha, the expectation
+value in each age bin is matched to the cosmic star formation rate densities in
+`behroozi19 <https://ui.adsabs.harvard.edu/abs/2019MNRAS.488.3143B/abstract>`_,
+while the distribution about the mean remains to be the Student's-t
+distribution. The sigma of the Student's-t distribution is set by
+``"logsfr_ratio_tscale"``, and the range is clipped to be within
+``"logsfr_ratio_mini"`` and ``"logsfr_ratio_maxi"``.
 
-A simple mass dependence on SFH is further introduced by shifting the start of the age bins as a function of mass. This SFH prior effectively encodes an expectation that high-mass galaxies form earlier, and low-mass galaxies form later, than naive expectations from the cosmic SFRD.
+A simple mass dependence on SFH is further introduced by shifting the start of
+the age bins as a function of mass. This SFH prior effectively encodes an
+expectation that high-mass galaxies form earlier, and low-mass galaxies form
+later, than naive expectations from the cosmic SFRD.
 
 
-Stellar Mass–Stellar Metallicity
+Stellar Mass-Stellar Metallicity
 -----------
 
-This is the stellar mass–stellar metallicity relationship measured from the SDSS in `gallazzi05 <https://ui.adsabs.harvard.edu/abs/2005MNRAS.362...41G/abstract>`_, introduced in `leja19 <https://ui.adsabs.harvard.edu/abs/2019ApJ...876....3L/abstract>`_.
+This is the stellar mass-stellar metallicity relationship measured from the SDSS
+in `gallazzi05
+<https://ui.adsabs.harvard.edu/abs/2005MNRAS.362...41G/abstract>`_, introduced
+in `leja19 <https://ui.adsabs.harvard.edu/abs/2019ApJ...876....3L/abstract>`_.
diff --git a/doc/sfhs.rst b/doc/sfhs.rst
index f1abba32..7a9519cc 100644
--- a/doc/sfhs.rst
+++ b/doc/sfhs.rst
@@ -77,8 +77,8 @@ Continuity SFH
 ^^^^^^^^^^^^^^
 See `leja19 <https://ui.adsabs.harvard.edu/abs/2019ApJ...876....3L/abstract>`_,
 `johnson21 <https://ui.adsabs.harvard.edu/abs/2021ApJS..254...22J/abstract>`_
-for more details. A set of propsector parameters implementing this treatment
-with 3 bins is available as the ``"continuity_sfh"`` entry of
+for more details. A basic set of prospector parameters implementing this
+treatment with 3 bins is available as the ``"continuity_sfh"`` entry of
 :py:class:`prospect.models.templates.TemplateLibrary`.
 
 In this parameterization, the SFR of each bin is derived from sampling a vector
@@ -86,7 +86,8 @@ of parameters describing the *ratio* of SFRs in adjacent temporal bins.  By
 default, a Student-t prior distribution (like a Gaussian but with heavier tails)
 is placed on the log of these ratios.  This results in a prior SFH that tends
 toward constant SFR, and down-weights drmamtic changes in the SFR between
-adjacent bins.  The overall normalization is provided by the ``logmass``
+adjacent bins.  The width of the distribution can be ajusted to produce smoother
+or burstier SFHs.The overall normalization is provided by the ``logmass``
 parameter.
 
 In detail, the SFR in each timetime is computed as
@@ -140,6 +141,18 @@ required to model post-starburst SFHs. A set of prospector parameters
 implementing this treatment is available as the ``"continuity_psb_sfh"`` entry
 of :py:class:`prospect.models.templates.TemplateLibrary`
 
+
+'Stochastic' SFH
+^^^^^^^^^^^^^^^^
+This SFH (hyper-)prior uses the power spectrum of SFH fluctuations -- the
+parameters of which can be sampled -- to determine the covariance matrix between
+(adjacent and non-adjacent) temporal bins of SFR. See `Wan et al. 24 <>`_ for
+details.  This prior is adapted from the Extended Regulator model developed in
+`Caplar & Tacchella (2019) <>`_ and `Tacchella, Forbes & Caplar (2020) <>`_, in
+conjunction with the GP implementation of `Iyer & Speagle et al. (2024) <https://ui.adsabs.harvard.edu/abs/2024ApJ...961...53I/abstract>`_.
+
+
+
 Dirichlet SFH
 ^^^^^^^^^^^^^
 See `leja17 <https://ui.adsabs.harvard.edu/abs/2017ApJ...837..170L/abstract>`_,
diff --git a/prospect/models/hyperparam_transforms.py b/prospect/models/hyperparam_transforms.py
index 37a273dc..907e2366 100644
--- a/prospect/models/hyperparam_transforms.py
+++ b/prospect/models/hyperparam_transforms.py
@@ -4,6 +4,10 @@
 """hyperparam_transforms.py -- This module contains parameter transformations that are
 used in the stochastic SFH prior.
 
+These are taken from the implementation of
+https://ui.adsabs.harvard.edu/abs/2024ApJ...961...53I/abstract given in
+https://github.com/kartheikiyer/GP-SFH
+
 They can be used as ``"depends_on"`` entries in parameter specifications.
 """
 
@@ -11,8 +15,8 @@
 from astropy.cosmology import FlatLambdaCDM
 
 __all__ = ["get_sfr_covar", "sfr_covar_to_sfr_ratio_covar"]
-           
-           
+
+
 # --------------------------------------
 # --- Functions/transforms for stochastic SFH prior ---
 # --------------------------------------
@@ -27,6 +31,8 @@ class simple_GP_sfh():
     A class that creates and holds information about a specific
     kernel, and can generate samples from it.
 
+    From https://github.com/kartheikiyer/GP-SFH
+
     Attributes
     ----------
     tarr: fiducial time array used to draw samples
@@ -108,6 +114,7 @@ def extended_regulator_model_kernel_paramlist(delta_t, kernel_params, base_e_to_
     sigma_gmc: gmc variability
     tau_l: cloud lifetime
 
+    from https://github.com/kartheikiyer/GP-SFH
     """
 
     sigma, tau_eq, tau_in, sigma_gmc, tau_gmc = kernel_params
@@ -132,11 +139,11 @@ def extended_regulator_model_kernel_paramlist(delta_t, kernel_params, base_e_to_
 
 
 def get_sfr_covar(psd_params, agebins=[], **extras):
-    
-    """
-    Caluclates SFR covariance matrix for a given set of PSD parameters and agebins
+    """Caluclates SFR covariance matrix for a given set of PSD parameters and agebins
     PSD parameters must be in the order: [sigma_reg, tau_eq, tau_in, sigma_dyn, tau_dyn]
-    
+
+    from https://github.com/kartheikiyer/GP-SFH
+
     Returns
     -------
     covar_matrix: (Nbins, Nbins)-dim array of covariance values for SFR
@@ -148,29 +155,29 @@ def get_sfr_covar(psd_params, agebins=[], **extras):
     case1.tarr = bincenters
     case1.kernel = extended_regulator_model_kernel_paramlist
     covar_matrix = case1.get_covariance_matrix(kernel_params = psd_params, show_prog=False)
-    
+
     return covar_matrix
 
 
 def sfr_covar_to_sfr_ratio_covar(covar_matrix):
-    
-    """
-    Caluclates log SFR ratio covariance matrix from SFR covariance matrix
-    
+    """Caluclates log SFR ratio covariance matrix from SFR covariance matrix
+
+    from https://github.com/kartheikiyer/GP-SFH
+
     Returns
     -------
     sfr_ratio_covar: (Nbins-1, Nbins-1)-dim array of covariance values for log SFR
     """
-    
+
     dim = covar_matrix.shape[0]
-    
+
     sfr_ratio_covar = []
-    
+
     for i in range(dim-1):
         row = []
         for j in range(dim-1):
             cov = covar_matrix[i][j] - covar_matrix[i+1][j] - covar_matrix[i][j+1] + covar_matrix[i+1][j+1]
             row.append(cov)
         sfr_ratio_covar.append(row)
-    
+
     return np.array(sfr_ratio_covar)
\ No newline at end of file
diff --git a/prospect/models/hyperparameters.py b/prospect/models/hyperparameters.py
index 5c64815b..e11a925b 100644
--- a/prospect/models/hyperparameters.py
+++ b/prospect/models/hyperparameters.py
@@ -1,9 +1,10 @@
 """
-hyperparameters.py 
+hyperparameters.py
 
 
-This class gets all all the ProspectorParams functionality, but it overrides the _prior_product and prior_transform methods
-to sample the hyperparameters & log SFR ratios of the stochastic SFH prior.
+This class gets all all the ProspectorParams functionality, but it overrides the
+_prior_product and prior_transform methods to sample the hyperparameters & log
+SFR ratios of the stochastic SFH prior.
 """
 
 import numpy as np
@@ -17,6 +18,11 @@
 
 class ProspectorHyperParams(ProspectorParams):
 
+    """
+    This class implements a SFH prior that is determined by hyper-parameters
+    that in turn have their own prior distributions.
+    """
+
     def _prior_product(self, theta, **extras):
         """Return a scalar which is the ln of the product of the prior
         probabilities for each element of theta.  Requires that the prior
@@ -31,10 +37,10 @@ def _prior_product(self, theta, **extras):
             parameter values.
         """
         lnp_prior = 0
-                
+
         hyper_params = ['sigma_reg', 'tau_eq', 'tau_in', 'sigma_dyn', 'tau_dyn']
         psd_params = np.zeros(len(hyper_params))
-        
+
         for i, p in enumerate(hyper_params):
             if self.config_dict[p]['isfree']:
                 inds = self.theta_index[p]
@@ -44,7 +50,7 @@ def _prior_product(self, theta, **extras):
                 lnp_prior += this_prior
             else:
                 psd_params[i] = self.config_dict[p]['init']
-                
+
         sfr_covar_matrix = transforms.get_sfr_covar(psd_params, agebins=self.config_dict['agebins']['init'])
         sfr_ratio_covar_matrix = transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar_matrix)
         nbins = len(self.config_dict['agebins']['init'])
@@ -52,16 +58,16 @@ def _prior_product(self, theta, **extras):
         inds = self.theta_index['logsfr_ratios']
         this_prior = np.sum(np.log(logsfr_ratio_prior.pdf(theta[..., inds])))
         lnp_prior += this_prior
-    
+
         for k, inds in list(self.theta_index.items()):
             if (k in hyper_params) or (k == 'logsfr_ratios'):
                 continue
             func = self.config_dict[k]['prior']
             this_prior = np.sum(func(theta[..., inds]), axis=-1)
             lnp_prior += this_prior
-            
+
         return lnp_prior
-    
+
 
     def prior_transform(self, unit_coords):
         """Go from unit cube to parameter space, for nested sampling.
@@ -73,13 +79,13 @@ def prior_transform(self, unit_coords):
             The parameter vector corresponding to the location in prior CDF
             corresponding to ``unit_coords``. ndarray of shape ``(ndim,)``
         """
-        
+
         theta = np.zeros(len(unit_coords))
-        
+
         hyper_params = ['sigma_reg', 'tau_eq', 'tau_in', 'sigma_dyn', 'tau_dyn']
         psd_params = np.zeros(len(hyper_params))
-        
-                
+
+
         for i, p in enumerate(hyper_params):
             if self.config_dict[p]['isfree']:
                 func = self.config_dict[p]['prior'].unit_transform
@@ -88,22 +94,22 @@ def prior_transform(self, unit_coords):
                 theta[inds] = psd_params[i]
             else:
                 psd_params[i] = self.config_dict[p]['init']
-            
+
         sfr_covar_matrix = transforms.get_sfr_covar(psd_params, agebins=self.config_dict['agebins']['init'])
         sfr_ratio_covar_matrix = transforms.sfr_covar_to_sfr_ratio_covar(sfr_covar_matrix)
         logsfr_ratio_prior = priors.MultiVariateNormal(mean=0, Sigma=sfr_ratio_covar_matrix)
         x = unit_coords[self.theta_index['logsfr_ratios']]
         logsfr_ratios = logsfr_ratio_prior.unit_transform(x)
         theta[self.theta_index['logsfr_ratios']] = logsfr_ratios
-                    
+
         for k, inds in list(self.theta_index.items()):
             if (k in hyper_params) or (k == 'logsfr_ratios'):
                 continue
             func = self.config_dict[k]['prior'].unit_transform
             theta[inds] = func(unit_coords[inds])
-            
+
         return theta
-        
-        
-        
-        
+
+
+
+
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 2f8bdc01..3df21c42 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -699,7 +699,7 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
             self._poly_coeffs = c
         else:
             poly = np.zeros_like(self._outwave)
-            
+
         return (1.0 + poly)
 
 
@@ -1300,8 +1300,8 @@ def spec_calibration(self, theta=None, obs=None, **kwargs):
                 return np.exp(self.params.get('spec_norm', 0) + poly)
         else:
             return 1.0 * self.params.get('spec_norm', 1.0)
-        
-        
+
+
 class HyperSpecModel(ProspectorHyperParams, SpecModel):
     pass
 

From 76c84ab06fdaab2c11a61baeff4f29ed534f5d11 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 18 Apr 2024 06:28:25 -0400
Subject: [PATCH 074/132] [skip ci] Fixes to references.

---
 doc/sfhs.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/sfhs.rst b/doc/sfhs.rst
index 7a9519cc..c3dd5e2e 100644
--- a/doc/sfhs.rst
+++ b/doc/sfhs.rst
@@ -148,7 +148,7 @@ This SFH (hyper-)prior uses the power spectrum of SFH fluctuations -- the
 parameters of which can be sampled -- to determine the covariance matrix between
 (adjacent and non-adjacent) temporal bins of SFR. See `Wan et al. 24 <>`_ for
 details.  This prior is adapted from the Extended Regulator model developed in
-`Caplar & Tacchella (2019) <>`_ and `Tacchella, Forbes & Caplar (2020) <>`_, in
+`Caplar & Tacchella (2019) <https://ui.adsabs.harvard.edu/abs/2019MNRAS.487.3845C/abstract>`_ and `Tacchella, Forbes & Caplar (2020) <https://ui.adsabs.harvard.edu/abs/2020MNRAS.497..698T/abstract>`_, in
 conjunction with the GP implementation of `Iyer & Speagle et al. (2024) <https://ui.adsabs.harvard.edu/abs/2024ApJ...961...53I/abstract>`_.
 
 

From f474e2e35cae802b55b7ff1e775d3b54a3874209 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 18 Apr 2024 06:30:11 -0400
Subject: [PATCH 075/132] [skip ci] Fixes to references.

---
 doc/sfhs.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/sfhs.rst b/doc/sfhs.rst
index c3dd5e2e..3bffbb11 100644
--- a/doc/sfhs.rst
+++ b/doc/sfhs.rst
@@ -148,8 +148,8 @@ This SFH (hyper-)prior uses the power spectrum of SFH fluctuations -- the
 parameters of which can be sampled -- to determine the covariance matrix between
 (adjacent and non-adjacent) temporal bins of SFR. See `Wan et al. 24 <>`_ for
 details.  This prior is adapted from the Extended Regulator model developed in
-`Caplar & Tacchella (2019) <https://ui.adsabs.harvard.edu/abs/2019MNRAS.487.3845C/abstract>`_ and `Tacchella, Forbes & Caplar (2020) <https://ui.adsabs.harvard.edu/abs/2020MNRAS.497..698T/abstract>`_, in
-conjunction with the GP implementation of `Iyer & Speagle et al. (2024) <https://ui.adsabs.harvard.edu/abs/2024ApJ...961...53I/abstract>`_.
+`Caplar & Tacchella (2019) <https://ui.adsabs.harvard.edu/abs/2019MNRAS.487.3845C/abstract>`_ and `Tacchella, Forbes & Caplar (2020) <https://ui.adsabs.harvard.edu/abs/2020MNRAS.497..698T/abstract>`_ , in
+conjunction with the GP implementation of `Iyer & Speagle et al. (2024) <https://ui.adsabs.harvard.edu/abs/2024ApJ...961...53I/abstract>`_ taken from `this module <https://github.com/kartheikiyer/GP-SFH>`_ .
 
 
 

From 7c1e17900af5bc2ebbe675e6afb12282105da428 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 26 Apr 2024 10:03:21 -0400
Subject: [PATCH 076/132] [skip ci] Update SFH reference.

---
 doc/sfhs.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/sfhs.rst b/doc/sfhs.rst
index 3bffbb11..6727e8a8 100644
--- a/doc/sfhs.rst
+++ b/doc/sfhs.rst
@@ -146,7 +146,7 @@ of :py:class:`prospect.models.templates.TemplateLibrary`
 ^^^^^^^^^^^^^^^^
 This SFH (hyper-)prior uses the power spectrum of SFH fluctuations -- the
 parameters of which can be sampled -- to determine the covariance matrix between
-(adjacent and non-adjacent) temporal bins of SFR. See `Wan et al. 24 <>`_ for
+(adjacent and non-adjacent) temporal bins of SFR. See `Wan et al. 24 <https://ui.adsabs.harvard.edu/abs/2024arXiv240414494W/abstract>`_ for
 details.  This prior is adapted from the Extended Regulator model developed in
 `Caplar & Tacchella (2019) <https://ui.adsabs.harvard.edu/abs/2019MNRAS.487.3845C/abstract>`_ and `Tacchella, Forbes & Caplar (2020) <https://ui.adsabs.harvard.edu/abs/2020MNRAS.497..698T/abstract>`_ , in
 conjunction with the GP implementation of `Iyer & Speagle et al. (2024) <https://ui.adsabs.harvard.edu/abs/2024ApJ...961...53I/abstract>`_ taken from `this module <https://github.com/kartheikiyer/GP-SFH>`_ .

From 34be1585395ddc1366458d42d67ea8d78d0f93ea Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 28 Apr 2024 11:44:47 -0400
Subject: [PATCH 077/132] remove duplicate tests.

---
 tests/test_eline.py     | 15 +++++++------
 tests/test_multispec.py | 47 +----------------------------------------
 tests/test_predict.py   | 22 +++++++++----------
 3 files changed, 19 insertions(+), 65 deletions(-)

diff --git a/tests/test_eline.py b/tests/test_eline.py
index 7330c425..3027a21d 100644
--- a/tests/test_eline.py
+++ b/tests/test_eline.py
@@ -7,7 +7,7 @@
 
 from sedpy import observate
 
-from prospect.observation import Photometry, Spectrum, from_oldstyle
+from prospect.observation import from_oldstyle
 from prospect.models.templates import TemplateLibrary
 from prospect.models.sedmodel import SpecModel
 from prospect.sources import CSPSpecBasis
@@ -146,7 +146,7 @@ def test_filtersets(get_sps):
         # We always use filtersets now
 
 
-def test_eline_implementation(get_sps):
+def test_eline_implementation(get_sps, plot=False):
 
     test_eline_parsing()
 
@@ -179,11 +179,12 @@ def test_eline_implementation(get_sps):
     (phot_nolya_2,), mfrac = model.predict(model.theta, [obslist[1]], sps=sps)
     assert np.all(phot_nolya == phot_nolya_2)
 
-    #import matplotlib.pyplot as pl
-    #pl.ion()
-    #fig, ax = pl.subplots()
-    #ax.plot(obs["wavelength"], spec)
-    #ax.plot(obs["wavelength"], spec_nolya)
+    if plot:
+        import matplotlib.pyplot as pl
+        pl.ion()
+        fig, ax = pl.subplots()
+        ax.plot(obslist[0]["wavelength"], spec)
+        ax.plot(obslist[0]["wavelength"], spec_nolya)
 
 
 #def test_marginalizing_lines():
diff --git a/tests/test_multispec.py b/tests/test_multispec.py
index c69a66cb..d6ac17da 100644
--- a/tests/test_multispec.py
+++ b/tests/test_multispec.py
@@ -1,12 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import sys
 import numpy as np
-
 import pytest
 
-from sedpy.observate import load_filters
 from prospect.sources import CSPSpecBasis
 from prospect.models import SpecModel, templates
 from prospect.observation import Spectrum, Photometry
@@ -47,52 +44,10 @@ def build_obs(multispec=True):
     return obslist
 
 
-def test_prediction_nodata(build_sps):
-    sps = build_sps
-    model = build_model(add_neb=True)
-    sobs, pobs = build_obs(multispec=False)
-    pobs.flux = None
-    pobs.uncertainty = None
-    sobs.wavelength = None
-    sobs.flux = None
-    sobs.uncertainty = None
-    pred, mfrac = model.predict(model.theta, observations=[sobs, pobs], sps=sps)
-    assert len(pred[0]) == len(sps.wavelengths)
-    assert len(pred[1]) == len(pobs.filterset)
-
-
-def test_multispec(build_sps):
-    sps = build_sps
-
-    obslist_single = build_obs(multispec=False)
-    obslist_multi = build_obs(multispec=True)
-    model = build_model(add_neb=True)
-
-    preds_single, mfrac = model.predict(model.theta, observations=obslist_single, sps=sps)
-    preds_multi, mfrac = model.predict(model.theta, observations=obslist_multi, sps=sps)
-
-    assert len(preds_single) == 2
-    assert len(preds_multi) == 3
-    assert np.allclose(preds_single[-1], preds_multi[-1])
-
-    # TODO: turn this plot into an actual test
-    #import matplotlib.pyplot as pl
-    #fig, ax = pl.subplots()
-    #ax.plot(obslist_single[0].wavelength, predictions_single[0])
-    #for p, o in zip(predictions, obslist):
-    #    if o.kind == "photometry":
-    #        ax.plot(o.wavelength, p, "o")
-    #    else:
-    #        ax.plot(o.wavelength, p)
-
-
 def test_multiline():
     """The goal is combine all constraints on the emission line luminosities.
-    
-    
-    
     """
-
+    pass
 
 
 def test_multires():
diff --git a/tests/test_predict.py b/tests/test_predict.py
index b0a5eae1..b474b4bc 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -1,12 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import sys
 import numpy as np
-
 import pytest
 
-from sedpy.observate import load_filters
 from prospect.sources import CSPSpecBasis
 from prospect.models import SpecModel, templates
 from prospect.observation import Spectrum, Photometry
@@ -63,7 +60,7 @@ def test_prediction_nodata(build_sps):
     assert np.any(np.isfinite(pred[1]))
 
 
-def test_multispec(build_sps):
+def test_multispec(build_sps, plot=False):
     sps = build_sps
 
     obslist_single = build_obs(multispec=False)
@@ -78,14 +75,15 @@ def test_multispec(build_sps):
     assert np.allclose(preds_single[-1], preds_multi[-1])
 
     # TODO: turn this plot into an actual test
-    #import matplotlib.pyplot as pl
-    #fig, ax = pl.subplots()
-    #ax.plot(obslist_single[0].wavelength, predictions_single[0])
-    #for p, o in zip(predictions, obslist):
-    #    if o.kind == "photometry":
-    #        ax.plot(o.wavelength, p, "o")
-    #    else:
-    #        ax.plot(o.wavelength, p)
+    if plot:
+        import matplotlib.pyplot as pl
+        fig, ax = pl.subplots()
+        ax.plot(obslist_single[0].wavelength, preds_single[0])
+        for p, o in zip(preds_multi, obslist_multi):
+           if o.kind == "photometry":
+               ax.plot(o.wavelength, p, "o")
+           else:
+               ax.plot(o.wavelength, p)
 
 
 def lnlike_testing(build_sps):

From 5829177d180821d4a4d30a61be784977711e1570 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 28 Apr 2024 11:52:19 -0400
Subject: [PATCH 078/132] fix logic bug in absolute_rest_maggies.

---
 prospect/models/sedmodel.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 33528420..531e2525 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -682,7 +682,6 @@ def add_dla(self, wave_rest, spec):
         spec *= np.exp(-tau)
         return spec
 
-
     def observed_wave(self, wave, do_wavecal=False):
         """Convert the restframe wavelngth grid to the observed frame wavelength
         grid, optionally including wavelength calibration adjustments.  Requires
@@ -733,7 +732,7 @@ def absolute_rest_maggies(self, filterset):
         abs_rest_maggies = np.atleast_1d(getSED(self._wave, flambda, filterset, linear_flux=True))
 
         # add emission lines
-        if bool(self.params.get('nebemlineinspec', False)) is False:
+        if (self._want_lines & self._need_lines):
             eline_z = self.params.get("eline_delta_zred", 0.0)
             elams = (1 + eline_z) * self._eline_wave
             elums = self._eline_lum * self.flux_norm() / (1 + self._zred) * (3631*jansky_cgs) * (ld / 10)**2

From ad63e9977cb04b1751bc998fe97cc054b57e64cf Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 28 Apr 2024 13:08:31 -0400
Subject: [PATCH 079/132] add a basic test for observation I/O, and some more
 docs for dataformats.

---
 doc/dataformat.rst                  | 29 +++++++++++---
 prospect/io/write_results.py        | 12 +++---
 prospect/observation/observation.py | 13 ++++--
 tests/test_io.py                    | 61 +++++++++++++++++++++++++++++
 4 files changed, 100 insertions(+), 15 deletions(-)
 create mode 100644 tests/test_io.py

diff --git a/doc/dataformat.rst b/doc/dataformat.rst
index bbbacfaf..d5039d9f 100644
--- a/doc/dataformat.rst
+++ b/doc/dataformat.rst
@@ -13,8 +13,9 @@ uncertainties thereon, they tell prospector what data to predict, contain
 dataset-specific information for how to predict that data, and can even store
 methods for computing likelihoods in the case of complicated, dataset-specific
 noise models. There are two fundamental kinds of data, `Photometry` and
-`Spectrum` that are each subclasses of `Observation`.  They have the following
-attributes, most of which can be also accessed as dictionary keys.
+`Spectrum` that are each subclasses of `Observation`. There is also also a
+`Lines` class for integrated emission line fluxes. They have the following
+attributes, most of which can also be accessed as dictionary keys.
 
 
 - ``wavelength``
@@ -30,7 +31,9 @@ attributes, most of which can be also accessed as dictionary keys.
     apparent magnitude. That is, 1 maggie is the flux density in Janskys divided
     by 3631. If absolute spectrophotometry is available, the units for a
     `Spectrum`` should also be maggies, otherwise photometry must be present and
-    a calibration vector must be supplied or fit.
+    a calibration vector must be supplied or fit.  Note that for convenience
+    there is a `maggies_to_nJy` attribute of `Observation` that gives the
+    conversion factor.
 
 - ``uncertainty``
     The uncertainty vector (sigma), in same units as ``flux``, ndarray of same
@@ -44,6 +47,9 @@ attributes, most of which can be also accessed as dictionary keys.
    For a `Photometry`, this is a list of strings corresponding to filter names
    in `sedpy <https://github.com/bd-j/sedpy>`_
 
+- ``line_ind``
+  For a `Lines` instance, the (zero-based) index of the emission line in the
+  FSPS emission line table.
 
 In addition to these attributes, several additional aspects of an observation
 are used to help predict data or to compute likelihoods.  The latter is
@@ -73,8 +79,7 @@ For a single observation, you might do something like:
 
         def build_obs(N):
             from prospect.data import Spectrum
-            # dummy observation dictionary with just a spectrum
-            N = 1000
+            N = 1000  # number of wavelength points
             spec = Spectrum(wavelength=np.linspace(3000, 5000, N), flux=np.zeros(N), uncertainty=np.ones(N))
             # ensure that this is a valid observation for fitting
             spec = spec.rectify()
@@ -84,6 +89,20 @@ For a single observation, you might do something like:
 
 Note that `build_obs` returns a *list* even if there is only one dataset.
 
+For photometry this might look like:
+
+.. code-block:: python
+
+        def build_obs(N):
+            from prospect.data import Photometry
+            # valid sedpy filter names
+            fnames = list([f"sdss_{b}0" for b in "ugriz"])
+            Nf = len(fnames)
+            phot = [Photometry(filters=fnames, flux=np.ones(Nf), uncertainty=np.ones(Nf)/10)]
+            # ensure that this is a valid observation for fitting
+            phot = phot.rectify()
+            observations = [phot]
+            return observations
 
 Converting from old style obs dictionaries
 ------------------------------------------
diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index 748cd1f5..6ac26b46 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -106,7 +106,7 @@ def write_hdf5(hfile, run_params, model, obs,
         generate and store
     """
     # If ``hfile`` is not a file object, assume it is a filename and open
-    if type(hfile) is str:
+    if isinstance(hfile, str):
         hf = h5py.File(hfile, "w")
     else:
         hf = hfile
@@ -122,6 +122,11 @@ def write_hdf5(hfile, run_params, model, obs,
     write_sampling_h5(hf, chain, extras)
     hf.flush()
 
+    # ----------------------
+    # Observational data
+    write_obs_to_h5(hf, obs)
+    hf.flush()
+
     # ----------------------
     # High level parameter and version info
     meta = metadata(run_params, model, write_model_params=write_model_params)
@@ -137,11 +142,6 @@ def write_hdf5(hfile, run_params, model, obs,
         mgroup = hf.create_group('optimization')
         mdat = mgroup.create_dataset('optimizer_results', data=out)
 
-    # ----------------------
-    # Observational data
-    write_obs_to_h5(hf, obs)
-    hf.flush()
-
     # ---------------
     # Best fitting model in space of data
     if sps is not None:
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 37831d8e..81dce927 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -10,7 +10,7 @@
 from ..likelihood.noise_model import NoiseModel
 
 
-__all__ = ["Observation", "Spectrum", "Photometry", "Lines"
+__all__ = ["Observation", "Spectrum", "Photometry", "Lines",
            "from_oldstyle", "from_serial", "obstypes"]
 
 
@@ -125,6 +125,11 @@ def _automask(self):
     def render(self, wavelength, spectrum):
         raise(NotImplementedError)
 
+    @property
+    def kind(self):
+        # make 'kind' private
+        return self._kind
+
     @property
     def ndof(self):
         # TODO: cache this?
@@ -210,7 +215,7 @@ def maggies_to_nJy(self):
 
 class Photometry(Observation):
 
-    kind = "photometry"
+    _kind = "photometry"
     alias = dict(maggies="flux",
                  maggies_unc="uncertainty",
                  filters="filters",
@@ -273,7 +278,7 @@ def to_oldstyle(self):
 
 class Spectrum(Observation):
 
-    kind = "spectrum"
+    _kind = "spectrum"
     alias = dict(spectrum="flux",
                  unc="uncertainty",
                  wavelength="wavelength",
@@ -442,7 +447,7 @@ def _smooth_lsf_fft(self, inwave, influx, outwave, sigma):
 
 class Lines(Spectrum):
 
-    kind = "lines"
+    _kind = "lines"
     alias = dict(spectrum="flux",
                  unc="uncertainty",
                  wavelength="wavelength",
diff --git a/tests/test_io.py b/tests/test_io.py
new file mode 100644
index 00000000..a99d307c
--- /dev/null
+++ b/tests/test_io.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+import h5py
+
+from prospect.models import SpecModel, templates
+from prospect.sources import CSPSpecBasis
+from prospect.observation import Photometry, Spectrum
+from prospect.io.write_results import write_obs_to_h5
+from prospect.io.read_results import obs_from_h5
+
+
+@pytest.fixture(scope="module")
+def build_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+def build_model(add_neb=False):
+    model_params = templates.TemplateLibrary["parametric_sfh"]
+    if add_neb:
+        model_params.update(templates.TemplateLibrary["nebular"])
+    return SpecModel(model_params)
+
+
+def build_obs(multispec=True):
+    N = 1500 * (2 - multispec)
+    wmax = 7000
+    wsplit = wmax - N * multispec
+
+    fnames = list([f"sdss_{b}0" for b in "ugriz"])
+    Nf = len(fnames)
+    phot = [Photometry(filters=fnames, flux=np.ones(Nf), uncertainty=np.ones(Nf)/10)]
+    spec = [Spectrum(wavelength=np.linspace(4000, wsplit, N),
+                     flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                     mask=slice(None))]
+
+    if multispec:
+        spec += [Spectrum(wavelength=np.linspace(wsplit+1, wmax, N),
+                          flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                          mask=slice(None))]
+
+    obslist = spec + phot
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+def test_observation_io(build_sps, plot=False):
+    sps = build_sps
+
+    obslist = build_obs(multispec=True)
+    model = build_model(add_neb=True)
+
+    # obs writing
+    with h5py.File("test.h5", "w") as hf:
+        write_obs_to_h5(hf, obslist)
+    with h5py.File("test.h5", "r") as hf:
+        obsr = obs_from_h5(hf["observations"])

From f343e516214bad1ebbf2dbb279a085d77f5baa7b Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 28 Apr 2024 13:37:08 -0400
Subject: [PATCH 080/132] cleanup after io test.

---
 doc/dataformat.rst          |  5 +++--
 prospect/models/sedmodel.py |  3 +++
 tests/test_io.py            | 10 ++++++++--
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/doc/dataformat.rst b/doc/dataformat.rst
index d5039d9f..36ea4ac2 100644
--- a/doc/dataformat.rst
+++ b/doc/dataformat.rst
@@ -7,7 +7,7 @@ The `Observation` class
 
 |Codename| expects the data in the form of list of ``Observations``, preferably
 returned by :py:meth:`build_obs` (see below). Each Observation instance
-corresponds to single dataset, and is basically a namespace that also supports
+corresponds to a single dataset, and is basically a namespace that also supports
 dict-like accessing of important attributes.  In addition to holding data and
 uncertainties thereon, they tell prospector what data to predict, contain
 dataset-specific information for how to predict that data, and can even store
@@ -58,7 +58,8 @@ models, jitter terms, or covariant noise.
 
 - ``name``
   A string that can be used to identify the dataset.  This can be useful for
-  dataset-specfic parameters.
+  dataset-specfic parameters.  By default the name is constructed from the
+  `kind` and the memory location of the object.
 
 - ``resolution``
    For a `Spectrum` this defines the instrumental resolution.  Analagously to
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 531e2525..2ec883d6 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -682,6 +682,9 @@ def add_dla(self, wave_rest, spec):
         spec *= np.exp(-tau)
         return spec
 
+    def add_damping_wing(self, wave_rest, spec):
+        pass
+
     def observed_wave(self, wave, do_wavecal=False):
         """Convert the restframe wavelngth grid to the observed frame wavelength
         grid, optionally including wavelength calibration adjustments.  Requires
diff --git a/tests/test_io.py b/tests/test_io.py
index a99d307c..97ccbb9e 100644
--- a/tests/test_io.py
+++ b/tests/test_io.py
@@ -54,8 +54,14 @@ def test_observation_io(build_sps, plot=False):
     obslist = build_obs(multispec=True)
     model = build_model(add_neb=True)
 
+    fn = "./test.h5"
     # obs writing
-    with h5py.File("test.h5", "w") as hf:
+    with h5py.File(fn, "w") as hf:
         write_obs_to_h5(hf, obslist)
-    with h5py.File("test.h5", "r") as hf:
+    # obs reading
+    with h5py.File(fn, "r") as hf:
         obsr = obs_from_h5(hf["observations"])
+
+    # cleanup?
+    import os
+    os.remove(fn)
\ No newline at end of file

From 8cdcd76276a35c85ccacc1ab5c9ba0ad643da470 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 28 Apr 2024 16:51:51 -0400
Subject: [PATCH 081/132] Basic IGM damping wing implementation.

---
 prospect/models/sedmodel.py | 93 +++++++++++++++++++++++++++++++++++--
 tests/test_dla.py           | 47 ++++++++++++++++++-
 tests/test_io.py            |  7 +--
 3 files changed, 138 insertions(+), 9 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 2ec883d6..5749f495 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -54,7 +54,8 @@ def _available_parameters(self):
                     ("eline_sigma", ""),
                     ("use_eline_priors", ""),
                     ("eline_prior_width", ""),
-                    ("dla_logNh", "log_10 HI column density for damped Lyman-alpha absorption")]
+                    ("dla_logNh", "log_10 HI column density for damped Lyman-alpha absorption"),
+                    ("igm_damping", "boolean switch to turn on IGM damping wing redward of 1216 rest")]
 
         referenced_pars = [("mass", ""),
                            ("lumdist", ""),
@@ -122,8 +123,10 @@ def predict(self, theta, observations=None, sps=None, **extras):
 
         # physical velocity smoothing of the whole UV/NIR spectrum
         self._smooth_spec = self.velocity_smoothing(self._wave, self._norm_spec)
-        # DLA absorption
+
+        # Ly-alpha absorption
         self._smooth_spec = self.add_dla(self._wave, self._smooth_spec)
+        self._smooth_spec = self.add_damping_wing(self._wave, self._smooth_spec)
 
         # generate predictions for likelihood
         # this assumes all spectral datasets (if present) occur first
@@ -683,7 +686,11 @@ def add_dla(self, wave_rest, spec):
         return spec
 
     def add_damping_wing(self, wave_rest, spec):
-        pass
+        if np.any(self.params.get("igm_damping", False)):
+            x_HI = self.params.get("igm_factor", 1.0)
+            tau = tau_damping(wave_rest, self._zred, x_HI, cosmo=cosmo)
+            spec *= np.exp(-tau)
+        return spec
 
     def observed_wave(self, wave, do_wavecal=False):
         """Convert the restframe wavelngth grid to the observed frame wavelength
@@ -1180,6 +1187,9 @@ def gauss(x, mu, A, sigma):
     return val.sum(axis=-1)
 
 
+# TODO: Move the below to a separate IGM module
+
+
 def H(a, x):
     """Voigt Profile Approximation from T. Tepper-Garcia (2006, 2007).
     Valid to a fractional error of ~ 1e-7 * (N_h/10^22) for Lyman-alpha (a~1e-4)"""
@@ -1246,4 +1256,79 @@ def Voigt(x, alpha, gamma):
     sigma = alpha / np.sqrt(2 * np.log(2))
 
     return np.real(wofz((x + 1j*gamma)/sigma/np.sqrt(2))) / sigma\
-                                                           /np.sqrt(2*np.pi)
\ No newline at end of file
+                                                           /np.sqrt(2*np.pi)
+
+
+def tau_damping(wave_rest, zred, x_HI, zmin=5, cosmo=cosmo, Y=0.25, l0=1215.6696):
+    """Compute the optical depth redward of restframe Ly-alpha due to the IGM
+    damping wing.  Fiollows Mirald-Escude 1998 and Totani 2006 in assuming a
+    uniform IGM below the object redshift.
+
+    Parameters
+    ----------
+    wave_rest : array_like, shape (N)
+        Restframe wavelength grid in Angstroms at which to evaluate the optical depth.
+
+    zred : float
+        The object redshift.  We also assume this is the maximum redshift of the
+        IGM integral
+
+    x_HI : float
+        The neutral fraction of the IGM.  Can be greater than 1 to approximate
+        local overdensity.
+
+    zmin : float
+        The minimum redshift for the uniform IGM integral
+
+    cosmo : astropy.cosmology.Cosmology() instance
+        The cosmology to use for the calculation
+
+    Y : float
+        The helium fraction of the universe
+
+    l0 : float
+        Rest frame transition wavelength in Angstroms.
+
+    Returns
+    -------
+    tau_damping : array_like, shape (N)
+        The optical depth due to the damping wing.  Will be zero blueward of l0.
+
+    """
+    R_alpha = 2.02e-8
+
+    wave_obs = wave_rest * (1 + zred)
+    zobs = wave_obs / l0 - 1
+    red = (zobs - zred) / (1+zobs) > (100 * R_alpha)
+
+    tau_damp = np.zeros_like(wave_rest)
+    xx = Ix((1 + zred) / (1 + zobs[red])) - Ix((1 + zmin) / (1 + zobs[red]))
+
+    tau = R_alpha/np.pi * x_HI * tau_gp(cosmo, zred, Y=Y)
+    tau = tau * ((1 + zobs[red]) / (1 + zred))**(3/2) * xx
+    tau_damp[red] = tau
+    return tau_damp
+
+
+def tau_gp(cosmo, zred, Y=0.25):
+    # totani 2006
+    # with scaling by omega_baryon * (1-Y) * h / sqrt(Omega_m)
+    #factor = 3.88e5
+    #scale = ((1-Y)/0.75) * (cosmo.Ob0/0.044) * (cosmo.Om0/0.27)**(-1/2) * (cosmo.h/0.71)
+
+    # Also Miralda-Escude substituting 1/sqrt(Omega_m) = Ho/Hz * (1+z)^(3/2))
+    factor = 2.6e5
+    scale = (1-Y) * cosmo.h * cosmo.Om0**(-0.5) * (cosmo.Ob0/0.03)
+
+    # Hertz 2024 relies on Becker 01/wikipedia and is not the same (missing 1-Y ?)
+    # factor = 1.8
+    # scale = cosmo.h * cosmo.Om0**(-0.5) * (cosmo.Ob0/0.02)
+
+    tau_gp = factor * scale * ((1 + zred) / 7)**(3/2)
+    return tau_gp
+
+
+def Ix(x):
+    v = x**(9/2)/(1-x) + 9/7 * x**(3.5) + 9/5*x**(2.5) + 3*x**(1.5) + 9 * x**(0.5)
+    v -= 9/2 * np.log((1+x**0.5) / (1-x**0.5))
+    return v
\ No newline at end of file
diff --git a/tests/test_dla.py b/tests/test_dla.py
index acb960dd..ebe61613 100644
--- a/tests/test_dla.py
+++ b/tests/test_dla.py
@@ -14,7 +14,7 @@ def build_sps():
     return sps
 
 
-def build_model(free_dla=True):
+def build_model(free_dla=True, damping_wing=False):
     model_params = templates.TemplateLibrary["parametric_sfh"]
     model_params["zred"]["isfree"] = True
     model_params.update(templates.TemplateLibrary["nebular"])
@@ -30,6 +30,10 @@ def build_model(free_dla=True):
     model_params["dla_logNh"] = dict(N=1, isfree=free_dla, init=18,
                                      prior=priors.Uniform(mini=18, maxi=23))
 
+    # Add damping wing switch
+    model_params["igm_damping"] = dict(N=1, isfree=False, init=damping_wing)
+
+
     return SpecModel(model_params)
 
 
@@ -61,6 +65,7 @@ def test_dla(build_sps, plot=False):
     model.params["dla_logNh"] = 0
     model.params["tage"] = 0.4
     model.params["tau"] = 0.2
+    model.params["dust2"] = 0.0
     theta1 = model.theta.copy()
 
     pred1 = model.predict(theta1, obs, sps)
@@ -88,4 +93,42 @@ def test_dla(build_sps, plot=False):
         ax.legend()
         ax.set_xlabel(r"$\lambda (\mu{\rm m})$")
         ax.set_ylabel(r"$f_\nu$")
-        fig.savefig("prospector_dla.png")
\ No newline at end of file
+        fig.savefig("prospector_dla.png")
+
+
+def test_damping(build_sps, plot=False):
+
+    sps = build_sps
+
+    obs = build_obs()
+    model = build_model(damping_wing=False)
+
+    model.params["zred"] = 13
+    model.params["dla_logNh"] = 0
+    model.params["tage"] = 0.4
+    model.params["tau"] = 0.2
+    model.params["dust2"] = 0.0
+    model.params["igm_damping"] = False
+    theta1 = model.theta.copy()
+
+    pred1 = model.predict(theta1, obs, sps)
+    (spec1, phot1), mfrac = pred1
+    model.params["igm_damping"] = True
+    pred2 = model.predict(theta1, obs, sps)
+    (spec2, phot2), mfrac = pred2
+    assert np.any(phot2 < phot1)
+    assert np.any(spec2 < spec1)
+
+    if plot:
+        import matplotlib.pyplot as pl
+        fig, axes = pl.subplots(2, 1, sharex=True)
+        ax = axes[0]
+        ax.plot(obs[0].wavelength/1e4, spec2/spec1, label="e^{-tau}")
+        ax.legend()
+        ax = axes[1]
+        ax.plot(obs[0].wavelength/1e4, spec1, label="No damping wing")
+        ax.plot(obs[0].wavelength/1e4, spec2, label="with Damping wing")
+        ax.legend()
+        ax.set_xlabel(r"$\lambda (\mu{\rm m})$")
+        ax.set_ylabel(r"$f_\nu$")
+        fig.savefig("prospector_damping_wing.png")
diff --git a/tests/test_io.py b/tests/test_io.py
index 97ccbb9e..05b9db11 100644
--- a/tests/test_io.py
+++ b/tests/test_io.py
@@ -49,12 +49,13 @@ def build_obs(multispec=True):
 
 
 def test_observation_io(build_sps, plot=False):
-    sps = build_sps
+    #sps = build_sps
+    #model = build_model(add_neb=True)
 
     obslist = build_obs(multispec=True)
-    model = build_model(add_neb=True)
 
-    fn = "./test.h5"
+    r = np.random.int(0, 10000) #HAAACK
+    fn = f"./test-{r}.h5"
     # obs writing
     with h5py.File(fn, "w") as hf:
         write_obs_to_h5(hf, obslist)

From fb4f8862b8d0bfc84e01a14c21cdf91283f5daff Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sun, 28 Apr 2024 18:33:25 -0400
Subject: [PATCH 082/132] fix bug in test.

---
 tests/test_io.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_io.py b/tests/test_io.py
index 05b9db11..c711ee94 100644
--- a/tests/test_io.py
+++ b/tests/test_io.py
@@ -54,7 +54,7 @@ def test_observation_io(build_sps, plot=False):
 
     obslist = build_obs(multispec=True)
 
-    r = np.random.int(0, 10000) #HAAACK
+    r = np.random.randint(0, 10000) #HAAACK
     fn = f"./test-{r}.h5"
     # obs writing
     with h5py.File(fn, "w") as hf:

From 274b89b9b67111f1d49d543fe9b24783eb0d2bee Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 29 Apr 2024 08:43:09 -0400
Subject: [PATCH 083/132] suppress io tests till ci issues can be worked out.

---
 tests/{test_io.py => tests_io.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename tests/{test_io.py => tests_io.py} (100%)

diff --git a/tests/test_io.py b/tests/tests_io.py
similarity index 100%
rename from tests/test_io.py
rename to tests/tests_io.py

From dc5c681247a283285512c4b30dfb60048f88ccc7 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 16 May 2024 15:11:36 -0400
Subject: [PATCH 084/132] add a check for emission line names in fsps cloudy
 table

---
 prospect/models/sedmodel.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 3df21c42..38b383c5 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -406,6 +406,8 @@ def parse_elines(self):
             # unless some are explicitly fixed
             lnames_to_fit = self.params.get('elines_to_fit', all_lines)
             lnames_to_fix = self.params.get('elines_to_fix', np.array([]))
+            assert np.all(np.isin(lnames_to_fit, all_lines)), f"Some lines to fit ({lnames_to_fit})are not in the cloudy grid; see $SPS_HOME/data/emlines_info.dat for accepted names"
+            assert np.all(np.isin(lnames_to_fix, all_lines)), f"Some fixed lines ({lnames_to_fix}) are not in the cloudy grid; see $SPS_HOME/data/emlines_info.dat for accepted names"
             self._fit_eline = np.isin(all_lines, lnames_to_fit) & ~np.isin(all_lines, lnames_to_fix)
         else:
             self._fit_eline = np.zeros(len(all_lines), dtype=bool)
@@ -413,6 +415,8 @@ def parse_elines(self):
         self._fix_eline = ~self._fit_eline
 
         if self.params.get("elines_to_ignore", []):
+            assert np.all(np.isin(self.params["elines_to_ignore"], self.emline_info["name"])), f"Some ignored lines lines ({self.params['elines_to_ignore']}) are not in the cloudy grid; see $SPS_HOME/data/emlines_info.dat for accepted names"
+
             self._use_eline = ~np.isin(self.emline_info["name"],
                                        self.params["elines_to_ignore"])
 

From b3b3b82035ab9a5c0c16db0b9e5b0a3e0c1bf223 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 16 May 2024 15:04:10 -0400
Subject: [PATCH 085/132] Add DLS redshift option.

---
 prospect/models/sedmodel.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 5749f495..dd4157ef 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -55,6 +55,7 @@ def _available_parameters(self):
                     ("use_eline_priors", ""),
                     ("eline_prior_width", ""),
                     ("dla_logNh", "log_10 HI column density for damped Lyman-alpha absorption"),
+                    ("dla_redshift", "redshift of the DLA; if greater than zred then no absorption occurs"),
                     ("igm_damping", "boolean switch to turn on IGM damping wing redward of 1216 rest")]
 
         referenced_pars = [("mass", ""),
@@ -681,6 +682,12 @@ def add_dla(self, wave_rest, spec):
         logN = self.params.get("dla_logNh", None)
         if logN is None:
             return spec
+        # Shift spectrum to the restframe of the DLA
+        dla_z = self.params.get("dla_redshift", self._zred)
+        dz = self._zred - dla_z
+        if dz < 0:
+            return spec
+        wave_rest = wave_rest * (1 + dz)
         tau = voigt_profile(wave_rest, 10**logN)
         spec *= np.exp(-tau)
         return spec
@@ -693,7 +700,7 @@ def add_damping_wing(self, wave_rest, spec):
         return spec
 
     def observed_wave(self, wave, do_wavecal=False):
-        """Convert the restframe wavelngth grid to the observed frame wavelength
+        """Convert the restframe wavelength grid to the observed frame wavelength
         grid, optionally including wavelength calibration adjustments.  Requires
         that the ``_zred`` attribute is already set.
 

From ce4ea2efd92d27d64809461e8595ce51209a7573 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 20 May 2024 10:02:17 -0400
Subject: [PATCH 086/132] fix math for lower redshift dla.

---
 prospect/models/sedmodel.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index dd4157ef..26cae9cc 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -684,10 +684,9 @@ def add_dla(self, wave_rest, spec):
             return spec
         # Shift spectrum to the restframe of the DLA
         dla_z = self.params.get("dla_redshift", self._zred)
-        dz = self._zred - dla_z
-        if dz < 0:
+        if dla_z > self._zred:
             return spec
-        wave_rest = wave_rest * (1 + dz)
+        wave_rest = wave_rest * (1 + dla_z) / (1 + self._zred)
         tau = voigt_profile(wave_rest, 10**logN)
         spec *= np.exp(-tau)
         return spec

From 9599c70b044d9a6224f5c7b78beef70edd48e894 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 4 Jun 2024 11:46:05 -0400
Subject: [PATCH 087/132] hack to change spectral resolution on the fly.

---
 prospect/models/sedmodel.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 26cae9cc..fa99b9c2 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -201,6 +201,15 @@ def predict_spec(self, obs, **extras):
         # --- smooth and put on output wavelength grid ---
         # Instrumental smoothing (accounting for library resolution)
         # Put onto the spec.wavelength grid.
+
+        # HACK to change the spectral resolution on the fly
+        if hasattr(obs, "resolution_jitter_parameter"):
+            parn = getattr(obs, "resolution_jitter_parameter")
+            res_jitter = self.params.get(parn)
+            obs.padded_resolution = np.interp(obs.padded_wavelength,
+                                              obs.wavelength,
+                                              obs.resolution * res_jitter)
+
         inst_spec = obs.instrumental_smoothing(obs_wave, self._smooth_spec,
                                                libres=self._library_resolution)
 

From 5a1866d7e2e12dd26201042c3bba4f4c69ec0467 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 4 Jun 2024 12:02:07 -0400
Subject: [PATCH 088/132] fix bug when multiple elines are to be ignored.

---
 prospect/models/sedmodel.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 38b383c5..fd56f8c4 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -414,7 +414,7 @@ def parse_elines(self):
 
         self._fix_eline = ~self._fit_eline
 
-        if self.params.get("elines_to_ignore", []):
+        if np.any(self.params.get("elines_to_ignore", [])):
             assert np.all(np.isin(self.params["elines_to_ignore"], self.emline_info["name"])), f"Some ignored lines lines ({self.params['elines_to_ignore']}) are not in the cloudy grid; see $SPS_HOME/data/emlines_info.dat for accepted names"
 
             self._use_eline = ~np.isin(self.emline_info["name"],

From 8e2113c148e44ba2973981d24b6ea726802aa250 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 4 Jun 2024 12:24:33 -0400
Subject: [PATCH 089/132] fix bug when multiple elines are to be ignored.

---
 prospect/models/sedmodel.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index fd56f8c4..6fbf143b 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -414,7 +414,7 @@ def parse_elines(self):
 
         self._fix_eline = ~self._fit_eline
 
-        if np.any(self.params.get("elines_to_ignore", [])):
+        if "elines_to_ignore" in self.params:
             assert np.all(np.isin(self.params["elines_to_ignore"], self.emline_info["name"])), f"Some ignored lines lines ({self.params['elines_to_ignore']}) are not in the cloudy grid; see $SPS_HOME/data/emlines_info.dat for accepted names"
 
             self._use_eline = ~np.isin(self.emline_info["name"],

From f9cc18a17cb6f271edc889e4aa0d12c47cd78c14 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 18 Jun 2024 17:15:42 -0400
Subject: [PATCH 090/132] fixes to pixelization for undersampled spectra.

---
 prospect/observation/__init__.py    |  7 ++-
 prospect/observation/observation.py | 69 ++++++++++++------------
 tests/tests_undersampling.py        | 81 +++++++++++++++++++++++++++++
 3 files changed, 118 insertions(+), 39 deletions(-)
 create mode 100644 tests/tests_undersampling.py

diff --git a/prospect/observation/__init__.py b/prospect/observation/__init__.py
index ebf9c627..ff5cefa8 100644
--- a/prospect/observation/__init__.py
+++ b/prospect/observation/__init__.py
@@ -1,7 +1,10 @@
 # -*- coding: utf-8 -*-
 
-from .observation import Photometry, Spectrum, Lines
+from .observation import Observation
+from .observation import Photometry, Spectrum, Lines, UndersampledSpectrum
 from .observation import from_oldstyle, from_serial
 
-__all__ = ["Observation", "Photometry", "Spectrum", "Lines",
+__all__ = ["Observation",
+           "Photometry", "Spectrum", "Lines",
+           "UndersampledSpectrum",
            "from_oldstyle", "from_serial"]
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 81dce927..5f993d72 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -10,7 +10,9 @@
 from ..likelihood.noise_model import NoiseModel
 
 
-__all__ = ["Observation", "Spectrum", "Photometry", "Lines",
+__all__ = ["Observation",
+           "Spectrum", "Photometry", "Lines",
+           "UndersampledSpectrum",
            "from_oldstyle", "from_serial", "obstypes"]
 
 
@@ -351,35 +353,50 @@ def pad_wavelength_array(self):
             self.padded_resolution = np.interp(self.padded_wavelength, self.wavelength, self.resolution)
 
     def _smooth_lsf_fft(self, inwave, influx, outwave, sigma):
+
+        # construct cdf of 'resolution elements' as a fn of wavelength
         dw = np.gradient(outwave)
         sigma_per_pixel = (dw / sigma)
         cdf = np.cumsum(sigma_per_pixel)
         cdf /= cdf.max()
-        # check: do we need this?
+
+        # Get number of resolution elements: is this the best way to do this?
+        # Can't we just use unnormalized cdf above
         x_per_pixel = np.gradient(cdf)
         x_per_sigma = np.nanmedian(x_per_pixel / sigma_per_pixel)
         pix_per_sigma = 1
         N = pix_per_sigma / x_per_sigma
         nx = int(2**np.ceil(np.log2(N)))
+
         # now evenly sample in the x coordinate
-        x = np.linspace(0, 1, nx)
-        dx = 1.0 / nx
+        x = np.linspace(cdf[0], 1, nx)
+        dx = (1.0 - cdf[0]) / nx
+        # convert x back to wavelength, and get model at these wavelengths
         lam = np.interp(x, cdf, outwave)
         newflux = np.interp(lam, inwave, influx)
+
+        # smooth flux sampled at constant resolution
+        # could replace this with np.conv()
         flux_conv = smooth_fft(dx, newflux, x_per_sigma)
-        outflux = np.interp(outwave, lam, flux_conv)
+
+        # sample at wavelengths of pixels
+        outflux = self._pixelize(outwave, lam, flux_conv)
         return outflux
 
-    def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
+    def _pixelize(self, outwave, inwave, influx):
+        # could do this with an FFT in pixel space using a sinc
+        return np.interp(outwave, inwave, influx)
+
+    def instrumental_smoothing(self, model_wave_obsframe, model_flux, zred=0, libres=0):
         """Smooth a spectrum by the instrumental resolution, optionally
         accounting (in quadrature) the intrinsic library resolution.
 
         Parameters
         ----------
-        wave_obs : ndarray of shape (N_pix_model,)
+        model_wave_obsframe : ndarray of shape (N_pix_model,)
             Observed frame wavelengths, in units of AA for the *model*
 
-        influx : ndarray of shape (N_pix_model,)
+        model_flux : ndarray of shape (N_pix_model,)
             Flux array corresponding to the observed frame wavelengths
 
         libres : float or ndarray of shape (N_pix_model,)
@@ -396,12 +413,12 @@ def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
             ``influx`` is simply interpolated onto the wavelength grid
         """
         if self.wavelength is None:
-            return influx
+            return model_flux
         if self.resolution is None:
-            return np.interp(self.wavelength, wave_obs, influx)
+            return np.interp(self.wavelength, model_wave_obsframe, model_flux)
 
         # interpolate library resolution onto the instrumental wavelength grid
-        Klib = np.interp(self.padded_wavelength, wave_obs, libres)
+        Klib = np.interp(self.padded_wavelength, model_wave_obsframe, libres)
         assert np.all(self.padded_resolution >= Klib), "data higher resolution than library"
 
         # quadrature difference of instrumental and library resolution
@@ -409,8 +426,8 @@ def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
         Kdelta_lambda = Kdelta / CKMS * self.padded_wavelength
 
         # Smooth by the difference kernel
-        outspec_padded = self._smooth_lsf_fft(wave_obs,
-                                              influx,
+        outspec_padded = self._smooth_lsf_fft(model_wave_obsframe,
+                                              model_flux,
                                               self.padded_wavelength,
                                               Kdelta_lambda)
 
@@ -419,30 +436,8 @@ def instrumental_smoothing(self, wave_obs, influx, zred=0, libres=0):
 
 class UndersampledSpectrum(Spectrum):
 
-    def _smooth_lsf_fft(self, inwave, influx, outwave, sigma):
-        raise NotImplementedError
-        # TODO does this need to be changed if outwave is undersampled?
-        # TODO testing
-        dw = np.gradient(outwave)
-        sigma_per_pixel = (dw / sigma)
-        cdf = np.cumsum(sigma_per_pixel)
-        cdf /= cdf.max()
-        # check: do we need this?
-        x_per_pixel = np.gradient(cdf)
-        x_per_sigma = np.nanmedian(x_per_pixel / sigma_per_pixel)
-        pix_per_sigma = 1
-        N = pix_per_sigma / x_per_sigma
-        nx = int(2**np.ceil(np.log2(N)))
-        # now evenly sample in the x coordinate
-        x = np.linspace(0, 1, nx)
-        dx = 1.0 / nx
-        # convert x to wave
-        lam = np.interp(x, cdf, outwave)
-        newflux = np.interp(lam, inwave, influx)
-        flux_conv = smooth_fft(dx, newflux, x_per_sigma)
-        # TODO - does this do the right thing regarding edge/center of pixels?
-        outflux = rebin(outwave, lam, flux_conv)
-        return outflux
+    def _pixelize(self, outwave, inwave, influx):
+        return rebin(outwave, inwave, influx)
 
 
 class Lines(Spectrum):
diff --git a/tests/tests_undersampling.py b/tests/tests_undersampling.py
new file mode 100644
index 00000000..4a6e7432
--- /dev/null
+++ b/tests/tests_undersampling.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+#import pytest
+
+from prospect.sources import CSPSpecBasis
+from prospect.models import SpecModel, templates
+from prospect.observation import Spectrum, UndersampledSpectrum
+
+#@pytest.fixture(scope="module")
+def build_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+def build_model(add_neb=False, sigma_v=200):
+    model_params = templates.TemplateLibrary["ssp"]
+    model_params.update(templates.TemplateLibrary["spectral_smoothing"])
+    model_params["sigma_smooth"] = dict(N=1, isfree=False, init=sigma_v)
+    if add_neb:
+        model_params.update(templates.TemplateLibrary["nebular"])
+        model_params["nebemlineinspec"]["init"] = np.array([False])
+        model_params["eline_sigma"] = dict(N=1, isfree=False, init=sigma_v)
+
+    model_params["tage"]["init"] = 0.2
+
+    return SpecModel(model_params)
+
+
+def build_obs(undersampling=4):
+
+    wmin, wmax = 4000, 7000
+    fwhm = 5  # instrumental LSF FWHM in AA
+    dl_s = fwhm / 3 # well sampled spectrum
+    dl_u = fwhm / 2 * undersampling # horribly undersampled spectrum
+
+    wave = np.arange(wmin, wmax, dl_s)
+    resolution = (fwhm/2.355) / wave * 2.998e5  # in km/s
+    full = Spectrum(wavelength=wave.copy(),
+                    flux=np.ones(len(wave)),
+                    uncertainty=np.ones(len(wave)) / 10,
+                    resolution=resolution,
+                    mask=slice(None),
+                    name="Oversampled")
+    wave = np.arange(wmin, wmax, dl_u)
+    resolution = (fwhm/2.355) / wave * 2.998e5  # in km/s
+    under = UndersampledSpectrum(wavelength=wave.copy(),
+                                 flux=np.ones(len(wave)),
+                                 uncertainty=np.ones(len(wave)) / 10,
+                                 resolution=resolution,
+                                 mask=slice(None),
+                                 name="Undersampled")
+
+    obslist = [full, under]
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+#def test_undersample(build_sps, plot=False):
+if __name__ == "__main__":
+    plot = True
+
+    sps = build_sps()
+    obslist = build_obs()
+    model = build_model(add_neb=True)
+
+    preds, x = model.predict(model.theta, observations=obslist, sps=sps)
+
+    # TODO: turn this plot into an actual test
+    if plot:
+        import matplotlib.pyplot as pl
+        fig, ax = pl.subplots()
+        ax.plot(model.observed_wave(model._wave), model._smooth_spec, label="intrinsic")
+        for p, o in zip(preds, obslist):
+           if o.kind == "photometry":
+               ax.plot(o.wavelength, p, "o")
+           else:
+               ax.step(o.wavelength, p, where="mid", label=o.name)
+
+        ax.set_xlim(o.wavelength.min(), o.wavelength.max())
\ No newline at end of file

From 60919e105b1b0b9787c9654fa7871e12fc5d6750 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 18 Jun 2024 17:17:47 -0400
Subject: [PATCH 091/132] rename velocity_smoothing -> losvd_smoothing;
 decrease min wavelength for smoothing from 1216 to 912AA; docstring updates.

---
 prospect/models/sedmodel.py | 79 +++++++++++++++++++++----------------
 1 file changed, 46 insertions(+), 33 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index fa99b9c2..fc1b88f8 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -123,7 +123,7 @@ def predict(self, theta, observations=None, sps=None, **extras):
                                          self._eline_lum)**2)
 
         # physical velocity smoothing of the whole UV/NIR spectrum
-        self._smooth_spec = self.velocity_smoothing(self._wave, self._norm_spec)
+        self._smooth_spec = self.losvd_smoothing(self._wave, self._norm_spec)
 
         # Ly-alpha absorption
         self._smooth_spec = self.add_dla(self._wave, self._smooth_spec)
@@ -159,7 +159,7 @@ def predict_spec(self, obs, **extras):
 
         It generates the following attributes
 
-          + ``_outwave`` - Wavelength grid (observed frame)
+          + ``_outwave`` - Wavelength grid (instrument frame)
           + ``_speccal`` - Calibration vector
           + ``_sed`` - Intrinsic spectrum (before cilbration vector applied but including emission lines)
 
@@ -172,20 +172,24 @@ def predict_spec(self, obs, **extras):
         Numerous quantities related to the emission lines are also cached (see
         ``cache_eline_parameters()`` and ``fit_mle_elines()`` for details.)
 
-        :param obs:
-            An instance of `Spectrum`, containing the output wavelength array,
-            the observed fluxes and uncertainties thereon.  Assumed to be the
-            result of :py:meth:`utils.obsutils.rectify_obs`
+        Parameters
+        ----------
+        obs : Instance of :py:class:`observation.Spectrum`
+            Must contain the output wavelength array, the observed fluxes and
+            uncertainties thereon.  Assumed to be the result of
+            :py:meth:`utils.obsutils.rectify_obs`
 
-        :param sigma_spec: (optional)
+        sigma_spec : (optional)
             The covariance matrix for the spectral noise. It is only used for
             emission line marginalization.
 
-        :returns spec:
+        Returns
+        -------
+        spec : ndarray of shape ``(nwave,)``
             The prediction for the observed frame spectral flux these
             parameters, at the wavelengths specified by ``obs['wavelength']``,
-            including multiplication by the calibration vector.
-            ndarray of shape ``(nwave,)`` in units of maggies.
+            including multiplication by the calibration vector. in units of
+            maggies.
         """
         # redshift model wavelength
         obs_wave = self.observed_wave(self._wave, do_wavecal=False)
@@ -230,11 +234,11 @@ def predict_spec(self, obs, **extras):
         emask = self._fit_eline_pixelmask
         if emask.any():
             # We need the spectroscopic covariance matrix to do emission line optimization and marginalization
-            sigma_spec = None
+            spec_unc = None
             # FIXME: do this only if the noise model is non-trivial, and make sure masking is consistent
             #vectors = obs.noise.populate_vectors(obs)
-            #sigma_spec = obs.noise.construct_covariance(**vectors)
-            self._fit_eline_spec = self.fit_mle_elines(obs, calibrated_spec, sigma_spec)
+            #spec_unc = obs.noise.construct_covariance(**vectors)
+            self._fit_eline_spec = self.fit_mle_elines(obs, calibrated_spec, spec_unc)
             calibrated_spec[emask] += self._fit_eline_spec.sum(axis=1)
 
         # --- cache intrinsic spectrum ---
@@ -262,17 +266,20 @@ def predict_lines(self, obs, **extras):
         ``_predicted_line_inds`` which is the indices of the line that are predicted.
         ``cache_eline_parameters()`` and ``fit_elines()`` for details).
 
-
-        :param obs:
-            A ``data.observation.Lines()`` instance, with the attributes
+        Parameters
+        ----------
+        obs : Instance of :py:class:``observation.Lines``
+            Must have the attributes:
             + ``"wavelength"`` - the observed frame wavelength of the lines.
             + ``"line_ind"`` - a set of indices identifying the observed lines in
             the fsps line array
 
-        :returns elum:
-            The prediction for the observed frame nebular emission line flux these
-            parameters, at the wavelengths specified by ``obs['wavelength']``,
-            ndarray of shape ``(nwave,)`` in units of erg/s/cm^2.
+        Returns
+        -------
+        elum : ndarray of shape ``(nwave,)``
+            The prediction for the observed frame nebular emission line flux
+            these parameters, at the wavelengths specified by
+            ``obs['wavelength']``, in units of erg/s/cm^2.
         """
         obs_wave = self.observed_wave(self._eline_wave, do_wavecal=False)
         self._outwave = obs.get('wavelength', obs_wave)
@@ -303,15 +310,17 @@ def predict_phot(self, filterset):
           + ``_ewave_obs`` and ``_eline_lum`` - emission line parameters from
             the SPS model
 
-        :param filters:
-            Instance of :py:class:`sedpy.observate.FilterSet` or list of
+        Parameters
+        ----------
+        filters : Instance of :py:class:`sedpy.observate.FilterSet` or list of
             :py:class:`sedpy.observate.Filter` objects. If there is no
             photometry, ``None`` should be supplied.
 
-        :returns phot:
-            Observed frame photometry of the model SED through the given filters.
-            ndarray of shape ``(len(filters),)``, in units of maggies.
-            If ``filters`` is None, this returns 0.0
+        Returns
+        -------
+        phot : ndarray of shape ``(len(filters),)``
+            Observed frame photometry of the model SED through the given filters,
+            in units of maggies. If ``filters`` is None, this returns 0.0
         """
         if filterset is None:
             return 0.0
@@ -331,7 +340,9 @@ def flux_norm(self):
         """Compute the scaling required to go from Lsun/Hz/Msun to maggies.
         Note this includes the (1+z) factor required for flux densities.
 
-        :returns norm: (float)
+        Returns
+        -------
+        norm : (float)
             The normalization factor, scalar float.
         """
         # distance factor
@@ -444,7 +455,9 @@ def cache_eline_parameters(self, obs, nsigma=5, forcelines=False):
         N.B. This must be run separately for each `Observation` instance at each
         likelihood call!!!
 
-        param
+        :param obs: observation.Spectrum() subclass
+            If given, provides the instrumental resolution for broadening the
+            emission lines.
 
         :param nsigma: (float, optional, default: 5.)
             Number of sigma from a line center to use for defining which lines
@@ -673,12 +686,12 @@ def get_eline_gaussians(self, lineidx=slice(None), wave=None):
 
         return eline_gaussians
 
-    def velocity_smoothing(self, wave, spec):
-        """Smooth the spectrum.  See :py:func:`prospect.utils.smoothing.smoothspec`
-        for details.
+    def losvd_smoothing(self, wave, spec):
+        """Smooth the spectrum in velocity space.
+        See :py:func:`prospect.utils.smoothing.smoothspec` for details.
         """
         sigma = self.params.get("sigma_smooth", 300)
-        sel = (wave > 1.2e3) & (wave < 2.5e4)
+        sel = (wave > 0.912e3) & (wave < 2.5e4)
         # TODO: make a fast version of this that is also accurate
         sm = smoothspec(wave, spec, sigma, outwave=wave[sel],
                         smoothtype="vel", fftsmooth=True)
@@ -1003,7 +1016,7 @@ def predict_spec(self, obs, **extras):
         self.cache_eline_parameters(obs, nsigma=nsigma)
 
         # --- smooth and put on output wavelength grid ---
-        smooth_spec = self.velocity_smoothing(obs_wave, self._norm_spec)
+        smooth_spec = self.losvd_smoothing(obs_wave, self._norm_spec)
         smooth_spec = obs.instrumental_smoothing(obs_wave, smooth_spec,
                                                  libres=self._library_resolution)
 

From 51c09d98c8fa01de3ca69dad4bd2093ab6d5790c Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 21 Jun 2024 16:50:09 -0400
Subject: [PATCH 092/132] more detail in the undersampled spectrum test.

---
 tests/tests_undersampling.py | 34 ++++++++++++++---
 tests/timing_tests.py        | 71 ++++++++++++++++++++++++++++++++++++
 2 files changed, 99 insertions(+), 6 deletions(-)
 create mode 100644 tests/timing_tests.py

diff --git a/tests/tests_undersampling.py b/tests/tests_undersampling.py
index 4a6e7432..8ee8d025 100644
--- a/tests/tests_undersampling.py
+++ b/tests/tests_undersampling.py
@@ -42,17 +42,31 @@ def build_obs(undersampling=4):
                     uncertainty=np.ones(len(wave)) / 10,
                     resolution=resolution,
                     mask=slice(None),
-                    name="Oversampled")
+                    name="Oversampled no pixelization")
+
+    full_pix = UndersampledSpectrum(wavelength=wave.copy(),
+                    flux=np.ones(len(wave)),
+                    uncertainty=np.ones(len(wave)) / 10,
+                    resolution=resolution,
+                    mask=slice(None),
+                    name="Oversampled but pixelized")
+
     wave = np.arange(wmin, wmax, dl_u)
     resolution = (fwhm/2.355) / wave * 2.998e5  # in km/s
-    under = UndersampledSpectrum(wavelength=wave.copy(),
+    under_pix = UndersampledSpectrum(wavelength=wave.copy(),
                                  flux=np.ones(len(wave)),
                                  uncertainty=np.ones(len(wave)) / 10,
                                  resolution=resolution,
                                  mask=slice(None),
-                                 name="Undersampled")
+                                 name="Undersampled and pixelized")
+    under = Spectrum(wavelength=wave.copy(),
+                                 flux=np.ones(len(wave)),
+                                 uncertainty=np.ones(len(wave)) / 10,
+                                 resolution=resolution,
+                                 mask=slice(None),
+                                 name="Undersampled no pixelization")
 
-    obslist = [full, under]
+    obslist = [full, full_pix, under, under_pix]
     [obs.rectify() for obs in obslist]
     return obslist
 
@@ -70,12 +84,20 @@ def build_obs(undersampling=4):
     # TODO: turn this plot into an actual test
     if plot:
         import matplotlib.pyplot as pl
-        fig, ax = pl.subplots()
-        ax.plot(model.observed_wave(model._wave), model._smooth_spec, label="intrinsic")
+        fig, axes = pl.subplots(2, 1, sharex=True)
+        ax = axes[0]
+        ax.plot(model.observed_wave(model._wave), model._smooth_spec, label="LOSVD only")
         for p, o in zip(preds, obslist):
            if o.kind == "photometry":
                ax.plot(o.wavelength, p, "o")
            else:
                ax.step(o.wavelength, p, where="mid", label=o.name)
+        ax.legend()
+
+        ax = axes[1]
+        ax.plot(obslist[0].wavelength, preds[0]/preds[1], label="Oversampled")
+        ax.plot(obslist[2].wavelength, preds[2]/preds[3], label="Undersampled")
+        ax.set_ylabel("Ratio of pixel-unconvolved to pixel-convolved flux")
+        ax.legend()
 
         ax.set_xlim(o.wavelength.min(), o.wavelength.max())
\ No newline at end of file
diff --git a/tests/timing_tests.py b/tests/timing_tests.py
new file mode 100644
index 00000000..749546d5
--- /dev/null
+++ b/tests/timing_tests.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import time
+import numpy as np
+from sedpy import observate
+
+from prospect import prospect_args
+from prospect.utils.obsutils import fix_obs
+from prospect.models.templates import TemplateLibrary
+from prospect.models.sedmodel import SpecModel
+
+from prospect.sources import CSPSpecBasis, FastStepBasis
+
+
+def build_model(nebular=True):
+    model_pars = TemplateLibrary["continuity_sfh"]
+    if nebular:
+        model_pars.update(TemplateLibrary["nebular"])
+    Basis = FastStepBasis
+    return SpecModel(model_pars), Basis(zcontinuous=1)
+
+
+def build_obs(spec=False):
+    fnames = [f"sdss_{b}0" for b in "ugriz"]
+    filts = observate.load_filters(fnames, gridded=True)
+    obs = dict(filters=filts,
+               maggies=np.zeros(len(fnames)),
+               maggies_unc=np.ones(len(fnames)),
+               wavelength=np.linspace(3000, 9000, 1000),
+               spectrum=np.ones(1000),
+               unc=np.ones(1000)*0.1)
+    if not spec:
+        obs["spectrum"] = None
+    obs = fix_obs(obs)
+
+    try:
+        from prospect.observation import from_oldstyle
+        obs = from_oldstyle(obs)
+    except(ImportError):
+        pass
+
+    return obs
+
+
+def predict(model, obs, sps):
+    z = np.random.uniform(-1, 0)
+    model.params["logzsol"] = np.array([z])
+    preds, x = model.predict(model.theta, observations=obs, sps=sps)
+    return preds
+
+
+if __name__ == "__main__":
+
+    obs = build_obs()
+    model, sps = build_model(nebular=False)
+
+    # make sure models get cached
+    logzsol_prior = model.config_dict["logzsol"]['prior']
+    lo, hi = logzsol_prior.range
+    logzsol_grid = np.around(np.arange(lo, hi, step=0.1), decimals=2)
+    for logzsol in logzsol_grid:
+        model.params["logzsol"] = np.array([logzsol])
+        _ = model.predict(model.theta, observations=obs, sps=sps)
+
+    N = 100
+    tic = time.time()
+    for i in range(N):
+        _ = predict(model, obs, sps)
+    toc = time.time()
+    print((toc-tic) / N)
\ No newline at end of file

From b055d6f9dd9a627fd642a1b22d47474e651bcd52 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 1 Jul 2024 11:07:43 -0400
Subject: [PATCH 093/132] add a method for producing an 'intrinsic' spectrum.

---
 prospect/models/sedmodel.py         | 72 ++++++++++++++++++++++++++---
 prospect/observation/__init__.py    |  4 +-
 prospect/observation/observation.py | 17 ++++++-
 3 files changed, 83 insertions(+), 10 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index fc1b88f8..46ed7c68 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -143,10 +143,68 @@ def predict_obs(self, obs):
             prediction = self.predict_lines(obs)
         elif obs.kind == "photometry":
             prediction = self.predict_phot(obs.filterset)
+        elif obs.kind == "intrinsic":
+            prediction = self.predict_intrinsic(obs)
         else:
             prediction = None
         return prediction
 
+    def predict_intrinsic(self, obs_dummy, continuum_only=True, **extras):
+        """Generate a prediction for the observed spectrum.  This method assumes
+        that the parameters have been set and predict_spec has previously been called.
+
+        Parameters
+        ----------
+        obs : Instance of :py:class:`observation.Spectrum`
+            Must contain the output wavelength array, the observed fluxes and
+            uncertainties thereon.  Assumed to be the result of
+            :py:meth:`utils.obsutils.rectify_obs`
+
+        Returns
+        -------
+        spec : ndarray of shape ``(nwave,)``
+            The prediction for the observed frame spectral flux these
+            parameters, at the wavelengths specified by ``obs['wavelength']``,
+            including multiplication by the calibration vector. in units of
+            maggies.
+        """
+        obs = obs_dummy
+
+        # redshift model wavelength
+        obs_wave = self.observed_wave(self._wave, do_wavecal=False)
+
+        # get output wavelength vector
+        self._outwave = obs.wavelength
+        if self._outwave is None:
+            self._outwave = obs_wave
+
+        # Set up for emission lines
+        self.cache_eline_parameters(obs)
+
+        # --- smooth and put on output wavelength grid ---
+        # Instrumental smoothing (accounting for library resolution)
+        # Put onto the spec.wavelength grid.
+        inst_spec = obs.instrumental_smoothing(obs_wave, self._smooth_spec,
+                                               libres=self._library_resolution)
+
+        # --- add fixed lines if necessary ---
+        emask = self._fix_eline_pixelmask
+        if emask.any() & (~continuum_only):
+            inds = self._fix_eline & self._valid_eline
+            espec = self.predict_eline_spec(line_indices=inds,
+                                            wave=self._outwave[emask])
+            self._fix_eline_spec = espec
+            inst_spec[emask] += self._fix_eline_spec.sum(axis=1)
+
+
+        # --- add (previously) fitted lines if necessary ---
+        emask = self._fit_eline_pixelmask
+        if emask.any() (~continuum_only):
+            inst_spec[emask] += self._fit_eline_spec.sum(axis=1)
+
+        return inst_spec
+
+
     def predict_spec(self, obs, **extras):
         """Generate a prediction for the observed spectrum.  This method assumes
         that the parameters have been set and that the following attributes are
@@ -226,9 +284,9 @@ def predict_spec(self, obs, **extras):
             self._fix_eline_spec = espec
             inst_spec[emask] += self._fix_eline_spec.sum(axis=1)
 
-        # --- calibration ---
+        # --- (de-) apply calibration ---
         self._speccal = self.spec_calibration(obs=obs, spec=inst_spec, **extras)
-        calibrated_spec = inst_spec * self._speccal
+        inst_spec = inst_spec * self._speccal
 
         # --- fit and add lines if necessary ---
         emask = self._fit_eline_pixelmask
@@ -238,13 +296,13 @@ def predict_spec(self, obs, **extras):
             # FIXME: do this only if the noise model is non-trivial, and make sure masking is consistent
             #vectors = obs.noise.populate_vectors(obs)
             #spec_unc = obs.noise.construct_covariance(**vectors)
-            self._fit_eline_spec = self.fit_mle_elines(obs, calibrated_spec, spec_unc)
-            calibrated_spec[emask] += self._fit_eline_spec.sum(axis=1)
+            self._fit_eline_spec = self.fit_mle_elines(obs, inst_spec, spec_unc)
+            inst_spec[emask] += self._fit_eline_spec.sum(axis=1)
 
-        # --- cache intrinsic spectrum ---
-        self._sed = calibrated_spec / self._speccal
+        # --- cache intrinsic spectrum for this observation ---
+        self._sed = inst_spec / self._speccal
 
-        return calibrated_spec
+        return inst_spec
 
     def predict_lines(self, obs, **extras):
         """Generate a prediction for the observed nebular line fluxes.  This method assumes
diff --git a/prospect/observation/__init__.py b/prospect/observation/__init__.py
index ff5cefa8..282e93c6 100644
--- a/prospect/observation/__init__.py
+++ b/prospect/observation/__init__.py
@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 
 from .observation import Observation
-from .observation import Photometry, Spectrum, Lines, UndersampledSpectrum
+from .observation import Photometry, Spectrum, Lines, UndersampledSpectrum, IntrinsicSpectrum
 from .observation import from_oldstyle, from_serial
 
 __all__ = ["Observation",
            "Photometry", "Spectrum", "Lines",
-           "UndersampledSpectrum",
+           "UndersampledSpectrum", "InstrinsicSpectrum",
            "from_oldstyle", "from_serial"]
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 5f993d72..63a8552f 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -12,7 +12,7 @@
 
 __all__ = ["Observation",
            "Spectrum", "Photometry", "Lines",
-           "UndersampledSpectrum",
+           "UndersampledSpectrum", "IntrinsicSpectrum",
            "from_oldstyle", "from_serial", "obstypes"]
 
 
@@ -435,11 +435,26 @@ def instrumental_smoothing(self, model_wave_obsframe, model_flux, zred=0, libres
 
 
 class UndersampledSpectrum(Spectrum):
+    """
+    As for Spectrum, but account for pixelization effects when pixels
+    undersamplesthe instrumental LSF.
+    """
 
     def _pixelize(self, outwave, inwave, influx):
         return rebin(outwave, inwave, influx)
 
 
+class IntrinsicSpectrum(Spectrum):
+
+    """
+    As for Spectrum, but predictions for this object type will not include
+    polynomial fitting or fitting of the emission line strengths (previously fit
+    and cached emission luminosities will be used.)
+    """
+
+    _kind = "intrinsic"
+
+
 class Lines(Spectrum):
 
     _kind = "lines"

From 60bc8195692d9965cd943f9e1caa750241b7ef57 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 5 Jul 2024 21:32:29 -0400
Subject: [PATCH 094/132] updating changelog for version 1.4.0

---
 CHANGELOG.rst | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 42b1419f..a2288ed8 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -1,5 +1,16 @@
 .. :changelog:
 
+v1.4.0 (2024-07-06)
++++++++++++++++++++
+- Adds the stochastic SFH hyper-prior courtesy @jwan22
+- Adds an explicit check of any provided emission line names and fixes a bug
+  when multiple emission lines are ignored
+
+Last release before v2.0
+
+`Full Changelog <https://github.com/bd-j/prospector/compare/v1.3.0...v1.4.0>`_
+
+
 v1.3.0 (2024-03-27)
 +++++++++++++++++++
 - Adds the prospector-beta SFH priors and documentation courtesy @wangbingjie

From 5e30a18ecf662a9ceafe99f4bc109c1945b81752 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 8 Jul 2024 15:47:29 -0400
Subject: [PATCH 095/132] store sampling duration.

---
 prospect/io/write_results.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index 790ebe57..0ce30d8b 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -133,6 +133,7 @@ def write_hdf5(hfile, run_params, model, obs,
     for k, v in meta.items():
         hf.attrs[k] = v
     hf.flush()
+    hf.attrs['sampling_duration'] = json.dumps(tsample)
 
     # -----------------
     # Optimizer info
@@ -209,7 +210,8 @@ def dynesty_to_struct(dyout, model):
                   lnlike=dyout['logl'],
                   efficiency=np.atleast_1d(dyout['eff']),
                   logz=np.atleast_1d(dyout['logz']),
-                  ncall=json.dumps(dyout['ncall'].tolist())
+                  ncall=np.atleast_1d(dyout['ncall'])
+                  #ncall=json.dumps(dyout['ncall'].tolist())
                  )
     return chaincat, extras
 

From e86c0b8f7b9e90901e08781fd0823ca808241cb3 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 8 Jul 2024 15:56:24 -0400
Subject: [PATCH 096/132] attach polyorder parameter to individual Spectrum()
 instances.

---
 prospect/models/sedmodel.py         | 7 ++++---
 prospect/observation/observation.py | 3 +++
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 13fb7dbd..ca3f6c2e 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -852,6 +852,7 @@ class PolySpecModel(SpecModel):
     """
 
     def _available_parameters(self):
+        # These should both be attached to the Observation instance as attributes
         pars = [("polyorder", "order of the polynomial to fit"),
                 ("poly_regularization", "vector of length `polyorder` providing regularization for each polynomial term"),
                 ("median_polynomial", "if > 0, median smooth with a kernel of width order/range/median_polynomial before fitting")
@@ -881,8 +882,9 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
         if theta is not None:
             self.set_parameters(theta)
 
-        # norm = self.params.get('spec_norm', 1.0)
-        order = np.squeeze(self.params.get('polyorder', 0))
+        #order = np.squeeze(self.params.get('polyorder', 0))
+        order = np.squeeze(getattr(obs, "polynomial_order", 0))
+        reg = np.squeeze(getattr(obs, "poly_regularization", 0))
         polyopt = ((order > 0) &
                    (obs.get('spectrum', None) is not None))
         if polyopt:
@@ -906,7 +908,6 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
             yvar = yerr**2
             A = chebvander(x[mask], order)
             ATA = np.dot(A.T, A / yvar[:, None])
-            reg = self.params.get('poly_regularization', 0.)
             if np.any(reg > 0):
                 ATA += reg**2 * np.eye(order+1)
             ATAinv = np.linalg.inv(ATA)
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 63a8552f..6d449450 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -296,6 +296,7 @@ def __init__(self,
                  calibration=None,
                  name=None,
                  lambda_pad=100,
+                 polyorder=0.
                  **kwargs):
 
         """
@@ -324,6 +325,8 @@ def __init__(self,
         self.calibration = calibration
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
         self.wavelength = wavelength
+        self.polynomial_order = polyorder
+        self.polynomial_regularization = 0.
 
     @property
     def wavelength(self):

From c96c164c1d4269c1a48d1cbb02dfcbf25f026b29 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 8 Jul 2024 16:00:31 -0400
Subject: [PATCH 097/132] fix bug in polynomial_order.

---
 prospect/models/sedmodel.py         | 6 +++---
 prospect/observation/observation.py | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index ca3f6c2e..36e52ef2 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -853,8 +853,8 @@ class PolySpecModel(SpecModel):
 
     def _available_parameters(self):
         # These should both be attached to the Observation instance as attributes
-        pars = [("polyorder", "order of the polynomial to fit"),
-                ("poly_regularization", "vector of length `polyorder` providing regularization for each polynomial term"),
+        pars = [("polynomial_order", "order of the polynomial to fit"),
+                ("polynomial_regularization", "vector of length `polyorder` providing regularization for each polynomial term"),
                 ("median_polynomial", "if > 0, median smooth with a kernel of width order/range/median_polynomial before fitting")
                 ]
 
@@ -930,7 +930,7 @@ class SplineSpecModel(SpecModel):
     """
 
     def _available_parameters(self):
-        pars = [("spline_knot_wave", "vector of wavelengths for the location ot he spline knots"),
+        pars = [("spline_knot_wave", "vector of wavelengths for the location of the spline knots"),
                 ("spline_knot_spacing", "spacing between knots, in units of wavelength"),
                 ("spline_knot_n", "number of interior knots between minimum and maximum unmasked wavelength")
                 ]
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 6d449450..1d0cd5e5 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -296,7 +296,7 @@ def __init__(self,
                  calibration=None,
                  name=None,
                  lambda_pad=100,
-                 polyorder=0.
+                 polynomial_order=0.,
                  **kwargs):
 
         """
@@ -325,7 +325,7 @@ def __init__(self,
         self.calibration = calibration
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
         self.wavelength = wavelength
-        self.polynomial_order = polyorder
+        self.polynomial_order = polynomial_order
         self.polynomial_regularization = 0.
 
     @property

From 09f11ca4e32f3d61c99e3c00289a58e6c26565e1 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 9 Jul 2024 11:00:57 -0400
Subject: [PATCH 098/132] let model params override observation specific
 polynomial, for backwards compatibility.

---
 prospect/models/sedmodel.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 36e52ef2..41abbbba 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -198,7 +198,6 @@ def predict_intrinsic(self, obs_dummy, continuum_only=True, **extras):
             self._fix_eline_spec = espec
             inst_spec[emask] += self._fix_eline_spec.sum(axis=1)
 
-
         # --- add (previously) fitted lines if necessary ---
         emask = self._fit_eline_pixelmask
         if emask.any() (~continuum_only):
@@ -882,9 +881,12 @@ def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
         if theta is not None:
             self.set_parameters(theta)
 
-        #order = np.squeeze(self.params.get('polyorder', 0))
+        # polynomial order and regularization, from the obs object or overridden from the model params
         order = np.squeeze(getattr(obs, "polynomial_order", 0))
-        reg = np.squeeze(getattr(obs, "poly_regularization", 0))
+        order = np.squeeze(self.params.get('polyorder', order))
+        reg = np.squeeze(getattr(obs, "polynomial_regularization", 0.))
+        reg = self.params.get('poly_regularization', reg)
+
         polyopt = ((order > 0) &
                    (obs.get('spectrum', None) is not None))
         if polyopt:

From 1717fd082e2128f7cc85a047fb5a6fe136467695 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 8 Jul 2024 16:23:50 -0400
Subject: [PATCH 099/132] beginning to move spectral claibration code to
 Observation objects.

---
 prospect/models/sedmodel.py         |  7 ++--
 prospect/observation/observation.py | 64 +++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+), 3 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 41abbbba..965dea30 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -285,8 +285,9 @@ def predict_spec(self, obs, **extras):
             inst_spec[emask] += self._fix_eline_spec.sum(axis=1)
 
         # --- (de-) apply calibration ---
-        self._speccal = self.spec_calibration(obs=obs, spec=inst_spec, **extras)
-        inst_spec = inst_spec * self._speccal
+        #self._speccal = self.spec_calibration(obs=obs, spec=inst_spec, **extras)
+        response = obs.get_calibration_vector(spec=inst_spec)
+        inst_spec = inst_spec * response
 
         # --- fit and add lines if necessary ---
         emask = self._fit_eline_pixelmask
@@ -300,7 +301,7 @@ def predict_spec(self, obs, **extras):
             inst_spec[emask] += self._fit_eline_spec.sum(axis=1)
 
         # --- cache intrinsic spectrum for this observation ---
-        self._sed = inst_spec / self._speccal
+        self._sed.append(inst_spec / response)
 
         return inst_spec
 
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 1d0cd5e5..f94894c2 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -504,6 +504,70 @@ def __init__(self,
         self.line_ind = np.array(line_ind).as_type(int)
 
 
+
+class PolyCal:
+
+    def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
+        """Implements a Chebyshev polynomial calibration model. This uses
+        least-squares to find the maximum-likelihood Chebyshev polynomial of a
+        certain order describing the ratio of the observed spectrum to the model
+        spectrum, conditional on all other parameters. If emission lines are
+        being marginalized out, they are excluded from the least-squares fit.
+
+        Parameters
+        ----------
+        obs :  Instance of `Spectrum`
+
+        spec : ndarray of shape (nwave,)
+            The model spectrum.
+
+        Returns
+        -------
+        cal : ndarray of shape (nwave,)
+           A polynomial given by :math:`\sum_{m=0}^M a_{m} * T_m(x)`.
+        """
+        if theta is not None:
+            self.set_parameters(theta)
+
+        #order = np.squeeze(self.params.get('polyorder', 0))
+        order = np.squeeze(getattr(obs, "polynomial_order", 0))
+        reg = np.squeeze(getattr(obs, "poly_regularization", 0))
+        polyopt = ((order > 0) &
+                   (obs.get('spectrum', None) is not None))
+        if polyopt:
+            # generate mask
+            # remove region around emission lines if doing analytical marginalization
+            mask = obs.get('mask', np.ones_like(obs['wavelength'], dtype=bool)).copy()
+            if self.params.get('marginalize_elines', False):
+                mask[self._fit_eline_pixelmask] = 0
+
+            # map unmasked wavelengths to the interval -1, 1
+            # masked wavelengths may have x>1, x<-1
+            x = self.wave_to_x(obs["wavelength"], mask)
+            y = (obs['spectrum'] / spec)[mask] - 1.0
+
+            if self.params.get('median_polynomial', 0) > 0:
+                kernel_factor = self.params["median_polynomial"]
+                knl = int((x.max() - x.min()) / order / kernel_factor)
+                knl += int((knl % 2) == 0)
+                y = medfilt(y, knl)
+            yerr = (obs['unc'] / spec)[mask]
+            yvar = yerr**2
+            A = chebvander(x[mask], order)
+            ATA = np.dot(A.T, A / yvar[:, None])
+            if np.any(reg > 0):
+                ATA += reg**2 * np.eye(order+1)
+            ATAinv = np.linalg.inv(ATA)
+            c = np.dot(ATAinv, np.dot(A.T, y / yvar))
+            Afull = chebvander(x, order)
+            poly = np.dot(Afull, c)
+            self._poly_coeffs = c
+        else:
+            poly = np.zeros_like(self._outwave)
+
+        return (1.0 + poly)
+
+
 obstypes = dict(photometry=Photometry,
                 spectrum=Spectrum,
                 lines=Lines)

From 605f2ea1d259b778bf1f1a119f6d8d70270b2787 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 10 Jul 2024 14:22:01 -0400
Subject: [PATCH 100/132] move the spectroscopic response fitting to
 Observation mixin classes.

---
 prospect/models/sedmodel.py         | 219 +------------------
 prospect/observation/observation.py | 312 ++++++++++++++++++++++------
 2 files changed, 254 insertions(+), 277 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 965dea30..b3983731 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -205,7 +205,7 @@ def predict_intrinsic(self, obs_dummy, continuum_only=True, **extras):
 
         return inst_spec
 
-    def predict_spec(self, obs, **extras):
+    def predict_spec(self, obs):
         """Generate a prediction for the observed spectrum.  This method assumes
         that the parameters have been set and that the following attributes are
         present and correct
@@ -285,8 +285,9 @@ def predict_spec(self, obs, **extras):
             inst_spec[emask] += self._fix_eline_spec.sum(axis=1)
 
         # --- (de-) apply calibration ---
-        #self._speccal = self.spec_calibration(obs=obs, spec=inst_spec, **extras)
-        response = obs.get_calibration_vector(spec=inst_spec)
+        response = obs.compute_response(spec=inst_spec,
+                                        extra_mask=self._fit_eline_pixelmask,
+                                        **self.params)
         inst_spec = inst_spec * response
 
         # --- fit and add lines if necessary ---
@@ -805,9 +806,6 @@ def wave_to_x(self, wavelength=None, mask=slice(None), **extras):
         x = 2.0 * (x / (x[mask]).max()) - 1.0
         return x
 
-    def spec_calibration(self, **kwargs):
-        return np.ones_like(self._outwave)
-
     def absolute_rest_maggies(self, filterset):
         """Return absolute rest-frame maggies (=10**(-0.4*M)) of the last
         computed spectrum.
@@ -843,160 +841,6 @@ def absolute_rest_maggies(self, filterset):
         return abs_rest_maggies
 
 
-class PolySpecModel(SpecModel):
-
-    """This is a subclass of *SpecModel* that generates the multiplicative
-    calibration vector at each model `predict` call as the maximum likelihood
-    chebyshev polynomial describing the ratio between the observed and the model
-    spectrum.
-    """
-
-    def _available_parameters(self):
-        # These should both be attached to the Observation instance as attributes
-        pars = [("polynomial_order", "order of the polynomial to fit"),
-                ("polynomial_regularization", "vector of length `polyorder` providing regularization for each polynomial term"),
-                ("median_polynomial", "if > 0, median smooth with a kernel of width order/range/median_polynomial before fitting")
-                ]
-
-        return pars
-
-    def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
-        """Implements a Chebyshev polynomial calibration model. This uses
-        least-squares to find the maximum-likelihood Chebyshev polynomial of a
-        certain order describing the ratio of the observed spectrum to the model
-        spectrum, conditional on all other parameters. If emission lines are
-        being marginalized out, they are excluded from the least-squares fit.
-
-        Parameters
-        ----------
-        obs :  Instance of `Spectrum`
-
-        spec : ndarray of shape (nwave,)
-            The model spectrum.
-
-        Returns
-        -------
-        cal : ndarray of shape (nwave,)
-           A polynomial given by :math:`\sum_{m=0}^M a_{m} * T_m(x)`.
-        """
-        if theta is not None:
-            self.set_parameters(theta)
-
-        # polynomial order and regularization, from the obs object or overridden from the model params
-        order = np.squeeze(getattr(obs, "polynomial_order", 0))
-        order = np.squeeze(self.params.get('polyorder', order))
-        reg = np.squeeze(getattr(obs, "polynomial_regularization", 0.))
-        reg = self.params.get('poly_regularization', reg)
-
-        polyopt = ((order > 0) &
-                   (obs.get('spectrum', None) is not None))
-        if polyopt:
-            # generate mask
-            # remove region around emission lines if doing analytical marginalization
-            mask = obs.get('mask', np.ones_like(obs['wavelength'], dtype=bool)).copy()
-            if self.params.get('marginalize_elines', False):
-                mask[self._fit_eline_pixelmask] = 0
-
-            # map unmasked wavelengths to the interval -1, 1
-            # masked wavelengths may have x>1, x<-1
-            x = self.wave_to_x(obs["wavelength"], mask)
-            y = (obs['spectrum'] / spec)[mask] - 1.0
-
-            if self.params.get('median_polynomial', 0) > 0:
-                kernel_factor = self.params["median_polynomial"]
-                knl = int((x.max() - x.min()) / order / kernel_factor)
-                knl += int((knl % 2) == 0)
-                y = medfilt(y, knl)
-            yerr = (obs['unc'] / spec)[mask]
-            yvar = yerr**2
-            A = chebvander(x[mask], order)
-            ATA = np.dot(A.T, A / yvar[:, None])
-            if np.any(reg > 0):
-                ATA += reg**2 * np.eye(order+1)
-            ATAinv = np.linalg.inv(ATA)
-            c = np.dot(ATAinv, np.dot(A.T, y / yvar))
-            Afull = chebvander(x, order)
-            poly = np.dot(Afull, c)
-            self._poly_coeffs = c
-        else:
-            poly = np.zeros_like(self._outwave)
-
-        return (1.0 + poly)
-
-
-class SplineSpecModel(SpecModel):
-
-    """This is a subclass of *SpecModel* that generates the multiplicative
-    calibration vector at each model `predict` call as the maximum likelihood
-    cubic spline describing the ratio between the observed and the model
-    spectrum.
-    """
-
-    def _available_parameters(self):
-        pars = [("spline_knot_wave", "vector of wavelengths for the location of the spline knots"),
-                ("spline_knot_spacing", "spacing between knots, in units of wavelength"),
-                ("spline_knot_n", "number of interior knots between minimum and maximum unmasked wavelength")
-                ]
-
-        return pars
-
-    def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
-        """Implements a spline calibration model.  This fits a cubic spline with
-        determined knot locations to the ratio of the observed spectrum to the
-        model spectrum.  If emission lines are being marginalized out, they are
-        excluded from the least-squares fit.
-
-        The knot locations must be specified as model parameters, either
-        explicitly or via a number of knots or knot spacing (in angstroms)
-        """
-        if theta is not None:
-            self.set_parameters(theta)
-
-        splineopt = True
-        if splineopt:
-            mask, (wlo, whi) = self.obs_to_mask(obs)
-            y = (obs['spectrum'] / spec)[mask] - 1.0
-            yerr = (obs['unc'] / spec)[mask]  # HACK
-            knots_x = self.make_knots(wlo, whi, as_x=True, **self.params)
-            x = 2.0 * (obs["wavelength"] - wlo) / (whi - wlo) - 1.0
-            tck = splrep(x[mask], y[mask], w=1/yerr[mask], k=3, task=-1, t=knots_x)
-            self._spline_coeffs = tck
-            spl = BSpline(*tck)
-            spline = spl(x)
-        else:
-            spline = np.zeros_like(self._outwave)
-        return (1.0 + spline)
-
-    def make_knots(self, wlo, whi, as_x=True, **params):
-        """
-        """
-        if "spline_knot_wave" in params:
-            knots = np.squeeze(params["spline_knot_wave"])
-        elif "spline_knot_spacing" in params:
-            s = np.squeeze(params["spline_knot_spacing"])
-            # we drop the start so knots are interior
-            knots = np.arange(wlo, whi, s)[1:]
-        elif "spline_knot_n" in params:
-            n = np.squeeze(params["spline_knot_n"])
-            # we need to drop the endpoints so knots are interior
-            knots = np.linspace(wlo, whi, n)[1:-1]
-        else:
-            raise KeyError("No valid spline knot specification in self.params")
-
-        if as_x:
-            knots = 2.0 * (knots - wlo) / (whi - wlo) - 1.0
-
-        return knots
-
-    def obs_to_mask(self, obs):
-        mask = obs.get('mask', np.ones_like(obs['wavelength'], dtype=bool)).copy()
-        if self.params.get('marginalize_elines', False):
-            mask[self._fit_eline_pixelmask] = 0
-        w = obs["wavelength"]
-        wrange = w[mask].min(), w[mask].max()
-        return mask, wrange
-
-
 class AGNSpecModel(SpecModel):
 
     # TODO: simplify this to use SpecModel methods
@@ -1034,7 +878,7 @@ def init_aline_info(self):
         assert np.abs(self.emline_info["wave"][59] - 4863) < 2
         self._aline_lum[ainds] = afluxes
 
-    def predict_spec(self, obs, **extras):
+    def predict_spec(self, obs):
         """Generate a prediction for the observed spectrum.  This method assumes
         that the parameters have been set and that the following attributes are
         present and correct
@@ -1110,13 +954,13 @@ def predict_spec(self, obs, **extras):
             smooth_spec[emask] += self._agn_eline_spec
 
         # --- calibration ---
-        self._speccal = self.spec_calibration(obs=obs, spec=smooth_spec, **extras)
-        calibrated_spec = smooth_spec * self._speccal
+        response = obs.compute_response(spec=smooth_spec, **self.params)
+        inst_spec = smooth_spec * response
 
         # --- cache intrinsic spectrum ---
-        self._sed = calibrated_spec / self._speccal
+        self._sed = inst_spec / response
 
-        return calibrated_spec
+        return inst_spec
 
     def predict_lines(self, obs, **extras):
         """Generate a prediction for the observed nebular line fluxes, including
@@ -1200,54 +1044,9 @@ def predict_aline_spec(self, line_indices, wave):
         return aline_spec
 
 
-class PolyFitModel(SpecModel):
-
-    """This is a subclass of :py:class:`SpecModel` that generates the
-    multiplicative calibration vector as a Chebyshev polynomial described by the
-    ``'poly_coeffs'`` parameter of the model, which may be free (fittable)
-    """
-
-    def spec_calibration(self, theta=None, obs=None, **kwargs):
-        """Implements a Chebyshev polynomial calibration model.  This only
-        occurs if ``"poly_coeffs"`` is present in the :py:attr:`params`
-        dictionary, otherwise the value of ``params["spec_norm"]`` is returned.
-
-        :param theta: (optional)
-            If given, set :py:attr:`params` using this vector before
-            calculating the calibration polynomial. ndarray of shape
-            ``(ndim,)``
-
-        :param obs:
-            A dictionary of observational data, must contain the key
-            ``"wavelength"``
-
-        :returns cal:
-           If ``params["cal_type"]`` is ``"poly"``, a polynomial given by
-           :math:`\times (\Sum_{m=0}^M```'poly_coeffs'[m]``:math:` \times T_n(x))`.
-        """
-        if theta is not None:
-            self.set_parameters(theta)
-
-        if ('poly_coeffs' in self.params):
-            mask = obs.get('mask', slice(None))
-            # map unmasked wavelengths to the interval -1, 1
-            # masked wavelengths may have x>1, x<-1
-            x = self.wave_to_x(obs["wavelength"], mask)
-            # get coefficients.
-            c = self.params['poly_coeffs']
-            poly = chebval(x, c)
-            return poly
-        else:
-            return 1.0
-
-
 class HyperSpecModel(ProspectorHyperParams, SpecModel):
     pass
 
-class HyperPolySpecModel(ProspectorHyperParams, PolySpecModel):
-    pass
-
-
 
 def ln_mvn(x, mean=None, cov=None):
     """Calculates the natural logarithm of the multivariate normal PDF
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index f94894c2..1078cebb 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -3,6 +3,10 @@
 import json
 import numpy as np
 
+from numpy.polynomial.chebyshev import chebval, chebvander
+from scipy.interpolate import splrep, BSpline
+from scipy.signal import medfilt
+
 from sedpy.observate import FilterSet
 from sedpy.smoothing import smooth_fft
 from sedpy.observate import rebin
@@ -13,6 +17,7 @@
 __all__ = ["Observation",
            "Spectrum", "Photometry", "Lines",
            "UndersampledSpectrum", "IntrinsicSpectrum",
+           "SplineOptCal", "PolyOptCal",
            "from_oldstyle", "from_serial", "obstypes"]
 
 
@@ -288,12 +293,12 @@ class Spectrum(Observation):
 
     _meta = ("kind", "name", "lambda_pad")
     _data = ("wavelength", "flux", "uncertainty", "mask",
-             "resolution", "calibration")
+             "resolution", "response")
 
     def __init__(self,
                  wavelength=None,
                  resolution=None,
-                 calibration=None,
+                 response=None,
                  name=None,
                  lambda_pad=100,
                  polynomial_order=0.,
@@ -322,11 +327,9 @@ def __init__(self,
         super(Spectrum, self).__init__(name=name, **kwargs)
         self.lambda_pad = lambda_pad
         self.resolution = resolution
-        self.calibration = calibration
+        self.response = response
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
         self.wavelength = wavelength
-        self.polynomial_order = polynomial_order
-        self.polynomial_regularization = 0.
 
     @property
     def wavelength(self):
@@ -437,25 +440,12 @@ def instrumental_smoothing(self, model_wave_obsframe, model_flux, zred=0, libres
         return outspec_padded[self._unpadded_inds]
 
 
-class UndersampledSpectrum(Spectrum):
-    """
-    As for Spectrum, but account for pixelization effects when pixels
-    undersamplesthe instrumental LSF.
-    """
-
-    def _pixelize(self, outwave, inwave, influx):
-        return rebin(outwave, inwave, influx)
-
-
-class IntrinsicSpectrum(Spectrum):
-
-    """
-    As for Spectrum, but predictions for this object type will not include
-    polynomial fitting or fitting of the emission line strengths (previously fit
-    and cached emission luminosities will be used.)
-    """
+    def instrumental_response(self, **extras):
+        if self.response is not None:
+            return self.response
+        else:
+            return 1.0
 
-    _kind = "intrinsic"
 
 
 class Lines(Spectrum):
@@ -473,6 +463,7 @@ class Lines(Spectrum):
 
     def __init__(self,
                  line_ind=None,
+                 line_names=None,
                  name=None,
                  **kwargs):
 
@@ -496,76 +487,255 @@ def __init__(self,
             dispersion (:math:`= c \, \sigma_\lambda / \lambda = c \, \FWHM_\lambda / 2.355 / \lambda = c / (2.355 \, R_\lambda)`
             where :math:`c=2.998e5 {\rm km}/{\rm s}`
 
+        line_ind : iterable of string, optional
+            Names of the lines.
+
         :param calibration:
             not sure yet ....
         """
         super(Lines, self).__init__(name=name, resolution=None, **kwargs)
         assert (line_ind is not None), "You must identify the lines by their index in the FSPS emission line array"
         self.line_ind = np.array(line_ind).as_type(int)
+        self.line_names = line_names
 
 
+class UndersampledSpectrum(Spectrum):
+    """
+    As for Spectrum, but account for pixelization effects when pixels
+    undersamplesthe instrumental LSF.
+    """
+    #TODO: Implement as a convolution with a square kernel (or sinc in frequency space)
+
+    def _pixelize(self, outwave, inwave, influx):
+        return rebin(outwave, inwave, influx)
+
+
+class IntrinsicSpectrum(Spectrum):
 
-class PolyCal:
+    """
+    As for Spectrum, but predictions for this object type will not include
+    polynomial fitting or fitting of the emission line strengths (previously fit
+    and cached emission luminosities will be used.)
+    """
+
+    _kind = "intrinsic"
+
+
+class PolyOptCal:
+
+    """A mixin class that allows for optimization of a Chebyshev response
+    function given a model spectrum.
+    """
 
-    def spec_calibration(self, theta=None, obs=None, spec=None, **kwargs):
-        """Implements a Chebyshev polynomial calibration model. This uses
+    def __init__(self, *args,
+                 polynomial_order=0,
+                 polynomial_regularization=0,
+                 median_polynomial=0,
+                 **kwargs):
+        super(PolyOptCal, self).__init(*args, **kwargs)
+        self.polynomial_order = polynomial_order
+        self.polynomial_regularization = polynomial_regularization
+        self.median_molynomial = median_polynomial
+
+    def _available_parameters(self):
+        # These should both be attached to the Observation instance as attributes
+        pars = [("polynomial_order", "order of the polynomial to fit"),
+                ("polynomial_regularization", "vector of length `polyorder` providing regularization for each polynomial term"),
+                ("median_polynomial", "if > 0, median smooth with a kernel of width order/range/median_polynomial before fitting")
+                ]
+
+        return pars
+
+    def compute_response(self, spec=None, extra_mask=True, **kwargs):
+        """Implements a Chebyshev polynomial response function model. This uses
         least-squares to find the maximum-likelihood Chebyshev polynomial of a
         certain order describing the ratio of the observed spectrum to the model
-        spectrum, conditional on all other parameters. If emission lines are
-        being marginalized out, they are excluded from the least-squares fit.
+        spectrum. If emission lines are being marginalized out, they should be
+        excluded from the least-squares fit using the ``extra_mask`` keyword
 
         Parameters
         ----------
-        obs :  Instance of `Spectrum`
+        spec : ndarray of shape (Spectrum().ndata,)
+            The model spectrum on the observed wavelength grid
 
-        spec : ndarray of shape (nwave,)
-            The model spectrum.
+        extra_mask : ndarray of Booleans of shape (Spectrum().ndata,)
+            The extra mask to be applied.  True=use data, False=mask data
 
         Returns
         -------
-        cal : ndarray of shape (nwave,)
+        response : ndarray of shape (nwave,)
            A polynomial given by :math:`\sum_{m=0}^M a_{m} * T_m(x)`.
         """
-        if theta is not None:
-            self.set_parameters(theta)
-
-        #order = np.squeeze(self.params.get('polyorder', 0))
-        order = np.squeeze(getattr(obs, "polynomial_order", 0))
-        reg = np.squeeze(getattr(obs, "poly_regularization", 0))
-        polyopt = ((order > 0) &
-                   (obs.get('spectrum', None) is not None))
-        if polyopt:
-            # generate mask
-            # remove region around emission lines if doing analytical marginalization
-            mask = obs.get('mask', np.ones_like(obs['wavelength'], dtype=bool)).copy()
-            if self.params.get('marginalize_elines', False):
-                mask[self._fit_eline_pixelmask] = 0
 
+        order = self.polynomial_order
+        reg = self.polynomial_regularization
+        mask = self.mask & extra_mask
+        assert (self.mask.sum() > order), f"Not enough points to constrain polynomial of order {order}"
+
+        polyopt = (order > 0)
+        if ~polyopt:
+            self.response = np.ones_like(self.wavelength)
+            return self.response
+
+        x = wave_to_x(self.wavelength, mask)
+        y = (self.flux / spec - 1.0)[mask]
+        yerr = (self.uncertainty / spec)[mask]
+        yvar = yerr**2
+
+        if self.median_polynomial > 0:
+            kernel_factor = self.median_polynomial
+            knl = int((x.max() - x.min()) / order / kernel_factor)
+            knl += int((knl % 2) == 0)
+            y = medfilt(y, knl)
+
+        Afull = chebvander(x, order)
+        A = Afull[mask, :]
+        ATA = np.dot(A.T, A / yvar[:, None])
+        if np.any(reg > 0):
+            ATA += reg**2 * np.eye(order+1)
+        c = np.linalg.solve(ATA, np.dot(A.T, y / yvar))
+
+        poly = np.dot(Afull, c)
+
+        self._chebyshev_coefficients = c
+        self.response = poly + 1.0
+        return self.response
+
+
+class SplineOptCal:
+
+    """A mixin class that allows for optimization of a Chebyshev response
+    function given a model spectrum.
+    """
+
+
+    def __init__(self, *args,
+                 spline_knot_wave=None,
+                 spline_knot_spacing=None,
+                 spline_knot_n=None,
+                 **kwargs):
+        super(SplineOptCal, self).__init(*args, **kwargs)
+
+        self.params = {}
+        if spline_knot_wave is not None:
+            self.params["spline_knot_wave"] = spline_knot_wave
+        elif spline_knot_spacing is not None:
+            self.params["spline_knot_spacing"] = spline_knot_spacing
+        elif spline_knot_n is not None:
+            self.params["spline_knot_n"] = spline_knot_n
+
+        # build and cache the knots
+        w = self.wavelength[self.mask]
+        (wlo, whi) = w.min(), w.min()
+        self.wave_x = 2.0 * (self.wavelength - wlo) / (whi - wlo) - 1.0
+        self.knots_x = self.make_knots(wlo, whi, as_x=True, **self.params)
+
+
+    def _available_parameters(self):
+        pars = [("spline_knot_wave", "vector of wavelengths for the location of the spline knots"),
+                ("spline_knot_spacing", "spacing between knots, in units of wavelength"),
+                ("spline_knot_n", "number of interior knots between minimum and maximum unmasked wavelength")
+                ]
+
+        return pars
+
+    def compute_response(self, spec=None, extra_mask=True, **extras):
+        """Implements a spline response function model.  This fits a cubic
+        spline with determined knot locations to the ratio of the observed
+        spectrum to the model spectrum.  If emission lines are being
+        marginalized out, they are excluded from the least-squares fit.
+
+        The knot locations must be specified as model parameters, either
+        explicitly or via a number of knots or knot spacing (in angstroms)
+        """
+        mask = self.mask & extra_mask
+
+
+        splineopt = True
+        if ~splineopt:
+            self.response = np.ones_like(self.wavelength)
+            return self.response
+
+        y = (self.flux / spec - 1.0)[mask]
+        yerr = (self.uncertainty / spec)[mask] # HACK
+        tck = splrep(self.wave_x[mask], y[mask], w=1/yerr[mask], k=3, task=-1, t=self.knots_x)
+        self._spline_coeffs = tck
+        spl = BSpline(*tck)
+        spline = spl(self.wave_x)
+
+        self.response = (1.0 + spline)
+        return self.response
+
+    def make_knots(self, wlo, whi, as_x=True, **params):
+        """Can we move this to instantiation?
+        """
+        if "spline_knot_wave" in params:
+            knots = np.squeeze(params["spline_knot_wave"])
+        elif "spline_knot_spacing" in params:
+            s = np.squeeze(params["spline_knot_spacing"])
+            # we drop the start so knots are interior
+            knots = np.arange(wlo, whi, s)[1:]
+        elif "spline_knot_n" in params:
+            n = np.squeeze(params["spline_knot_n"])
+            # we need to drop the endpoints so knots are interior
+            knots = np.linspace(wlo, whi, n)[1:-1]
+        else:
+            raise KeyError("No valid spline knot specification in self.params")
+
+        if as_x:
+            knots = 2.0 * (knots - wlo) / (whi - wlo) - 1.0
+
+        return knots
+
+
+class PolyFitCal:
+
+    """This is a mixin class that generates the
+    multiplicative response vector as a Chebyshev polynomial described by the
+    ``poly_param_name`` parameter of the model, which may be free (fittable)
+    """
+
+    def __init__(self, *args, poly_param_name=None, **kwargs):
+        super(SplineOptCal, self).__init(*args, **kwargs)
+        self.poly_param_name = poly_param_name
+
+    def _available_parameters(self):
+        pars = [(self.poly_param_name, "vector of polynomial chabyshev coefficients")]
+
+        return pars
+
+    def compute_response(self, **kwargs):
+        """Implements a Chebyshev polynomial calibration model.  This only
+        occurs if ``"poly_coeffs"`` is present in the :py:attr:`params`
+        dictionary, otherwise the value of ``params["spec_norm"]`` is returned.
+
+        :param theta: (optional)
+            If given, set :py:attr:`params` using this vector before
+            calculating the calibration polynomial. ndarray of shape
+            ``(ndim,)``
+
+        :param obs:
+            A dictionary of observational data, must contain the key
+            ``"wavelength"``
+
+        :returns cal:
+           If ``params["cal_type"]`` is ``"poly"``, a polynomial given by
+           :math:`\times (\Sum_{m=0}^M```'poly_coeffs'[m]``:math:` \times T_n(x))`.
+        """
+
+        if self.poly_param_name in kwargs:
+            mask = self.get('mask', slice(None))
             # map unmasked wavelengths to the interval -1, 1
             # masked wavelengths may have x>1, x<-1
-            x = self.wave_to_x(obs["wavelength"], mask)
-            y = (obs['spectrum'] / spec)[mask] - 1.0
-
-            if self.params.get('median_polynomial', 0) > 0:
-                kernel_factor = self.params["median_polynomial"]
-                knl = int((x.max() - x.min()) / order / kernel_factor)
-                knl += int((knl % 2) == 0)
-                y = medfilt(y, knl)
-            yerr = (obs['unc'] / spec)[mask]
-            yvar = yerr**2
-            A = chebvander(x[mask], order)
-            ATA = np.dot(A.T, A / yvar[:, None])
-            if np.any(reg > 0):
-                ATA += reg**2 * np.eye(order+1)
-            ATAinv = np.linalg.inv(ATA)
-            c = np.dot(ATAinv, np.dot(A.T, y / yvar))
-            Afull = chebvander(x, order)
-            poly = np.dot(Afull, c)
-            self._poly_coeffs = c
+            x = wave_to_x(self.wavelength, mask)
+            # get coefficients.
+            c = kwargs[self.poly_param_name]
+            poly = chebval(x, c)
         else:
-            poly = np.zeros_like(self._outwave)
+            poly = 1.0
 
-        return (1.0 + poly)
+        self.response = poly
+        return self.response
 
 
 obstypes = dict(photometry=Photometry,
@@ -600,3 +770,11 @@ def from_serial(arr, meta):
 
     return obs
 
+
+def wave_to_x(wavelength=None, mask=slice(None), **extras):
+    """Map unmasked wavelengths to the interval -1, 1
+            masked wavelengths may have x>1, x<-1
+    """
+    x = wavelength - (wavelength[mask]).min()
+    x = 2.0 * (x / (x[mask]).max()) - 1.0
+    return x
\ No newline at end of file

From fe3f10e468fa77155644763f32b310e9a14f255f Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 10 Jul 2024 15:28:03 -0400
Subject: [PATCH 101/132] some documentation for spectra including response
 function treatments.

---
 doc/dataformat.rst | 10 ++++----
 doc/spectra.rst    | 60 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 5 deletions(-)
 create mode 100644 doc/spectra.rst

diff --git a/doc/dataformat.rst b/doc/dataformat.rst
index 36ea4ac2..29051163 100644
--- a/doc/dataformat.rst
+++ b/doc/dataformat.rst
@@ -79,7 +79,7 @@ For a single observation, you might do something like:
 .. code-block:: python
 
         def build_obs(N):
-            from prospect.data import Spectrum
+            from prospect.observation import Spectrum
             N = 1000  # number of wavelength points
             spec = Spectrum(wavelength=np.linspace(3000, 5000, N), flux=np.zeros(N), uncertainty=np.ones(N))
             # ensure that this is a valid observation for fitting
@@ -95,7 +95,7 @@ For photometry this might look like:
 .. code-block:: python
 
         def build_obs(N):
-            from prospect.data import Photometry
+            from prospect.observation import Photometry
             # valid sedpy filter names
             fnames = list([f"sdss_{b}0" for b in "ugriz"])
             Nf = len(fnames)
@@ -113,7 +113,7 @@ A tool exists to convert old combined observation dictionaries to a list of
 
 .. code-block:: python
 
-        from prospect.data import from_oldstyle
+        from prospect.observation import from_oldstyle
         # dummy observation dictionary with just a spectrum
         N = 1000
         obs = dict(wavelength=np.linspace(3000, 5000, N), spectrum=np.zeros(N), unc=np.ones(N),
@@ -129,7 +129,7 @@ The :py:meth:`build_obs` function
 
 The :py:meth:`build_obs` function in the parameter file is written by the user.
 It should take a dictionary of command line arguments as keyword arguments. It
-should return a list of :py:class:`prospect.data.Observation` instances,
+should return a list of :py:class:`prospect.observation.Observation` instances,
 described above.
 
 Other than that, the contents can be anything. Within this function you might
@@ -142,7 +142,7 @@ The point of this function is that you don't have to *externally* convert your
 data format to be what |Codename| expects and keep another version of files
 lying around: the conversion happens *within* the code itself. Again, the only
 requirement is that the function can take a ``run_params`` dictionary as keyword
-arguments and that it return :py:class:`prospect.data.Observation` instances, as
+arguments and that it return :py:class:`prospect.observation.Observation` instances, as
  described above.  Each observation instance should correspond to a particular
  dataset (e.g. a broadband photomtric SED, the spectrum from a particular
  instrument, or the spectrum from a particular night) that shares instrumental
diff --git a/doc/spectra.rst b/doc/spectra.rst
new file mode 100644
index 00000000..b3b34da3
--- /dev/null
+++ b/doc/spectra.rst
@@ -0,0 +1,60 @@
+Fitting Spectra
+================
+
+There are several extra considerations that come up when fitting spectroscopy.
+
+Wavelength range, resolution, and linespread function
+-----------------------------------------------------
+
+Prospector is based on FSPS, which uses stellar spectral libraries with given
+resolution. The empirical MILES library has a resolution of ~2.5A FWHM from
+3750AA - 7200AA restframe, and much lower (R~200 or so, but not actually well
+defined) outside this range. Higher resolution data (after including both
+velocity dispersion and instrumental resolution) or spectral points outside this
+range cannot yet be fit.
+
+Prospector includes methods for FFT based smoothing of the spectra, assuming a
+gaussian LSF (in either wavelength or velocity space). There is also the
+possibility of FFT based smoothing for wavelength dependent Gaussian dispersion
+(i.e. sigma_lambda = f(lambda) with f possibly a polynomial of lambda). In
+practice the smoothed spectra will be a combination of the library resolution
+plus whatever FFT smoothing is applied. Hopefully this can be made to match your
+actual data resolution, which is a combination of the physical velocity
+dispersion and the instrumental resolution. The smoothing is controlled by the
+parameters `sigma_smooth`, `smooth_type`, and `fftsmooth`
+
+
+Instrumental Response & Spectrophotometric Calibration
+---------------------
+
+There are various options for dealing with the spectral continuum shape
+depending on how well you think your spectra are calibrated and if you also fit
+photometry to tie down the continuum shape. You can optimize out a polynomial
+"calibration" vector, or simultaneously fit for a polynomial and marginalize
+over the polynomial coefficients (this allows you to place priors on the
+accuracy of the spectrophotometric calibration). Or you can just take the
+spectrum as perfectly calibrated.
+
+Particular treatments can be implemented using different mixin classes, e.g.
+
+.. code-block:: python
+
+        from prospect.observation import Spectrum, PolyOptCal
+        class PolySpect(PolyOptCal, Spectrum):
+            pass
+        spec = PolySpect(wavelength=np.linspace(3000, 5000, N),
+                         flux=np.zeros(N),
+                         uncertainty=np.ones(N),
+                         polynomial_order=5)
+
+
+Nebular emission
+----------------
+
+While prospector/FSPS include self-consistent nebular emission, the treatment is
+probably not flexible enough at the moment to fit high S/N, high resolution data
+including nebular emission (e.g. due to deviations of line ratios from Cloudy
+predictions or to complicated gas kinematics that are different than stellar
+kinematics). Thus fitting nebular lines should take adavantage of the nebular
+line amplitude optimization/marginalization capabilities. For very low
+resolution data this is less of an issue.
\ No newline at end of file

From a2e2710d2f0a68c818464c91401de666b891865c Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 7 Aug 2024 10:45:05 -0400
Subject: [PATCH 102/132] fix type comparisons.

---
 prospect/io/read_results.py         | 4 ++--
 prospect/io/write_results.py        | 2 +-
 prospect/observation/observation.py | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/prospect/io/read_results.py b/prospect/io/read_results.py
index cff75423..0e9dac33 100644
--- a/prospect/io/read_results.py
+++ b/prospect/io/read_results.py
@@ -240,9 +240,9 @@ def get_sps(res):
                   "same as the FSPS libraries that you are using now ({})".format(flib, rlib))
         # If fitting and reading in are happening in different python versions,
         # ensure string comparison doesn't throw error:
-        if type(flib[0]) == 'bytes':
+        if isinstance(flib[0], bytes):
             flib = [i.decode() for i in flib]
-        if type(rlib[0]) == 'bytes':
+        if isinstance(rlib[0], bytes):
             rlib = [i.decode() for i in rlib]
         assert (flib[0] == rlib[0]) and (flib[1] == rlib[1]), liberr
 
diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index 0ce30d8b..cf3d312c 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -279,7 +279,7 @@ def chain_to_struct(chain, model=None, names=None, **extras):
     struct :
         A structured ndarray of parameter values.
     """
-    indict = type(chain) == dict
+    indict = isinstance(chain, dict)
     if indict:
         return dict_to_struct(chain)
     else:
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 1078cebb..0aa78cc3 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -46,7 +46,7 @@ class Observation:
     noise :
     """
 
-    kind = "observation"
+    _kind = "observation"
     logify_spectrum = False
     alias = {}
     _meta = ("kind", "name")

From eb4a2b07f3ae8d42c415d013d7b391c38eef5246 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 8 Aug 2024 10:48:05 -0400
Subject: [PATCH 103/132] doc updates.

---
 doc/faq.rst        | 43 ----------------------------------------
 doc/index.rst      |  1 +
 doc/quickstart.rst | 49 ++++++++++++++++++++++++++++++++++------------
 doc/spectra.rst    | 20 +++++++++++--------
 4 files changed, 49 insertions(+), 64 deletions(-)

diff --git a/doc/faq.rst b/doc/faq.rst
index 3dbbfad8..1e3728d0 100644
--- a/doc/faq.rst
+++ b/doc/faq.rst
@@ -40,49 +40,6 @@ sampling algorithm being used, and the kind of data that you have.  Hours or
 even days per fit is not uncommon for more complex models.
 
 
-Can I fit my spectrum too?
---------------------------
-There are several extra considerations that come up when fitting spectroscopy
-
-   1) Wavelength range and resolution.
-      Prospector is based on FSPS, which uses the MILES spectral library. These
-      have a resolution of ~2.5A FWHM from 3750AA - 7200AA restframe, and much
-      lower (R~200 or so, but not actually well defined) outside this range.
-      Higher resolution data (after including both velocity dispersion and
-      instrumental resolution) or spectral points outside this range cannot yet
-      be fit.
-
-   2) Relatedly, line spread function.
-      Prospector includes methods for FFT based smoothing of the spectra,
-      assuming a gaussian LSF (in either wavelength or velocity space). There is
-      also the possibility of FFT based smoothing for wavelength dependent
-      Gaussian dispersion (i.e. sigma_lambda = f(lambda) with f possibly a
-      polynomial of lambda). In practice the smoothed spectra will be a
-      combination of the library resolution plus whatever FFT smoothing is
-      applied. Hopefully this can be made to match your actual data resolution,
-      which is a combination of the physical velocity dispersion and the
-      instrumental resolution. The smoothing is controlled by the parameters
-      `sigma_smooth`, `smooth_type`, and `fftsmooth`
-
-   3) Nebular emission.
-      While prospector/FSPS include self-consistent nebular emission, the
-      treatment is probably not flexible enough at the moment to fit high S/N,
-      high resolution data including nebular emission (e.g. due to deviations of
-      line ratios from Cloudy predictions or to complicated gas kinematics that
-      are different than stellar kinematics). Thus fitting nebular lines should
-      take adavantage of the nebular line amplitude optimization/marginalization
-      capabilities. For very low resolution data this is less of an issue.
-
-   4) Spectrophotometric calibration.
-      There are various options for dealing with the spectral continuum shape
-      depending on how well you think your spectra are calibrated and if you
-      also fit photometry to tie down the continuum shape. You can optimize out
-      a polynomial "calibration" vector, or simultaneously fit for a polynomial
-      and marginalize over the polynomial coefficients (this allows you to place
-      priors on the accuracy of the spectrophotometric calibration). Or you can
-      just take the spectrum as perfectly calibrated.
-
-
 How do I fit for redshift as well as other parameters?
 ------------------------------------------------------
 The simplest way is to just let the parameter specification for ``"zred"``
diff --git a/doc/index.rst b/doc/index.rst
index a6817275..d82c2b4e 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -30,6 +30,7 @@ Prospector allows you to:
    installation
    usage
    dataformat
+   spectra
    models
    sfhs
    nebular
diff --git a/doc/quickstart.rst b/doc/quickstart.rst
index 6ca448de..eabc38bf 100644
--- a/doc/quickstart.rst
+++ b/doc/quickstart.rst
@@ -45,7 +45,7 @@ include an empty Spectrum data set to force a prediction of the full spectrum.
 .. code:: python
 
     from sedpy.observate import load_filters
-    from prospect.data import Photometry, Spectrum
+    from prospect.observation import Photometry, Spectrum
 
     filters = load_filters([f"sdss_{b}0" for b in bands])
     maggies = np.array([10**(-0.4 * cat[0][f"cModelMag_{b}"]) for b in bands])
@@ -59,6 +59,7 @@ include an empty Spectrum data set to force a prediction of the full spectrum.
     for obs in observations:
         obs.redshift = shdus[2].data[0]["z"]
 
+
 In principle we could also add noise models for the spectral and photometric
 data (e.g. to fit for the photometric noise floor), but we'll make the default
 assumption of iid Gaussian noise for the moment.
@@ -69,18 +70,25 @@ Build a Model
 
 Here we will get a default parameter set for a simple parametric SFH, and add a
 set of parameters describing nebular emission.  We'll also fix the redshift to
-the value given by SDSS. This model has 5 free parameters, each of which has a
-an associated prior distribution.  These default prior distributions can and
-should be replaced or adjusted depending on your particular science question.
+the value given by SDSS. This model has 5 free parameters, each of which has an
+associated prior distribution.  These default prior distributions can and should
+be replaced or adjusted depending on your particular science question. Here
+we'll just change the prior distribution for stellar mass, as an example.
 
 .. code:: python
 
+    # Get a baseline set of model parameters
     from prospect.models.templates import TemplateLibrary
     from prospect.models import SpecModel
     model_params = TemplateLibrary["parametric_sfh"]
     model_params.update(TemplateLibrary["nebular"])
     model_params["zred"]["init"] = obs["redshift"]
 
+    # Adjust the prior for mass, giving a wider range
+    from prospect.models import priors
+    model_params["mass"]["prior"] = priors.LogUniform(mini=1e6, maxi=1e13)
+
+    # Instantiate the model using this parameter dictionary
     model = SpecModel(model_params)
     assert len(model.free_params) == 5
     print(model)
@@ -100,13 +108,15 @@ spectral and isochrone libraries are being used.
     sps = CSPSpecBasis(zcontinuous=1)
     print(sps.ssp.libraries)
 
+For piecewise constant and other flexible SFHs use `FastStepBasis` instead of
+`CSPSpecBasis`.
 
 Make a prediction
 -----------------
 
 We can now predict our data for any set of parameters.  This will take a little
 time because fsps is building and caching the SSPs.  Subsequent calls to predict
-will be faster.  Here we'll just make the predicition for the current value of
+will be faster.  Here we'll just make the prediction for the current value of
 the free parameters.
 
 .. code:: python
@@ -114,23 +124,36 @@ the free parameters.
     current_parameters = ",".join([f"{p}={v}" for p, v in zip(model.free_params, model.theta)])
     print(current_parameters)
     (spec, phot), mfrac = model.predict(model.theta, observations, sps=sps)
-    print(phot / obs["maggies"])
+    print("filter,observed,predicted")
+    for i, f in enumerate(obs["filters"]):
+        print(f"{f.name},{obs['maggies'][i]},{phot[i]}")
 
 
 Run a fit
 ---------
 
-Since we can make predictions and we have data and uncertainties, we should be
-able to construct a likelihood function.  Here we'll use the pre-defined default
+Since we can make predictions and we have (photometric) data and uncertainties,
+we should be able to construct a likelihood function, and then combine with the
+priors to sample the posterior.  Here we'll use the pre-defined default
 posterior probability function.  We also set some sampling related keywords to
-make the fit go a little faster, though it should still take of order tens of
-minutes.
+make the fit go a little faster (but give rougher posterior estimates), though
+it should still take of order tens of minutes.
 
 .. code:: python
 
     from prospect.fitting import lnprobfn, fit_model
+
+    # just the photometry
+    obs = [observations[1]]
+
+    # posterior probability of the initial parameters given the photometry
+    lnp = lnprobfn(model.theta, model, observations=obs, sps=sps)
+
+    # now do the posterior sampling
     fitting_kwargs = dict(nlive_init=400, nested_method="rwalk", nested_target_n_effective=10000, nested_dlogz_init=0.05)
-    output = fit_model(obs, model, sps, optimize=False, dynesty=True, lnprobfn=lnprobfn, **fitting_kwargs)
+    output = fit_model(obs, model, sps, lnprobfn=lnprobfn,
+                       optimize=False, dynesty=True,
+                       **fitting_kwargs)
     result, duration = output["sampling"]
 
 The ``result`` is a dictionary with keys giving the Monte Carlo samples of
@@ -146,7 +169,7 @@ as follows:
 
     from prospect.io import write_results as writer
     hfile = "./quickstart_dynesty_mcmc.h5"
-    writer.write_hdf5(hfile, {}, model, obs,
+    writer.write_hdf5(hfile, {}, model, observations,
                      output["sampling"][0], None,
                      sps=sps,
                      tsample=output["sampling"][1],
@@ -179,7 +202,7 @@ We'll mark the highest probablity posterior sample as well.
     from prospect.plotting import corner
     nsamples, ndim = out["chain"].shape
     cfig, axes = pl.subplots(ndim, ndim, figsize=(10,9))
-    axes = corner.allcorner(out["chain"].T, out["theta_labels"], axes, weights=out["weights"], color="royalblue", show_titles=True)
+    #axes = corner.allcorner(out["chain"].T, out["theta_labels"], axes, weights=out["weights"], color="royalblue", show_titles=True)
 
     from prospect.plotting.utils import best_sample
     pbest = best_sample(out)
diff --git a/doc/spectra.rst b/doc/spectra.rst
index b3b34da3..ef0a96a3 100644
--- a/doc/spectra.rst
+++ b/doc/spectra.rst
@@ -14,15 +14,19 @@ velocity dispersion and instrumental resolution) or spectral points outside this
 range cannot yet be fit.
 
 Prospector includes methods for FFT based smoothing of the spectra, assuming a
-gaussian LSF (in either wavelength or velocity space). There is also the
+Gaussian LSF (in either wavelength or velocity space). There is also the
 possibility of FFT based smoothing for wavelength dependent Gaussian dispersion
 (i.e. sigma_lambda = f(lambda) with f possibly a polynomial of lambda). In
-practice the smoothed spectra will be a combination of the library resolution
+practice the smoothed model spectra will be a combination of the library resolution
 plus whatever FFT smoothing is applied. Hopefully this can be made to match your
 actual data resolution, which is a combination of the physical velocity
 dispersion and the instrumental resolution. The smoothing is controlled by the
 parameters `sigma_smooth`, `smooth_type`, and `fftsmooth`
 
+For undersampled spectra, a special :py:class:`UnderSampledSpectrum` class
+exists that will integrate the model (smoothed by velocity dispersion and
+intrumental resolution) over the supplied pixels.
+
 
 Instrumental Response & Spectrophotometric Calibration
 ---------------------
@@ -35,17 +39,17 @@ over the polynomial coefficients (this allows you to place priors on the
 accuracy of the spectrophotometric calibration). Or you can just take the
 spectrum as perfectly calibrated.
 
-Particular treatments can be implemented using different mixin classes, e.g.
+Particular treatments can be implemented using different mix-in classes, e.g.
 
 .. code-block:: python
 
         from prospect.observation import Spectrum, PolyOptCal
-        class PolySpect(PolyOptCal, Spectrum):
+        class PolySpectrum(PolyOptCal, Spectrum):
             pass
-        spec = PolySpect(wavelength=np.linspace(3000, 5000, N),
-                         flux=np.zeros(N),
-                         uncertainty=np.ones(N),
-                         polynomial_order=5)
+        spec = PolySpectrum(wavelength=np.linspace(3000, 5000, N),
+                            flux=np.zeros(N),
+                            uncertainty=np.ones(N),
+                            polynomial_order=5)
 
 
 Nebular emission

From 768c68936a55e1c51a200a370078b28f7684563b Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 8 Aug 2024 12:11:06 -0400
Subject: [PATCH 104/132] move common prediction code to SpecModel method. Add
 basic polycal test; fix imports; fix speccal bugs in SpecModel.

---
 prospect/models/__init__.py         |  9 ++--
 prospect/models/sedmodel.py         | 48 ++++++++++++-----
 prospect/observation/__init__.py    |  5 +-
 prospect/observation/observation.py | 10 ++--
 tests/test_polycal.py               | 80 +++++++++++++++++++++++++++++
 5 files changed, 127 insertions(+), 25 deletions(-)
 create mode 100644 tests/test_polycal.py

diff --git a/prospect/models/__init__.py b/prospect/models/__init__.py
index 1fe98241..728647e8 100644
--- a/prospect/models/__init__.py
+++ b/prospect/models/__init__.py
@@ -6,14 +6,13 @@
 """
 
 
-from .sedmodel import ProspectorParams, SpecModel
-from .sedmodel import PolySpecModel, SplineSpecModel
-from .sedmodel import AGNSpecModel
+from .parameters import ProspectorParams
+from .sedmodel import SpecModel, HyperSpecModel, AGNSpecModel
 
 
 __all__ = ["ProspectorParams",
            "SpecModel",
-           "PolySpecModel", "SplineSpecModel",
-           "LineSpecModel", "AGNSpecModel"
+           "HyperSpecModel",
+           "AGNSpecModel"
            ]
 
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index b3983731..b7e73477 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -22,10 +22,8 @@
 
 
 __all__ = ["SpecModel",
-           "PolySpecModel", "SplineSpecModel",
-           "HyperSpecModel", "HyperPolySpecModel",
-           "AGNSpecModel",
-           "PolyFitModel"]
+           "HyperSpecModel",
+           "AGNSpecModel"]
 
 
 class SpecModel(ProspectorParams):
@@ -103,7 +101,28 @@ def predict(self, theta, observations=None, sps=None, **extras):
             will be `mfrac` the ratio of the surviving stellar mass to the
             stellar mass formed.
         """
+        self.predict_init(theta, sps)
 
+        # generate predictions for likelihood
+        # this assumes all spectral datasets (if present) occur first
+        # because they can change the line strengths during marginalization.
+        predictions = [self.predict_obs(obs) for obs in observations]
+
+        return predictions, self._mfrac
+
+    def predict_init(self, theta, sps):
+        """Generate the physical model on the model wavelength grid, and cache
+        many quantities used in common for all kinds of predictions.
+
+        Parameters
+        ----------
+        theta : ndarray of shape ``(ndim,)``
+            Vector of free model parameter values.
+
+        sps :
+            An `sps` object to be used in the model generation.  It must have
+            the :py:func:`get_galaxy_spectrum` method defined.
+        """
         # generate and cache intrinsic model spectrum and info
         self.set_parameters(theta)
         self._wave, self._spec, self._mfrac = sps.get_galaxy_spectrum(**self.params)
@@ -131,13 +150,6 @@ def predict(self, theta, observations=None, sps=None, **extras):
         self._smooth_spec = self.add_dla(self._wave, self._smooth_spec)
         self._smooth_spec = self.add_damping_wing(self._wave, self._smooth_spec)
 
-        # generate predictions for likelihood
-        # this assumes all spectral datasets (if present) occur first
-        # because they can change the line strengths during marginalization.
-        predictions = [self.predict_obs(obs) for obs in observations]
-
-        return predictions, self._mfrac
-
     def predict_obs(self, obs):
         if obs.kind == "spectrum":
             prediction = self.predict_spec(obs)
@@ -253,6 +265,7 @@ def predict_spec(self, obs):
         obs_wave = self.observed_wave(self._wave, do_wavecal=False)
 
         # get output wavelength vector
+        # TODO: remove this and require all Spectrum instances to have a wavelength array
         self._outwave = obs.wavelength
         if self._outwave is None:
             self._outwave = obs_wave
@@ -285,15 +298,19 @@ def predict_spec(self, obs):
             inst_spec[emask] += self._fix_eline_spec.sum(axis=1)
 
         # --- (de-) apply calibration ---
+        extra_mask = self._fit_eline_pixelmask
+        if not extra_mask.any():
+            extra_mask = True  # all pixels are ok
         response = obs.compute_response(spec=inst_spec,
-                                        extra_mask=self._fit_eline_pixelmask,
+                                        extra_mask=extra_mask,
                                         **self.params)
         inst_spec = inst_spec * response
 
         # --- fit and add lines if necessary ---
         emask = self._fit_eline_pixelmask
         if emask.any():
-            # We need the spectroscopic covariance matrix to do emission line optimization and marginalization
+            # We need the spectroscopic covariance matrix to do emission line
+            # optimization and marginalization
             spec_unc = None
             # FIXME: do this only if the noise model is non-trivial, and make sure masking is consistent
             #vectors = obs.noise.populate_vectors(obs)
@@ -302,7 +319,8 @@ def predict_spec(self, obs):
             inst_spec[emask] += self._fit_eline_spec.sum(axis=1)
 
         # --- cache intrinsic spectrum for this observation ---
-        self._sed.append(inst_spec / response)
+        self._sed = inst_spec / response
+        self._speccal = response
 
         return inst_spec
 
@@ -635,6 +653,7 @@ def fit_mle_elines(self, obs, calibrated_spec, sigma_spec=None):
 
         # generate line amplitudes in observed flux units
         units_factor = self.flux_norm() / (1 + self._zred)
+        # FIXME: use obs.response instead of _speccal, remove all references to speccal
         calib_factor = np.interp(self._ewave_obs[idx], nebwave, self._speccal[emask])
         linecal = units_factor * calib_factor
         alpha_breve = self._eline_lum[idx] * linecal
@@ -959,6 +978,7 @@ def predict_spec(self, obs):
 
         # --- cache intrinsic spectrum ---
         self._sed = inst_spec / response
+        self._speccal = response
 
         return inst_spec
 
diff --git a/prospect/observation/__init__.py b/prospect/observation/__init__.py
index 282e93c6..46bf1ef4 100644
--- a/prospect/observation/__init__.py
+++ b/prospect/observation/__init__.py
@@ -1,10 +1,13 @@
 # -*- coding: utf-8 -*-
 
 from .observation import Observation
-from .observation import Photometry, Spectrum, Lines, UndersampledSpectrum, IntrinsicSpectrum
+from .observation import Photometry, Spectrum, Lines
+from .observation import UndersampledSpectrum, IntrinsicSpectrum
+from .observation import PolyOptCal, SplineOptCal
 from .observation import from_oldstyle, from_serial
 
 __all__ = ["Observation",
            "Photometry", "Spectrum", "Lines",
            "UndersampledSpectrum", "InstrinsicSpectrum",
+           "PolyOptCal", "SplineOptCal",
            "from_oldstyle", "from_serial"]
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 0aa78cc3..58a544ab 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -447,7 +447,6 @@ def instrumental_response(self, **extras):
             return 1.0
 
 
-
 class Lines(Spectrum):
 
     _kind = "lines"
@@ -532,10 +531,10 @@ def __init__(self, *args,
                  polynomial_regularization=0,
                  median_polynomial=0,
                  **kwargs):
-        super(PolyOptCal, self).__init(*args, **kwargs)
+        super(PolyOptCal, self).__init__(*args, **kwargs)
         self.polynomial_order = polynomial_order
         self.polynomial_regularization = polynomial_regularization
-        self.median_molynomial = median_polynomial
+        self.median_polynomial = median_polynomial
 
     def _available_parameters(self):
         # These should both be attached to the Observation instance as attributes
@@ -573,7 +572,8 @@ def compute_response(self, spec=None, extra_mask=True, **kwargs):
         assert (self.mask.sum() > order), f"Not enough points to constrain polynomial of order {order}"
 
         polyopt = (order > 0)
-        if ~polyopt:
+        if (not polyopt):
+            print("no polynomial")
             self.response = np.ones_like(self.wavelength)
             return self.response
 
@@ -614,7 +614,7 @@ def __init__(self, *args,
                  spline_knot_spacing=None,
                  spline_knot_n=None,
                  **kwargs):
-        super(SplineOptCal, self).__init(*args, **kwargs)
+        super(SplineOptCal, self).__init__(*args, **kwargs)
 
         self.params = {}
         if spline_knot_wave is not None:
diff --git a/tests/test_polycal.py b/tests/test_polycal.py
new file mode 100644
index 00000000..7a3261c4
--- /dev/null
+++ b/tests/test_polycal.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+from prospect.sources import CSPSpecBasis
+from prospect.models import SpecModel, templates
+from prospect.observation import Spectrum, Photometry, PolyOptCal
+
+
+class PolySpectrum(PolyOptCal, Spectrum):
+    pass
+
+
+
+@pytest.fixture
+def get_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+def build_model(add_neb=False):
+    model_params = templates.TemplateLibrary["parametric_sfh"]
+    if add_neb:
+        model_params.update(templates.TemplateLibrary["nebular"])
+    return SpecModel(model_params)
+
+
+def build_obs(multispec=False):
+    N = 1500 * (2 - multispec)
+    wmax = 7000
+    wsplit = wmax - N * multispec
+
+    fnames = list([f"sdss_{b}0" for b in "ugriz"])
+    Nf = len(fnames)
+    phot = [Photometry(filters=fnames,
+                       flux=np.ones(Nf),
+                       uncertainty=np.ones(Nf)/10)]
+    spec = [PolySpectrum(wavelength=np.linspace(4000, wsplit, N),
+                         flux=np.ones(N),
+                         uncertainty=np.ones(N) / 10,
+                         mask=slice(None),
+                         polynomial_order=5)
+            ]
+
+    if multispec:
+        spec += [Spectrum(wavelength=np.linspace(wsplit+1, wmax, N),
+                          flux=np.ones(N), uncertainty=np.ones(N) / 10,
+                          mask=slice(None))]
+
+    obslist = spec + phot
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+def test_polycal(plot=False):
+    """Make sure the polynomial optimization works
+    """
+    sps = get_sps
+    observations = build_obs()
+    model = build_model()
+
+    preds, extra = model.predict(model.theta, observations=observations, sps=sps)
+    obs = observations[0]
+
+    assert np.any(obs.response != 0)
+
+    if plot:
+        import matplotlib.pyplot as pl
+        fig, axes = pl.subplots(3, 1, sharex=True)
+        ax = axes[0]
+        ax.plot(obs.wavelength, obs.flux, label="obseved flux (ones)")
+        ax.plot(obs.wavelength, preds[0], label="model flux (times response)")
+        ax = axes[1]
+        ax.plot(obs.wavelength, obs.response, label="instrumental response (polynomial)")
+        ax = axes[2]
+        ax.plot(obs.wavelength, preds[0]/ obs.response, label="intrinsic model spectrum")
+        ax.set_xlabel("wavelength")
+        [ax.legend() for ax in axes]
\ No newline at end of file

From 9f00d0875bd701a401f60c7623de74af2ebaf353 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 8 Aug 2024 18:53:33 -0400
Subject: [PATCH 105/132] fix misnamed spectral response method.

---
 prospect/observation/observation.py | 2 +-
 tests/test_polycal.py               | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 58a544ab..60f916c3 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -440,7 +440,7 @@ def instrumental_smoothing(self, model_wave_obsframe, model_flux, zred=0, libres
         return outspec_padded[self._unpadded_inds]
 
 
-    def instrumental_response(self, **extras):
+    def compute_response(self, **extras):
         if self.response is not None:
             return self.response
         else:
diff --git a/tests/test_polycal.py b/tests/test_polycal.py
index 7a3261c4..b4ea4488 100644
--- a/tests/test_polycal.py
+++ b/tests/test_polycal.py
@@ -54,7 +54,7 @@ def build_obs(multispec=False):
     return obslist
 
 
-def test_polycal(plot=False):
+def test_polycal(get_sps, plot=False):
     """Make sure the polynomial optimization works
     """
     sps = get_sps

From 0bb8f43f023e3318f0a1147069b644345e0715a4 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 8 Jul 2024 12:39:33 -0400
Subject: [PATCH 106/132] words in readme about migrating from v1.X

---
 README.md | 53 +++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 45 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index bc8ab330..82c21565 100644
--- a/README.md
+++ b/README.md
@@ -6,10 +6,8 @@ Version 2.0! (in progress)
 
 This is a major refactor to allow for multiple datasets (i.e. multiple spectra)
 with different noise models and instrument parameters to constrain a single
-galaxy model.  It will also include substantial updates to the outputs to allow
-samples of the spectra (and mfrac) generated during sampling to be saved as well
-as as cleaner parameter sample output. It may include emulator models and
-gradient based sampling.
+galaxy model.  Other updates may include cleaner stored outputs, interfaces with
+additional nested samplers, and improved tretments of smoothing.
 
 Work to do includes:
 
@@ -21,7 +19,8 @@ Work to do includes:
 - [x] Structured ndarray for output chains and lnlikehoods
 - [x] Update docs
 - [x] Update demo scripts
-- [ ] Account for undersampled spectra via a square convolution in pixel space (or explicit rebinning)
+- [x] Account for undersampled spectra via explicit rebinning.
+- [ ] Account for undersampled spectra via a square convolution in pixel space.
 - [ ] Update notebooks
 - [ ] Update plotting module
 - [ ] Test i/o with structured arrays
@@ -33,6 +32,44 @@ Work to do includes:
 - [ ] Implement UltraNest and Nautilus backends
 
 
+Migration from < v2.0
+---------------------
+
+For most users the primary difference from v1.X will be that the data to predict
+and fit is now specified as a list of `prospect.observation.Observation()`
+instances, instead of a single 'obs' dictionary.  There is a new convenience
+method to convert from the old 'obs' dictionary format to the new specification.
+This can be used with existing scripts as follows:
+
+```py
+# old build_obs function giving a dictionary
+obs_dict = build_obs(**run_params)
+# get convenience method
+from prospect.observation import from_oldstyle
+# make a new list of Observation instances from the dictionary
+observations = from_oldstyle(obs_dict)
+# verify and prepare for fitting; similar to 'obsutils.fix_obs()'
+[obs.rectify() for obs in observations]
+print(observations)
+```
+
+It is recommended to do the conversion within the `build_obs()` method, if
+possible. This list of observations is then supplied to `fit_model`.  Because
+noise models are now attached explicitly to each observation, they do not need
+to be generated separately or supplied to `fit_model()`, which no longer accepts
+a `noise=` argument.
+
+```py
+from prospect.fitting import fit_model
+output = fit_model(observations, model, sps, **config)
+```
+
+Finally, the output chain or samples is now stored as a structured array, where
+each row corresponds to a sample, and each column is a parameter (possibly
+multidimensional).  Additional information (such as sample weights, likelihoods,
+and poster probabilities) are stored as additional datasets in the output.
+
+
 Purpose
 -------
 
@@ -48,9 +85,9 @@ and/or spectroscopic data.  Prospector allows you to:
 * Infer high-dimensional stellar population properties using parametric or
   highly flexible SFHs (with nested or ensemble Monte Carlo sampling)
 
-* Combine photometric and spectroscopic data from the UV to Far-IR rigorously
-  using a flexible spectroscopic calibration model and forward modeling many
-  aspects of spectroscopic data analysis.
+* Combine multiple photometric, spectroscopic, and/or line flux datasets from
+  the UV to Far-IR rigorously using a flexible spectroscopic calibration model
+  and forward modeling many aspects of spectroscopic data analysis.
 
 Read the [documentation](http://prospect.readthedocs.io/en/latest/) and the
 code [paper](https://ui.adsabs.harvard.edu/abs/2021ApJS..254...22J/abstract).

From d76f841821e942debc0513bdc801aedde0b810be Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Mon, 8 Jul 2024 16:05:58 -0400
Subject: [PATCH 107/132] Mention polynomial calibration in readme for changes
 from v1.X.

---
 README.md       | 15 ++++++++++-----
 doc/spectra.rst |  8 ++++++--
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 82c21565..1b4f7fe7 100644
--- a/README.md
+++ b/README.md
@@ -35,11 +35,12 @@ Work to do includes:
 Migration from < v2.0
 ---------------------
 
-For most users the primary difference from v1.X will be that the data to predict
-and fit is now specified as a list of `prospect.observation.Observation()`
-instances, instead of a single 'obs' dictionary.  There is a new convenience
-method to convert from the old 'obs' dictionary format to the new specification.
-This can be used with existing scripts as follows:
+For many users the primary difference from v1.X will be that the data to predict
+and fit a model to is now specified as a list of
+`prospect.observation.Observation()` instances, instead of a single 'obs'
+dictionary.  There is a new convenience method to convert from the old 'obs'
+dictionary format to the new specification. This can be used with existing
+scripts as follows:
 
 ```py
 # old build_obs function giving a dictionary
@@ -64,6 +65,10 @@ from prospect.fitting import fit_model
 output = fit_model(observations, model, sps, **config)
 ```
 
+Another change is that spectral response functions (i.e. calibration vectors) are now handled by specialized sub-classes of these `Observation` classes.  See `spectra`_ for details.
+
+.. _spectra: docs/spectra.rst
+
 Finally, the output chain or samples is now stored as a structured array, where
 each row corresponds to a sample, and each column is a parameter (possibly
 multidimensional).  Additional information (such as sample weights, likelihoods,
diff --git a/doc/spectra.rst b/doc/spectra.rst
index ef0a96a3..5d81746a 100644
--- a/doc/spectra.rst
+++ b/doc/spectra.rst
@@ -39,13 +39,17 @@ over the polynomial coefficients (this allows you to place priors on the
 accuracy of the spectrophotometric calibration). Or you can just take the
 spectrum as perfectly calibrated.
 
-Particular treatments can be implemented using different mix-in classes, e.g.
+Particular treatments can be implemented using different mix-in classes for the
+:py:class:`Spectrum` observational data, e.g. for optimization of a 5th order
+polynomial calibration vector at each likelihood call, use
+:py:class:`PolyOptCal` as follows
 
 .. code-block:: python
 
         from prospect.observation import Spectrum, PolyOptCal
-        class PolySpectrum(PolyOptCal, Spectrum):
+        class PolySpectrum(PolyOptCal, Spectrum):  # order matters
             pass
+
         spec = PolySpectrum(wavelength=np.linspace(3000, 5000, N),
                             flux=np.zeros(N),
                             uncertainty=np.ones(N),

From ca3948e1ed23c5a16eb78a8bcb9966ec221c28cc Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 9 Aug 2024 11:00:24 -0400
Subject: [PATCH 108/132] try to store an unstructured chain in the output as
 well as a structured chain.

---
 README.md                    |  4 +---
 prospect/io/write_results.py | 16 +++++++++++-----
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 1b4f7fe7..214e68c6 100644
--- a/README.md
+++ b/README.md
@@ -65,9 +65,7 @@ from prospect.fitting import fit_model
 output = fit_model(observations, model, sps, **config)
 ```
 
-Another change is that spectral response functions (i.e. calibration vectors) are now handled by specialized sub-classes of these `Observation` classes.  See `spectra`_ for details.
-
-.. _spectra: docs/spectra.rst
+Another change is that spectral response functions (i.e. calibration vectors) are now handled by specialized sub-classes of these `Observation` classes.  See the [spectroscopy docs](docs/spectra.rst) for details.
 
 Finally, the output chain or samples is now stored as a structured array, where
 each row corresponds to a sample, and each column is a parameter (possibly
diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index cf3d312c..2d27c67a 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -5,10 +5,11 @@
 to HDF5 files as well as to pickles.
 """
 
-import os, time, warnings
-from copy import deepcopy
-import pickle, json, base64
+import warnings
+import pickle, json
 import numpy as np
+from numpy.lib.recfunctions import structured_to_unstructured, unstructured_to_structured
+
 try:
     import h5py
     _has_h5py_ = True
@@ -223,6 +224,11 @@ def write_sampling_h5(hf, chain, extras):
         sdat = hf.create_group('sampling')
 
     sdat.create_dataset('chain', data=chain)
+    try:
+        uchain = structured_to_unstructured(chain)
+        sdat.create_dataset("unstructured_chain", data=uchain)
+    except:
+        pass
     for k, v in extras.items():
         try:
             sdat.create_dataset(k, data=v)
@@ -279,8 +285,7 @@ def chain_to_struct(chain, model=None, names=None, **extras):
     struct :
         A structured ndarray of parameter values.
     """
-    indict = isinstance(chain, dict)
-    if indict:
+    if isinstance(chain, dict):
         return dict_to_struct(chain)
     else:
         n = np.prod(chain.shape[:-1])
@@ -296,6 +301,7 @@ def chain_to_struct(chain, model=None, names=None, **extras):
 
     dt += [(str(k), "<f8") for k in extras.keys()]
 
+    # TODO: replace with unstructured_to_structured
     struct = np.zeros(n, dtype=np.dtype(dt))
     for i, p in enumerate(names):
         if model is not None:

From ade88bd3dd3608ac086b7b0165397986ffe2c5ce Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 6 Jul 2024 15:32:36 -0400
Subject: [PATCH 109/132] clean up imports and type comparison in
 parameters.py.

---
 prospect/models/parameters.py | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/prospect/models/parameters.py b/prospect/models/parameters.py
index 01b2509e..37624bef 100644
--- a/prospect/models/parameters.py
+++ b/prospect/models/parameters.py
@@ -10,13 +10,9 @@
 from copy import deepcopy
 import warnings
 import numpy as np
-import json, pickle
 from . import priors
 from .templates import describe
-import scipy
-from . import hyperparam_transforms as transforms
-#from gp_sfh import *
-#import gp_sfh_kernels
+
 
 __all__ = ["ProspectorParams"]
 
@@ -67,10 +63,10 @@ def __init__(self, configuration, verbose=True, param_order=None, **kwargs):
         """
         self.init_config = deepcopy(configuration)
         self.parameter_order = param_order
-        if type(configuration) == list:
+        if isinstance(configuration, list):
             self.config_list = configuration
             self.config_dict = plist_to_pdict(self.config_list)
-        elif type(configuration) == dict:
+        elif isinstance(configuration, dict):
             self.config_dict = configuration
             self.config_list = pdict_to_plist(self.config_dict, order=param_order)
         else:
@@ -188,7 +184,7 @@ def _prior_product(self, theta, **extras):
             parameter values.
         """
         lnp_prior = 0
-        
+
         for k, inds in list(self.theta_index.items()):
             func = self.config_dict[k]['prior']
             this_prior = np.sum(func(theta[..., inds]), axis=-1)
@@ -209,10 +205,10 @@ def prior_transform(self, unit_coords):
         theta = np.zeros(len(unit_coords))
 
         for k, inds in list(self.theta_index.items()):
-            
+
             func = self.config_dict[k]['prior'].unit_transform
             theta[inds] = func(unit_coords[inds])
-        
+
         return theta
 
     def propagate_parameter_dependencies(self):

From 9a4262ad80fefd13bd608b71ef06788c531e18ea Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Sat, 6 Jul 2024 23:26:53 -0400
Subject: [PATCH 110/132] Multiple nested samplers.   Add a unified nested
 sampling method for multiple samplers,   including interface to input
 arguments and output files.   Remove old dynesty iterator based interface,
 and many sampling options.

---
 .github/workflows/tests.yml     |   2 +-
 prospect/fitting/__init__.py    |   4 +-
 prospect/fitting/fitting.py     | 124 +++++----
 prospect/fitting/nested.py      | 439 ++++++++++++++++++--------------
 prospect/io/write_results.py    |  22 +-
 prospect/utils/prospect_args.py |  57 ++---
 6 files changed, 336 insertions(+), 312 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index f7b7c073..0b720d3c 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -12,7 +12,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9", "3.10"]
+        python-version: ["3.9", "3.11"]
         os: [ubuntu-latest, macos-latest]
     steps:
       - name: Clone the repo
diff --git a/prospect/fitting/__init__.py b/prospect/fitting/__init__.py
index 80cbb8f7..0a6bbc6d 100644
--- a/prospect/fitting/__init__.py
+++ b/prospect/fitting/__init__.py
@@ -1,10 +1,10 @@
 from .ensemble import run_emcee_sampler, restart_emcee_sampler
 from .minimizer import reinitialize
-from .nested import run_dynesty_sampler
+from .nested import run_nested_sampler
 from .fitting import fit_model, lnprobfn, run_minimize
 
 __all__ = ["fit_model", "lnprobfn",
            # below should all be removed/deprecated
            "run_emcee_sampler", "restart_emcee_sampler",
-           "run_dynesty_sampler",
+           "run_nested_sampler",
            "run_minimize", "reinitialize"]
diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index d222d07c..27c107d7 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -15,12 +15,12 @@
 
 from .minimizer import minimize_wrapper, minimizer_ball
 from .ensemble import run_emcee_sampler
-from .nested import run_dynesty_sampler
+from .nested import run_nested_sampler, parse_nested_kwargs
 from ..likelihood.likelihood import compute_chi, compute_lnlike
 
 
 __all__ = ["lnprobfn", "fit_model",
-           "run_minimize", "run_emcee", "run_dynesty"
+           "run_minimize", "run_ensemble", "run_nested"
            ]
 
 
@@ -72,7 +72,7 @@ def lnprobfn(theta, model=None, observations=None, sps=None,
     """
     if residuals:
         ndof = np.sum([obs["ndof"] for obs in observations])
-        lnnull = np.zeros(ndof) - 1e18  # -np.infty
+        lnnull = np.zeros(ndof) - 1e18  # -np.inf
     else:
         lnnull = -np.inf
 
@@ -123,7 +123,8 @@ def wrap_lnp(lnpfn, observations, model, sps, **lnp_kwargs):
 
 
 def fit_model(observations, model, sps, lnprobfn=lnprobfn,
-              optimize=False, emcee=False, dynesty=True, **kwargs):
+              optimize=False, emcee=False, nested_sampler="",
+              **kwargs):
     """Fit a model to observations using a number of different methods
 
     Parameters
@@ -167,7 +168,7 @@ def fit_model(observations, model, sps, lnprobfn=lnprobfn,
         + ``hfile``: an open h5py.File file handle for writing result incrementally
 
         Many additional emcee parameters can be provided here, see
-        :py:func:`run_emcee` for details.
+        :py:func:`run_ensemble` for details.
 
     dynesty : bool (optional, default: True)
         If ``True``, sample from the posterior using dynesty.  Additonal
@@ -184,11 +185,7 @@ def fit_model(observations, model, sps, lnprobfn=lnprobfn,
     # Make sure obs has required keys
     [obs.rectify() for obs in observations]
 
-    if emcee & dynesty:
-        msg = ("Cannot run both emcee and dynesty fits "
-               "in a single call to fit_model")
-        raise(ValueError, msg)
-    if (not emcee) & (not dynesty) & (not optimize):
+    if (not bool(emcee)) & (not bool(nested_sampler)) & (not optimize):
         msg = ("No sampling or optimization routine "
                "specified by user; returning empty results")
         warnings.warn(msg)
@@ -204,14 +201,16 @@ def fit_model(observations, model, sps, lnprobfn=lnprobfn,
         output["optimization"] = (optres, topt)
 
     if emcee:
-        run_sampler = run_emcee
-    elif dynesty:
-        run_sampler = run_dynesty
+        run_sampler = run_ensemble
+    elif nested_sampler:
+        run_sampler = run_nested
+        kwargs["fitter"] = nested_sampler
     else:
         return output
 
     output["sampling"] = run_sampler(observations, model, sps,
-                                     lnprobfn=lnprobfn, **kwargs)
+                                     lnprobfn=lnprobfn,
+                                     **kwargs)
     return output
 
 
@@ -305,8 +304,8 @@ def run_minimize(observations=None, model=None, sps=None, lnprobfn=lnprobfn,
     return results, tm, best
 
 
-def run_emcee(observations, model, sps, lnprobfn=lnprobfn,
-              hfile=None, initial_positions=None, **kwargs):
+def run_ensemble(observations, model, sps, lnprobfn=lnprobfn,
+                 hfile=None, initial_positions=None, **kwargs):
     """Run emcee, optionally including burn-in and convergence checking.  Thin
     wrapper on :py:class:`prospect.fitting.ensemble.run_emcee_sampler`
 
@@ -387,6 +386,7 @@ def run_emcee(observations, model, sps, lnprobfn=lnprobfn,
     q = model.theta.copy()
 
     postkwargs = {}
+    # Hack for MPI pools to access the global namespace
     for item in ['observations', 'model', 'sps']:
         val = eval(item)
         if val is not None:
@@ -396,26 +396,32 @@ def run_emcee(observations, model, sps, lnprobfn=lnprobfn,
     # Could try to make signatures for these two methods the same....
     if initial_positions is not None:
         raise NotImplementedError
-        meth = restart_emcee_sampler
-        t = time.time()
-        out = meth(lnprobfn, initial_positions, hdf5=hfile,
-                   postkwargs=postkwargs, **kwargs)
+        go = time.time()
+        out = restart_emcee_sampler(lnprobfn, initial_positions,
+                                    hdf5=hfile,
+                                    postkwargs=postkwargs,
+                                    **kwargs)
         sampler = out
-        ts = time.time() - t
+        ts = time.time() - go
     else:
-        meth = run_emcee_sampler
-        t = time.time()
-        out = meth(lnprobfn, q, model, hdf5=hfile,
-                   postkwargs=postkwargs, **kwargs)
-        sampler, burn_p0, burn_prob0 = out
-        ts = time.time() - t
+        go = time.time()
+        out = run_emcee_sampler(lnprobfn, q, model,
+                                hdf5=hfile,
+                                postkwargs=postkwargs,
+                                **kwargs)
+        sampler, burn_loc0, burn_prob0 = out
+        ts = time.time() - go
 
     return sampler, ts
 
 
-def run_dynesty(observations, model, sps, lnprobfn=lnprobfn,
-                pool=None, nested_target_n_effective=10000, **kwargs):
-    """Thin wrapper on :py:class:`prospect.fitting.nested.run_dynesty_sampler`
+def run_nested(observations, model, sps,
+               lnprobfn=lnprobfn,
+               fitter="dynesty",
+               nested_nlive=1000,
+               nested_neff=1000,
+               **kwargs):
+    """Thin wrapper on :py:class:`prospect.fitting.nested.run_nested_sampler`
 
     Parameters
     ----------
@@ -436,43 +442,33 @@ def run_dynesty(observations, model, sps, lnprobfn=lnprobfn,
         ``model``, and ``sps`` as keywords. By default use the
         :py:func:`lnprobfn` defined above.
 
-    Extra Parameters
-    --------
-    nested_bound: (optional, default: 'multi')
-
-    nested_sample: (optional, default: 'unif')
-
-    nested_nlive_init: (optional, default: 100)
-
-    nested_nlive_batch: (optional, default: 100)
-
-    nested_dlogz_init: (optional, default: 0.02)
-
-    nested_maxcall: (optional, default: None)
-
-    nested_walks: (optional, default: 25)
-
     Returns
     --------
-    result:
-        An instance of :py:class:`dynesty.results.Results`.
+    result: Dictionary
+        Will have keys:
+        * points : parameter location of the samples
+        * log_weight : ln of the weights of each sample
+        * log_like : ln of the likelihoods of each sample
 
     t_wall : float
         Duration of sampling in seconds of wall time.
     """
-    from dynesty.dynamicsampler import stopping_function, weight_function
-    nested_stop_kwargs = {"target_n_effective": nested_target_n_effective}
-
-    lnp = wrap_lnp(lnprobfn, observations, model, sps, nested=True)
-
-    # Need to deal with postkwargs...
-
-    t = time.time()
-    dynestyout = run_dynesty_sampler(lnp, model.prior_transform, model.ndim,
-                                     stop_function=stopping_function,
-                                     wt_function=weight_function,
-                                     nested_stop_kwargs=nested_stop_kwargs,
-                                     pool=pool, **kwargs)
-    ts = time.time() - t
-
-    return dynestyout, ts
+    # wrap the probability fiunction, making sure it's a likelihood
+    likelihood = wrap_lnp(lnprobfn, observations, model, sps, nested=True)
+
+    # which keywords do we have for this fitter?
+    ns_kwargs, nr_kwargs = parse_nested_kwargs(fitter=fitter,
+                                               **kwargs)
+
+    go = time.time()
+    output = run_nested_sampler(model,
+                                likelihood,
+                                fitter=fitter,
+                                verbose=False,
+                                nested_nlive=nested_nlive,
+                                nested_neff=nested_neff,
+                                nested_sampler_kwargs=ns_kwargs,
+                                nested_run_kwargs=nr_kwargs)
+    ts = time.time() - go
+
+    return output, ts
diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index 73d7ed1e..80083e34 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -1,199 +1,244 @@
-import sys, time
+import time
 import numpy as np
-from numpy.random import normal, multivariate_normal
-
-try:
-    import nestle
-except(ImportError):
-    pass
-
-
-try:
-    import dynesty
-    from dynesty.utils import *
-    from dynesty.dynamicsampler import _kld_error
-except(ImportError):
-    pass
-
-
-__all__ = ["run_nestle_sampler", "run_dynesty_sampler"]
-
-
-def run_nestle_sampler(lnprobfn, model, verbose=True,
-                       callback=None,
-                       nestle_method='multi', nestle_npoints=200,
-                       nestle_maxcall=int(1e6), nestle_update_interval=None,
-                       **kwargs):
-
-    result = nestle.sample(lnprobfn, model.prior_transform, model.ndim,
-                           method=nestle_method, npoints=nestle_npoints,
-                           callback=callback, maxcall=nestle_maxcall,
-                           update_interval=nestle_update_interval)
-    return result
-
-
-def run_dynesty_sampler(lnprobfn, prior_transform, ndim,
-                        verbose=True,
-                        # sampler kwargs
-                        nested_bound='multi',
-                        nested_sample='unif',
-                        nested_walks=25,
-                        nested_update_interval=0.6,
-                        nested_bootstrap=0,
-                        pool=None,
-                        use_pool={},
-                        queue_size=1,
-                        # init sampling kwargs
-                        nested_nlive_init=100,
-                        nested_dlogz_init=0.02,
-                        nested_maxiter_init=None,
-                        nested_maxcall_init=None,
-                        nested_live_points=None,
-                        # batch sampling kwargs
-                        nested_maxbatch=None,
-                        nested_nlive_batch=100,
-                        nested_maxiter_batch=None,
-                        nested_maxcall_batch=None,
-                        nested_use_stop=True,
-                        # overall kwargs
-                        nested_maxcall=None,
-                        nested_maxiter=None,
-                        nested_first_update={},
-                        stop_function=None,
-                        wt_function=None,
-                        nested_weight_kwargs={'pfrac': 1.0},
-                        nested_stop_kwargs={},
-                        nested_save_bounds=False,
-                        print_progress=True,
-                        **extras):
-
-    # instantiate sampler
-    dsampler = dynesty.DynamicNestedSampler(lnprobfn, prior_transform, ndim,
-                                            bound=nested_bound,
-                                            sample=nested_sample,
-                                            walks=nested_walks,
-                                            bootstrap=nested_bootstrap,
-                                            update_interval=nested_update_interval,
-                                            pool=pool, queue_size=queue_size, use_pool=use_pool
-                                            )
-
-    # generator for initial nested sampling
-    ncall = dsampler.ncall
-    niter = dsampler.it - 1
-    tstart = time.time()
-    for results in dsampler.sample_initial(nlive=nested_nlive_init,
-                                           dlogz=nested_dlogz_init,
-                                           maxcall=nested_maxcall_init,
-                                           maxiter=nested_maxiter_init,
-                                           live_points=nested_live_points):
-
-        try:
-            # dynesty >= 2.0
-            (worst, ustar, vstar, loglstar, logvol,
-             logwt, logz, logzvar, h, nc, worst_it,
-             propidx, propiter, eff, delta_logz, blob) = results
-        except(ValueError):
-            # dynsety < 2.0
-            (worst, ustar, vstar, loglstar, logvol,
-            logwt, logz, logzvar, h, nc, worst_it,
-            propidx, propiter, eff, delta_logz) = results
-
-        if delta_logz > 1e6:
-            delta_logz = np.inf
-        ncall += nc
-        niter += 1
-
-        if print_progress:
-            with np.errstate(invalid='ignore'):
-                logzerr = np.sqrt(logzvar)
-            sys.stderr.write("\riter: {:d} | batch: {:d} | nc: {:d} | "
-                            "ncall: {:d} | eff(%): {:6.3f} | "
-                            "logz: {:6.3f} +/- {:6.3f} | "
-                            "dlogz: {:6.3f} > {:6.3f}    "
-                            .format(niter, 0, nc, ncall, eff, logz,
-                                    logzerr, delta_logz, nested_dlogz_init))
-            sys.stderr.flush()
-
-    ndur = time.time() - tstart
-    if verbose:
-        print('\ndone dynesty (initial) in {0}s'.format(ndur))
-
-    if nested_maxcall is None:
-        nested_maxcall = sys.maxsize
-    if nested_maxbatch is None:
-        nested_maxbatch = sys.maxsize
-    if nested_maxcall_batch is None:
-        nested_maxcall_batch = sys.maxsize
-    if nested_maxiter is None:
-        nested_maxiter = sys.maxsize
-    if nested_maxiter_batch is None:
-        nested_maxiter_batch = sys.maxsize
-
-    # generator for dynamic sampling
-    tstart = time.time()
-    for n in range(dsampler.batch, nested_maxbatch):
-        # Update stopping criteria.
-        dsampler.sampler.save_bounds = False
-        res = dsampler.results
-        mcall = min(nested_maxcall - ncall, nested_maxcall_batch)
-        miter = min(nested_maxiter - niter, nested_maxiter_batch)
-        if nested_use_stop:
-            if dsampler.use_pool_stopfn:
-                M = dsampler.M
-            else:
-                M = map
-            stop, stop_vals = stop_function(res, nested_stop_kwargs,
-                                            rstate=dsampler.rstate, M=M,
-                                            return_vals=True)
-            stop_val = stop_vals[2]
-        else:
-            stop = False
-            stop_val = np.NaN
-
-        # If we have either likelihood calls or iterations remaining,
-        # run our batch.
-        if mcall > 0 and miter > 0 and not stop:
-            # Compute our sampling bounds using the provided
-            # weight function.
-            logl_bounds = wt_function(res, nested_weight_kwargs)
-            lnz, lnzerr = res.logz[-1], res.logzerr[-1]
-            for results in dsampler.sample_batch(nlive_new=nested_nlive_batch,
-                                                 logl_bounds=logl_bounds,
-                                                 maxiter=miter,
-                                                 maxcall=mcall,
-                                                 save_bounds=nested_save_bounds):
-
-                try:
-                    # dynesty >= 2.0
-                    (worst, ustar, vstar, loglstar, nc,
-                     worst_it, propidx, propiter, eff, blob) = results
-                except(ValueError):
-                    # dynesty < 2.0
-                    (worst, ustar, vstar, loglstar, nc,
-                    worst_it, propidx, propiter, eff) = results
-                ncall += nc
-                niter += 1
-                if print_progress:
-                    sys.stderr.write("\riter: {:d} | batch: {:d} | "
-                                    "nc: {:d} | ncall: {:d} | "
-                                    "eff(%): {:6.3f} | "
-                                    "loglstar: {:6.3f} < {:6.3f} "
-                                    "< {:6.3f} | "
-                                    "logz: {:6.3f} +/- {:6.3f} | "
-                                    "stop: {:6.3f}    "
-                                    .format(niter, n+1, nc, ncall,
-                                            eff, logl_bounds[0], loglstar,
-                                            logl_bounds[1], lnz, lnzerr,
-                                            stop_val))
-                    sys.stderr.flush()
-            dsampler.combine_runs()
-        else:
-            # We're done!
-            break
-
-    ndur = time.time() - tstart
-    if verbose:
-        print('done dynesty (dynamic) in {0}s'.format(ndur))
-
-    return dsampler.results
 
+
+__all__ = ["run_nested_sampler", "parse_nested_kwargs"]
+
+
+def parse_nested_kwargs(fitter=None, **kwargs):
+
+    # todo:
+    #   something like 'enlarge'
+    #   something like 'bootstrap' or N_networks or?
+
+    sampler_kwargs = {}
+    run_kwargs = {}
+
+    if fitter == "dynesty":
+        sampler_kwargs["bound"] = kwargs["nested_bound"]
+        sampler_kwargs["method"] = kwargs["nested_sample"]
+        sampler_kwargs["walks"] = kwargs["nested_walks"]
+        run_kwargs["dlogz_init"] = kwargs["nested_dlogz"]
+
+    elif fitter == "ultranest":
+        #run_kwargs["dlogz"] = kwargs["nested_dlogz"]
+        pass
+
+    elif fitter == "nautilus":
+        pass
+
+    else:
+        # say what?
+        raise ValueError(f"{fitter} not a valid fitter")
+
+    return sampler_kwargs, run_kwargs
+
+
+
+def run_nested_sampler(model,
+                       likelihood_function,
+                       fitter="dynesty",
+                       nested_nlive=1000,
+                       nested_neff=1000,
+                       verbose=False,
+                       nested_run_kwargs={},
+                       nested_sampler_kwargs={}):
+    """We give a model -- parameter discription and prior transform -- and a
+    likelihood function. We get back samples, weights, and likelihood values.
+    """
+
+    go = time.time()
+
+    # --- Nautilus ---
+    if fitter == "nautilus":
+        from nautilus import Sampler
+
+        sampler = Sampler(model.prior_transform,
+                          likelihood_function,
+                          pass_dict=False, # likelihood expects array, not dict
+                          n_live=nested_nlive,
+                          **nested_sampler_kwargs)
+        sampler.run(n_eff=nested_neff,
+                    verbose=verbose,
+                    **nested_run_kwargs)
+        points, log_w, log_like = sampler.posterior()
+
+    # --- Ultranest ---
+    if fitter == "ultranest":
+
+        from ultranest import ReactiveNestedSampler
+        sampler = ReactiveNestedSampler(model.theta_labels,
+                                        likelihood_function,
+                                        model.prior_transform,
+                                        **nested_sampler_kwargs)
+        result = sampler.run(min_ess=nested_neff,
+                             min_num_live_points=nested_nlive,
+                             show_status=verbose,
+                             **nested_run_kwargs)
+
+        points = np.array(result['weighted_samples']['points'])
+        log_w = np.log(np.array(result['weighted_samples']['weights']))
+        log_like = np.array(result['weighted_samples']['logl'])
+
+    # --- Dynesty ---
+    if fitter == "dynesty":
+        from dynesty import DynamicNestedSampler
+
+        sampler = DynamicNestedSampler(likelihood_function,
+                                       model.prior_transform,
+                                       model.ndim,
+                                       nlive=nested_nlive,
+                                       **nested_sampler_kwargs)
+        sampler.run_nested(n_effective=nested_neff,
+                           print_progress=verbose,
+                           **nested_run_kwargs)
+
+        points = sampler.results["samples"]
+        log_w = sampler.results["logwt"]
+        log_like = sampler.results["logl"]
+
+    # --- Nestle ---
+    if fitter == "nestle":
+        import nestle
+        result = nestle.sample(likelihood_function,
+                               model.prior_transform,
+                               model.ndim,
+                               **nested_sampler_kwargs)
+
+        points = result["samples"]
+        log_w = result["logwt"]
+        log_like = result["logl"]
+
+    dur = time.time() - go
+
+    return dict(points=points, log_weight=log_w, log_like=log_like)
+
+
+# OMG
+SAMPLER_KWARGS = {
+
+"dynesty_sampler_kwargs" : dict(nlive=None,
+                                bound='multi',
+                                sample='auto',
+                                #periodic=None,
+                                #reflective=None,
+                                update_interval=None,
+                                first_update=None,
+                                npdim=None,
+                                #rstate=None,
+                                queue_size=None,
+                                pool=None,
+                                use_pool=None,
+                                #logl_args=None,
+                                #logl_kwargs=None,
+                                #ptform_args=None,
+                                #ptform_kwargs=None,
+                                #gradient=None,
+                                #grad_args=None,
+                                #grad_kwargs=None,
+                                #compute_jac=False,
+                                enlarge=None,
+                                bootstrap=None,
+                                walks=None,
+                                facc=0.5,
+                                slices=None,
+                                fmove=0.9,
+                                max_move=100,
+                                #update_func=None,
+                                ncdim=None,
+                                blob=False,
+                                #save_history=False,
+                                #history_filename=None)
+                             ),
+"dynesty_run_kwargs" : dict(nlive_init=None, # nlive0
+                            maxiter_init=None,
+                            maxcall_init=None,
+                            dlogz_init=0.01,
+                            logl_max_init=np.inf,
+                            n_effective_init=np.inf, # deprecated
+                            nlive_batch=None, #nlive0
+                            wt_function=None,
+                            wt_kwargs=None,
+                            maxiter_batch=None,
+                            maxcall_batch=None,
+                            maxiter=None,
+                            maxcall=None,
+                            maxbatch=None,
+                            n_effective=None,
+                            stop_function=None,
+                            stop_kwargs=None,
+                            #use_stop=True,
+                            #save_bounds=True, # doesn't hurt...?
+                            print_progress=True,
+                            #print_func=None,
+                            live_points=None,
+                            #resume=False,
+                            #checkpoint_file=None,
+                            #checkpoint_every=60)
+                            ),
+"ultranest_sampler_kwargs":dict(transform=None,
+                                #derived_param_names=[],
+                                #wrapped_params=None,
+                                #resume='subfolder',
+                                #run_num=None,
+                                #log_dir=None,
+                                #num_test_samples=2,
+                                draw_multiple=True,
+                                num_bootstraps=30,
+                                #vectorized=False,
+                                ndraw_min=128,
+                                ndraw_max=65536,
+                                storage_backend='hdf5',
+                                warmstart_max_tau=-1,
+                                ),
+"ultranest_run_kwargs":dict(update_interval_volume_fraction=0.8,
+                            update_interval_ncall=None,
+                            #log_interval=None,
+                            show_status=True,
+                            #viz_callback='auto',
+                            dlogz=0.5,
+                            dKL=0.5,
+                            frac_remain=0.01,
+                            Lepsilon=0.001,
+                            min_ess=400,
+                            max_iters=None,
+                            max_ncalls=None,
+                            max_num_improvement_loops=-1,
+                            min_num_live_points=400,
+                            cluster_num_live_points=40,
+                            insertion_test_window=10,
+                            insertion_test_zscore_threshold=4,
+                            region_class="MLFriends",
+                            #widen_before_initial_plateau_num_warn=10000,
+                            #widen_before_initial_plateau_num_max=50000,
+                            ),
+"nautilus_sampler_kwargs":dict(n_live=2000,
+                               n_update=None,
+                               enlarge_per_dim=1.1,
+                               n_points_min=None,
+                               split_threshold=100,
+                               n_networks=4,
+                               neural_network_kwargs={},
+                               #prior_args=[],
+                               #prior_kwargs={},
+                               #likelihood_args=[],
+                               #likelihood_kwargs={},
+                               n_batch=None,
+                               n_like_new_bound=None,
+                               #vectorized=False,
+                               #pass_dict=None,
+                               pool=None,
+                               seed=None,
+                               blobs_dtype=None,
+                               #filepath=None,
+                               #resume=True
+                               ),
+"nautilus_run_kwargs":dict(f_live=0.01,
+                           n_shell=1,
+                           n_eff=10000,
+                           n_like_max=np.inf,
+                           discard_exploration=False,
+                           timeout=np.inf,
+                           verbose=False
+                           ),
+}
diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index 2d27c67a..79743d10 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -116,8 +116,8 @@ def write_hdf5(hfile, run_params, model, obs,
     # Sampling info
     if run_params.get("emcee", False):
         chain, extras = emcee_to_struct(sampler, model)
-    elif run_params.get("dynesty", False):
-        chain, extras = dynesty_to_struct(sampler, model)
+    elif run_params.get("nested", False):
+        chain, extras = nested_to_struct(sampler, model)
     else:
         chain, extras = None, None
     write_sampling_h5(hf, chain, extras)
@@ -200,20 +200,16 @@ def emcee_to_struct(sampler, model):
     return chaincat, extras
 
 
-def dynesty_to_struct(dyout, model):
+def nested_to_struct(nested_out, model):
     # preamble
-    lnprior = model.prior_product(dyout['samples'])
+    lnprior = model.prior_product(nested_out['points'])
 
     # chaincat & extras
-    chaincat = chain_to_struct(dyout["samples"], model=model)
-    extras = dict(weights=np.exp(dyout['logwt']-dyout['logz'][-1]),
-                  lnprobability=dyout['logl'] + lnprior,
-                  lnlike=dyout['logl'],
-                  efficiency=np.atleast_1d(dyout['eff']),
-                  logz=np.atleast_1d(dyout['logz']),
-                  ncall=np.atleast_1d(dyout['ncall'])
-                  #ncall=json.dumps(dyout['ncall'].tolist())
-                 )
+    chaincat = chain_to_struct(nested_out['points'], model=model)
+    extras = dict(weights=np.exp(nested_out['log_weight']),
+                  lnprobability=nested_out['log_like'] + lnprior,
+                  lnlike=nested_out['log_like']
+                  )
     return chaincat, extras
 
 
diff --git a/prospect/utils/prospect_args.py b/prospect/utils/prospect_args.py
index 15c3d31a..7e257a5e 100644
--- a/prospect/utils/prospect_args.py
+++ b/prospect/utils/prospect_args.py
@@ -14,7 +14,7 @@ def show_default_args():
     parser.print_help()
 
 
-def get_parser(fitters=["optimize", "emcee", "dynesty"]):
+def get_parser(fitters=["optimize", "emcee", "nested"]):
     """Get a default prospector argument parser
     """
 
@@ -46,8 +46,8 @@ def get_parser(fitters=["optimize", "emcee", "dynesty"]):
     if "emcee" in fitters:
         parser = add_emcee_args(parser)
 
-    if "dynesty" in fitters:
-        parser = add_dynesty_args(parser)
+    if "nested" in fitters:
+        parser = add_nested_args(parser)
 
     return parser
 
@@ -108,10 +108,22 @@ def add_emcee_args(parser):
     return parser
 
 
-def add_dynesty_args(parser):
+def add_nested_args(parser):
     # --- dynesty parameters ---
-    parser.add_argument("--dynesty", action="store_true",
-                        help="If set, do nested sampling with dynesty.")
+    parser.add_argument("--nested_sampler", type=str, default="",
+                        choices=["", "dynesty", "nautilus", "ultranest"],
+                        help="do sampling with this sampler")
+
+    parser.add_argument("--nested_nlive", dest="nested_nlive", type=int, default=1000,
+                        help="Number of live points for the nested sampling run.")
+
+    parser.add_argument("--nested_target_n_effective", type=int, default=10000,
+                        help=("Stop when the number of *effective* posterior samples as estimated "
+                              "by dynesty reaches the target number."))
+
+    parser.add_argument("--nested_dlogz", type=float, default=0.05,
+                        help=("Stop the initial run when the remaining evidence is estimated "
+                              "to be less than this."))
 
     parser.add_argument("--nested_bound", type=str, default="multi",
                         choices=["single", "multi", "balls", "cubes"],
@@ -119,42 +131,17 @@ def add_dynesty_args(parser):
                               "One of single | multi | balls | cubes"))
 
     parser.add_argument("--nested_sample", "--nested_method", type=str, dest="nested_sample",
-                        default="slice", choices=["unif", "rwalk", "slice"],
+                        default="auto", choices=["auto", "unif", "rwalk", "slice", "hslice"],
                         help=("Method for drawing new points during sampling.  "
-                              "One of unif | rwalk | slice"))
+                              "One of auto | unif | rwalk | slice | hslice"))
 
     parser.add_argument("--nested_walks", type=int, default=48,
                         help=("Number of Metropolis steps to take when "
                               "`nested_sample` is 'rwalk'"))
 
-    parser.add_argument("--nlive_init", dest="nested_nlive_init", type=int, default=100,
-                        help="Number of live points for the intial nested sampling run.")
-
-    parser.add_argument("--nlive_batch", dest="nested_nlive_batch", type=int, default=100,
-                        help="Number of live points for the dynamic nested sampling batches")
-
-    parser.add_argument("--nested_dlogz_init", type=float, default=0.05,
-                        help=("Stop the initial run when the remaining evidence is estimated "
-                              "to be less than this."))
-
-    parser.add_argument("--nested_maxcall", type=int, default=int(5e7),
-                        help=("Maximum number of likelihood calls during nested sampling. "
-                              "This will only be enforced after the initial pass"))
-
-    parser.add_argument("--nested_maxiter", type=int, default=int(1e6),
-                        help=("Maximum number of iterations during nested sampling. "
-                              "This will only be enforced after the initial pass"))
-
-    parser.add_argument("--nested_maxbatch", type=int, default=10,
-                        help="Maximum number of dynamic batches.")
-
     parser.add_argument("--nested_bootstrap", type=int, default=0,
-                        help=("Number of bootstrap resamplings to use when estimating "
-                              "ellipsoid expansion factor."))
-
-    parser.add_argument("--nested_target_n_effective", type=int, default=10000,
-                        help=("Stop when the number of *effective* posterior samples as estimated "
-                              "by dynesty reaches the target number."))
+                         help=("Number of bootstrap resamplings to use when estimating "
+                               "ellipsoid expansion factor."))
 
     return parser
 

From fa2c50193946497539c6dd49893b5a9b706c60dc Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 28 Aug 2024 13:50:04 -0400
Subject: [PATCH 111/132] change how samplers are specified; clean up how
 results are passed and written out; update docs; add sampler test script.

---
 demo/demo_params.py          |  12 ++--
 demo/tutorial.rst            |  25 ++++----
 doc/quickstart.rst           |  36 ++++++-----
 doc/usage.rst                |  40 +++++++-----
 prospect/fitting/fitting.py  |  34 ++++++----
 prospect/fitting/nested.py   |  47 +++++++++-----
 prospect/io/write_results.py |  83 +++++++++++++-----------
 tests/tests_samplers.py      | 119 +++++++++++++++++++++++++++++++++++
 8 files changed, 281 insertions(+), 115 deletions(-)
 create mode 100644 tests/tests_samplers.py

diff --git a/demo/demo_params.py b/demo/demo_params.py
index b4d8a769..36fa1ed2 100644
--- a/demo/demo_params.py
+++ b/demo/demo_params.py
@@ -148,7 +148,7 @@ def build_obs(objid=0, phottable='demo_photometry.dat',
     # import astropy.io.fits as pyfits
     # catalog = pyfits.getdata(phottable)
 
-    from prospect.data.observation import Photometry, Spectrum
+    from prospect.observation import Photometry, Spectrum
 
     # Here we will read in an ascii catalog of magnitudes as a numpy structured
     # array
@@ -262,10 +262,12 @@ def build_all(**kwargs):
     output = fit_model(obs, model, sps, **config)
 
     print("writing to {}".format(hfile))
-    writer.write_hdf5(hfile, run_params, model, obs,
-                      output["sampling"][0], output["optimization"][0],
-                      tsample=output["sampling"][1],
-                      toptimize=output["optimization"][1],
+    writer.write_hdf5(hfile,
+                      config,
+                      model,
+                      obs,
+                      output["sampling"],
+                      output["optimization"],
                       sps=sps
                       )
 
diff --git a/demo/tutorial.rst b/demo/tutorial.rst
index dff8a13b..d2396367 100644
--- a/demo/tutorial.rst
+++ b/demo/tutorial.rst
@@ -164,25 +164,26 @@ that for now.
 
 Running a fit
 ----------------------
-There are two kinds of fitting packages that can be used with |Codename|. The
-first is ``emcee`` which implements ensemble MCMC sampling, and the second is
-``dynesty``, which implements dynamic nested sampling. It is also possible to
-perform optimization. If ``emcee`` is used, the result of the optimization will
-be used to initalize the ensemble of walkers.
+There are a few kinds of fitting packages that can be used with |Codename|. The
+first is ``emcee`` which implements ensemble MCMC sampling. A number of nested
+samplers are also available (``dynesty``, ``nautilus``, and ``ultranest``). It
+is also possible to perform optimization. If ``emcee`` is used, the result of
+the optimization will be used to initalize the ensemble of walkers.
 
 The choice of which fitting algorithms to use is based on command line flags
-(``--optimization``, ``--emcee``, and ``--dynesty``.) If no flags are set the
-model and data objects will be generated and stored in the output file, but no
-fitting will take place. To run the fit on object number 0 using ``emcee`` after
-an initial optimization, we would do the following at the command line
+(``--optimization``, ``--emcee``, and ``--nested_sampler <dynesty|nautilus|ultranest>``.)
+If no flags are set the model and data objects will be generated and stored in
+the output file, but no fitting will take place. To run the fit on object number
+0 using ``emcee`` after an initial optimization, we would do the following at
+the command line
 
 .. code-block:: shell
 
 		python demo_params.py --objid=0 --emcee --optimize \
 		--outfile=demo_obj0_emcee
 
-If we wanted to change something about the MCMC parameters, or fit a different object,
-we could also do that at the command line
+If we wanted to change something about the MCMC parameters, or fit a different
+object, we could also do that at the command line
 
 .. code-block:: shell
 
@@ -193,7 +194,7 @@ And if we want to use nested sampling with ``dynesty`` we would do the following
 
 .. code-block:: shell
 
-		python demo_params.py --objid=0  --dynesty \
+		python demo_params.py --objid=0  --nested_sampler dynesty \
 		--outfile=demo_obj0_dynesty
 
 Finally, it is sometimes useful to run the script from the interpreter to do
diff --git a/doc/quickstart.rst b/doc/quickstart.rst
index eabc38bf..376ef785 100644
--- a/doc/quickstart.rst
+++ b/doc/quickstart.rst
@@ -154,12 +154,12 @@ it should still take of order tens of minutes.
     output = fit_model(obs, model, sps, lnprobfn=lnprobfn,
                        optimize=False, dynesty=True,
                        **fitting_kwargs)
-    result, duration = output["sampling"]
+    result = output["sampling"]
 
 The ``result`` is a dictionary with keys giving the Monte Carlo samples of
 parameter values and the corresponding posterior probabilities.  Because we are
-using dynesty, we also get weights associated with each parameter sample in the
-chain.
+using nested sampling, we also get weights associated with each parameter sample
+in the chain.
 
 Typically we'll want to save the fit information.  We can save the output of the
 sampling along with other information about the model and the data that was fit
@@ -168,12 +168,16 @@ as follows:
 .. code:: python
 
     from prospect.io import write_results as writer
-    hfile = "./quickstart_dynesty_mcmc.h5"
-    writer.write_hdf5(hfile, {}, model, observations,
-                     output["sampling"][0], None,
-                     sps=sps,
-                     tsample=output["sampling"][1],
-                     toptimize=0.0)
+    writer.write_hdf5("./quickstart_dynesty_mcmc.h5",
+                      config=fitting_kwargs,
+                      model=model,
+                      obs=observations,
+                      output["sampling"],
+                      None,
+                      sps=sps)
+
+Note that this doesn't include all the config information that would normally be stored (see :ref:`usage`)
+
 
 Make plots
 ----------
@@ -187,14 +191,14 @@ information we can use the built-in reader.
     hfile = "./quickstart_dynesty_mcmc.h5"
     out, out_obs, out_model = reader.results_from(hfile)
 
-This gives a dictionary of useful information (``out``), as well as the obs
-dictionary that we were using and, in some cases, a reconsitituted model object.
-However, that is only possible if the model generation code is saved to the
-results file, in the form of the text for a `build_model()` function.  Here we
-will use just use the model object that we've already generated.
+This gives a dictionary of useful information (``out``), as well as the obs data
+that we were using and, in some cases, a reconsitituted model object. However,
+that is *only* possible if the model generation code is saved to the results file,
+in the form of the text for a `build_model()` function.  Here we will use just
+use the model object that we've already generated.
 
-Now we will do some plotting.  First, lets make a corner plot of the posterior.
-We'll mark the highest probablity posterior sample as well.
+First, lets make a corner plot of the posterior. We'll mark the highest
+probablity posterior sample as well.
 
 .. code:: python
 
diff --git a/doc/usage.rst b/doc/usage.rst
index 950f0931..29840131 100644
--- a/doc/usage.rst
+++ b/doc/usage.rst
@@ -13,7 +13,7 @@ execution:
 
 .. code-block:: shell
 
-		python parameter_file.py --dynesty
+		python parameter_file.py --nested_sampler dynesty --nested_target_n_effective 512
 
 Additional command line options can be given (see below) e.g.
 
@@ -50,6 +50,7 @@ writes output.
             # --- Configure ---
             args = parser.parse_args()
             config = vars(args)
+            # allows parameter file text to be stored for model regeneration
             config["param_file"] = __file__
 
             # --- Get fitting ingredients ---
@@ -68,12 +69,14 @@ writes output.
             output = fit_model(obs, model, sps, **config)
 
             print("writing to {}".format(hfile))
-            writer.write_hdf5(hfile, run_params, model, obs,
-                                output["sampling"][0], output["optimization"][0],
-                                tsample=output["sampling"][1],
-                                toptimize=output["optimization"][1],
-                                sps=sps
-                                )
+            writer.write_hdf5(hfile,
+                              config=config,
+                              model=model,
+                              obs=obs,
+                              output["sampling"],
+                              output["optimization"],
+                              sps=sps
+                              )
 
             try:
                 hfile.close()
@@ -147,7 +150,8 @@ might actually increase the total CPU usage).
 To use MPI a "pool" of cores must be made available; each core will instantiate
 the fitting ingredients separately, and a single core in the pool will then
 conduct the fit, distributing likelihood requests to the other cores in the
-pool.  This requires changes to the final code block that instantiates and runs the fit:
+pool.  This requires changes to the final code block that instantiates and runs
+the fit:
 
 .. code-block:: python
 
@@ -189,7 +193,7 @@ pool.  This requires changes to the final code block that instantiates and runs
 
         # Evaluate SPS over logzsol grid in order to get necessary data in cache/memory
         # for each MPI process. Otherwise, you risk creating a lag between the MPI tasks
-        # caching data depending which can slow down the parallelization
+        # caching SSPs which can slow down the parallelization
         if (withmpi) & ('logzsol' in model.free_params):
             dummy_obs = dict(filters=None, wavelength=None)
 
@@ -225,13 +229,15 @@ pool.  This requires changes to the final code block that instantiates and runs
 
         # Set up an output file and write
         ts = time.strftime("%y%b%d-%H.%M", time.localtime())
-        hfile = "{0}_{1}_mcmc.h5".format(args.outfile, ts)
-        writer.write_hdf5(hfile, run_params, model, obs,
-                          output["sampling"][0], output["optimization"][0],
-                          tsample=output["sampling"][1],
-                          toptimize=output["optimization"][1],
-                          sps=sps)
-
+        hfile = f"{args.outfile}_worker{comm.rank()}_{ts}_mcmc.h5"
+        writer.write_hdf5(hfile,
+                            run_params=run_params,
+                            model=model,
+                            obs=obs,
+                            output["sampling"],
+                            output["optimization"],
+                            sps=sps
+                            )
         try:
             hfile.close()
         except(AttributeError):
@@ -243,7 +249,7 @@ Then, to run this file using mpi it can be called from the command line with som
 
         mpirun -np <number of processors> python parameter_file.py --emcee
         # or
-        mpirun -np <number of processors> python parameter_file.py --dynesty
+        mpirun -np <number of processors> python parameter_file.py --nested_sampler dynesty
 
 Note that only model evaluation is parallelizable with `dynesty`, and many
 operations (e.g. new point proposal) are still done in serial. This means that
diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index 27c107d7..70e8cf34 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -185,13 +185,18 @@ def fit_model(observations, model, sps, lnprobfn=lnprobfn,
     # Make sure obs has required keys
     [obs.rectify() for obs in observations]
 
+    if (emcee) & (bool(nested_sampler)):
+        msg = ("Cannot run both emcee and nested fits "
+               "in a single call to fit_model")
+        raise(ValueError, msg)
+
     if (not bool(emcee)) & (not bool(nested_sampler)) & (not optimize):
         msg = ("No sampling or optimization routine "
                "specified by user; returning empty results")
         warnings.warn(msg)
 
-    output = {"optimization": (None, 0.),
-              "sampling": (None, 0.)}
+    output = {"optimization": None,
+              "sampling": None}
 
     if optimize:
         optres, topt, best = run_minimize(observations, model, sps,
@@ -204,7 +209,8 @@ def fit_model(observations, model, sps, lnprobfn=lnprobfn,
         run_sampler = run_ensemble
     elif nested_sampler:
         run_sampler = run_nested
-        kwargs["fitter"] = nested_sampler
+        # put nested_sampler back into kwargs for lower level functions
+        kwargs["nested_sampler"] = nested_sampler
     else:
         return output
 
@@ -412,14 +418,20 @@ def run_ensemble(observations, model, sps, lnprobfn=lnprobfn,
         sampler, burn_loc0, burn_prob0 = out
         ts = time.time() - go
 
-    return sampler, ts
+    try:
+        sampler.duration = ts
+    except:
+        pass
+
+    return sampler
 
 
 def run_nested(observations, model, sps,
                lnprobfn=lnprobfn,
-               fitter="dynesty",
+               nested_sampler="dynesty",
                nested_nlive=1000,
                nested_neff=1000,
+               verbose=False,
                **kwargs):
     """Thin wrapper on :py:class:`prospect.fitting.nested.run_nested_sampler`
 
@@ -457,18 +469,16 @@ def run_nested(observations, model, sps,
     likelihood = wrap_lnp(lnprobfn, observations, model, sps, nested=True)
 
     # which keywords do we have for this fitter?
-    ns_kwargs, nr_kwargs = parse_nested_kwargs(fitter=fitter,
-                                               **kwargs)
+    ns_kwargs, nr_kwargs = parse_nested_kwargs(nested_sampler=nested_sampler,**kwargs)
 
-    go = time.time()
     output = run_nested_sampler(model,
                                 likelihood,
-                                fitter=fitter,
-                                verbose=False,
+                                nested_sampler=nested_sampler,
+                                verbose=verbose,
                                 nested_nlive=nested_nlive,
                                 nested_neff=nested_neff,
                                 nested_sampler_kwargs=ns_kwargs,
                                 nested_run_kwargs=nr_kwargs)
-    ts = time.time() - go
+    info, result_obj = output
 
-    return output, ts
+    return info
diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index 80083e34..3b467bf8 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -1,35 +1,34 @@
 import time
 import numpy as np
 
-
 __all__ = ["run_nested_sampler", "parse_nested_kwargs"]
 
 
-def parse_nested_kwargs(fitter=None, **kwargs):
+def parse_nested_kwargs(nested_sampler=None, **kwargs):
 
-    # todo:
+    # TODO:
     #   something like 'enlarge'
     #   something like 'bootstrap' or N_networks or?
 
     sampler_kwargs = {}
     run_kwargs = {}
 
-    if fitter == "dynesty":
+    if nested_sampler == "dynesty":
         sampler_kwargs["bound"] = kwargs["nested_bound"]
-        sampler_kwargs["method"] = kwargs["nested_sample"]
+        sampler_kwargs["sample"] = kwargs["nested_sample"]
         sampler_kwargs["walks"] = kwargs["nested_walks"]
         run_kwargs["dlogz_init"] = kwargs["nested_dlogz"]
 
-    elif fitter == "ultranest":
+    elif nested_sampler == "ultranest":
         #run_kwargs["dlogz"] = kwargs["nested_dlogz"]
         pass
 
-    elif fitter == "nautilus":
+    elif nested_sampler == "nautilus":
         pass
 
     else:
         # say what?
-        raise ValueError(f"{fitter} not a valid fitter")
+        raise ValueError(f"{nested_sampler} not a valid fitter")
 
     return sampler_kwargs, run_kwargs
 
@@ -37,7 +36,7 @@ def parse_nested_kwargs(fitter=None, **kwargs):
 
 def run_nested_sampler(model,
                        likelihood_function,
-                       fitter="dynesty",
+                       nested_sampler="dynesty",
                        nested_nlive=1000,
                        nested_neff=1000,
                        verbose=False,
@@ -45,29 +44,41 @@ def run_nested_sampler(model,
                        nested_sampler_kwargs={}):
     """We give a model -- parameter discription and prior transform -- and a
     likelihood function. We get back samples, weights, and likelihood values.
+
+    Returns
+    -------
+    samples : 3-tuple of ndarrays (loc, logwt, loglike)
+        Loctions, log-weights, and log-likelihoods for the samples
+
+    obj : Object
+        The sampling object.  This will depend on the nested sampler being used.
     """
 
     go = time.time()
 
     # --- Nautilus ---
-    if fitter == "nautilus":
+    if nested_sampler == "nautilus":
         from nautilus import Sampler
 
         sampler = Sampler(model.prior_transform,
                           likelihood_function,
+                          n_dim=model.ndim,
                           pass_dict=False, # likelihood expects array, not dict
                           n_live=nested_nlive,
                           **nested_sampler_kwargs)
         sampler.run(n_eff=nested_neff,
                     verbose=verbose,
                     **nested_run_kwargs)
+        obj = sampler
+
         points, log_w, log_like = sampler.posterior()
 
     # --- Ultranest ---
-    if fitter == "ultranest":
+    if nested_sampler == "ultranest":
 
         from ultranest import ReactiveNestedSampler
-        sampler = ReactiveNestedSampler(model.theta_labels,
+        parameter_names = model.theta_labels()
+        sampler = ReactiveNestedSampler(parameter_names,
                                         likelihood_function,
                                         model.prior_transform,
                                         **nested_sampler_kwargs)
@@ -75,13 +86,14 @@ def run_nested_sampler(model,
                              min_num_live_points=nested_nlive,
                              show_status=verbose,
                              **nested_run_kwargs)
+        obj = result
 
         points = np.array(result['weighted_samples']['points'])
         log_w = np.log(np.array(result['weighted_samples']['weights']))
         log_like = np.array(result['weighted_samples']['logl'])
 
     # --- Dynesty ---
-    if fitter == "dynesty":
+    if nested_sampler == "dynesty":
         from dynesty import DynamicNestedSampler
 
         sampler = DynamicNestedSampler(likelihood_function,
@@ -92,18 +104,20 @@ def run_nested_sampler(model,
         sampler.run_nested(n_effective=nested_neff,
                            print_progress=verbose,
                            **nested_run_kwargs)
+        obj = sampler
 
         points = sampler.results["samples"]
         log_w = sampler.results["logwt"]
         log_like = sampler.results["logl"]
 
     # --- Nestle ---
-    if fitter == "nestle":
+    if nested_sampler == "nestle":
         import nestle
         result = nestle.sample(likelihood_function,
                                model.prior_transform,
                                model.ndim,
                                **nested_sampler_kwargs)
+        obj = result
 
         points = result["samples"]
         log_w = result["logwt"]
@@ -111,12 +125,11 @@ def run_nested_sampler(model,
 
     dur = time.time() - go
 
-    return dict(points=points, log_weight=log_w, log_like=log_like)
+    return dict(points=points, log_weight=log_w, log_like=log_like, duration=dur), obj
 
 
 # OMG
-SAMPLER_KWARGS = {
-
+NESTED_KWARGS = {
 "dynesty_sampler_kwargs" : dict(nlive=None,
                                 bound='multi',
                                 sample='auto',
diff --git a/prospect/io/write_results.py b/prospect/io/write_results.py
index 79743d10..ad08cfb1 100644
--- a/prospect/io/write_results.py
+++ b/prospect/io/write_results.py
@@ -70,41 +70,43 @@ def paramfile_string(param_file=None, **extras):
     return pstr
 
 
-
-def write_hdf5(hfile, run_params, model, obs,
-               sampler=None,
-               optimize_result_list=None,
-               tsample=0.0, toptimize=0.0,
-               sampling_initial_center=[],
+def write_hdf5(hfile,
+               config={},
+               model=None,
+               obs=None,
+               sampling_result=None,
+               optimize_result_tuple=None,
                write_model_params=True,
-               sps=None, **extras):
+               sps=None,
+               **extras):
     """Write output and information to an HDF5 file object (or
     group).
 
-    :param hfile:
+    hfile : string or `h5py.File`
         File to which results will be written.  Can be a string name or an
         `h5py.File` object handle.
 
-    :param run_params:
+    run_params : dict-like
         The dictionary of arguments used to build and fit a model.
 
-    :param model:
-        The `prospect.models.SedModel` object.
+    model : Instance of :py:class:`prospect.models.SpecModel`
+        The  object.
 
-    :param obs:
-        The dictionary of observations that were fit.
+    obs : list of Observation() instances
+        The observations that were fit.
 
-    :param sampler:
-        The `emcee` or `dynesty` sampler object used to draw posterior samples.
-        Can be `None` if only optimization was performed.
+    sampling_result : EnsembleSampler() or dict
+        The `emcee` sampler used to draw posterior samples or nested sampler
+        output. Can be `None` if only optimization was performed.
 
-    :param optimize_result_list:
+    optimize_result_tuple : 2-tuple of (list, float)
         A list of `scipy.optimize.OptimizationResult` objects generated during
-        the optimization stage.  Can be `None` if no optimization is performed
+        the optimization stage, and a float giving the duration of sampling. Can
+        be `None` if no optimization is performed
 
-    param sps: (optional, default: None)
+    sps : instance of :py:class:`prospect.sources.SSPBasis` (optional, default: None)
         If a `prospect.sources.SSPBasis` object is supplied, it will be used to
-        generate and store
+        generate and store best fit values (not implemented)
     """
     # If ``hfile`` is not a file object, assume it is a filename and open
     if isinstance(hfile, str):
@@ -112,12 +114,15 @@ def write_hdf5(hfile, run_params, model, obs,
     else:
         hf = hfile
 
+    assert (model is not None), "Must pass a prospector model"
+    run_params = config
+
     # ----------------------
     # Sampling info
     if run_params.get("emcee", False):
-        chain, extras = emcee_to_struct(sampler, model)
-    elif run_params.get("nested", False):
-        chain, extras = nested_to_struct(sampler, model)
+        chain, extras = emcee_to_struct(sampling_result, model)
+    elif bool(run_params.get("nested_sampler", False)):
+        chain, extras = nested_to_struct(sampling_result, model)
     else:
         chain, extras = None, None
     write_sampling_h5(hf, chain, extras)
@@ -125,8 +130,9 @@ def write_hdf5(hfile, run_params, model, obs,
 
     # ----------------------
     # Observational data
-    write_obs_to_h5(hf, obs)
-    hf.flush()
+    if obs is not None:
+        write_obs_to_h5(hf, obs)
+        hf.flush()
 
     # ----------------------
     # High level parameter and version info
@@ -134,15 +140,15 @@ def write_hdf5(hfile, run_params, model, obs,
     for k, v in meta.items():
         hf.attrs[k] = v
     hf.flush()
-    hf.attrs['sampling_duration'] = json.dumps(tsample)
 
     # -----------------
     # Optimizer info
-    hf.attrs['optimizer_duration'] = json.dumps(toptimize)
-    if optimize_result_list is not None:
-        out = optresultlist_to_ndarray(optimize_result_list)
-        mgroup = hf.create_group('optimization')
-        mdat = mgroup.create_dataset('optimizer_results', data=out)
+    if optimize_result_tuple is not None:
+        optimize_list, toptimize = optimize_result_tuple
+        optarr = optresultlist_to_ndarray(optimize_list)
+        opt = hf.create_group('optimization')
+        _ = opt.create_dataset('optimizer_results', data=optarr)
+        opt.attrs["optimizer_duration"] = json.dumps(toptimize)
 
     # ---------------
     # Best fitting model in space of data
@@ -151,7 +157,7 @@ def write_hdf5(hfile, run_params, model, obs,
             pass
             #from ..plotting.utils import best_sample
             #pbest = best_sample(hf["sampling"])
-            #spec, phot, mfrac = model.predict(pbest, obs=obs, sps=sps)
+            #predictions, mfrac = model.predict(pbest, obs=obs, sps=sps)
             #best = hf.create_group("bestfit")
             #best.create_dataset("spectrum", data=spec)
             #best.create_dataset("photometry", data=phot)
@@ -168,6 +174,8 @@ def write_hdf5(hfile, run_params, model, obs,
 
 
 def metadata(run_params, model, write_model_params=True):
+    """Generate a metadata dictionary, with serialized entries.
+    """
     meta = dict(run_params=run_params,
                 paramfile_text=paramfile_string(**run_params))
     if write_model_params:
@@ -188,14 +196,16 @@ def emcee_to_struct(sampler, model):
     # preamble
     samples = sampler.get_chain(flat=True)
     lnprior = model.prior_product(samples)
+    lnpost = sampler.get_log_prob(flat=True)
 
     # chaincat & extras
     chaincat = chain_to_struct(samples, model=model)
     extras = dict(weights=None,
-                  lnprobability=sampler.get_log_prob(flat=True),
-                  lnlike=sampler.get_log_prob(flat=True) - lnprior,
+                  lnprobability=lnpost,
+                  lnlike=lnpost - lnprior,
                   acceptance=sampler.acceptance_fraction,
-                  rstate=sampler.random_state)
+                  rstate=sampler.random_state,
+                  duration=sampler.getattr("duration", 0.0))
 
     return chaincat, extras
 
@@ -208,7 +218,8 @@ def nested_to_struct(nested_out, model):
     chaincat = chain_to_struct(nested_out['points'], model=model)
     extras = dict(weights=np.exp(nested_out['log_weight']),
                   lnprobability=nested_out['log_like'] + lnprior,
-                  lnlike=nested_out['log_like']
+                  lnlike=nested_out['log_like'],
+                  duration=nested_out.get("duration", 0.0)
                   )
     return chaincat, extras
 
diff --git a/tests/tests_samplers.py b/tests/tests_samplers.py
new file mode 100644
index 00000000..6bf59582
--- /dev/null
+++ b/tests/tests_samplers.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+import numpy as np
+
+#import pytest
+
+from prospect.utils.prospect_args import get_parser
+from prospect.sources import CSPSpecBasis
+from prospect.models import SpecModel, templates
+from prospect.observation import Photometry
+from prospect.fitting import fit_model
+from prospect.fitting.nested import parse_nested_kwargs
+from prospect.io.write_results import write_hdf5
+
+
+#@pytest.fixture
+def get_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+def build_model(add_neb=False, add_outlier=False):
+    model_params = templates.TemplateLibrary["parametric_sfh"]
+    model_params["logzsol"]["isfree"] = False  # built for speed
+    if add_neb: # skip for speed
+        model_params.update(templates.TemplateLibrary["nebular"])
+    if add_outlier:
+        model_params.update(templates.TemplateLibrary["outlier_model"])
+        model_params["f_outlier_phot"]["isfree"] = True
+        model_params["f_outlier_phot"]["init"] = 0.05
+    return SpecModel(model_params)
+
+
+def build_obs(**kwargs):
+
+    from astroquery.sdss import SDSS
+    from astropy.coordinates import SkyCoord
+    bands = "ugriz"
+    mcol = [f"cModelMag_{b}" for b in bands]
+    ecol = [f"cModelMagErr_{b}" for b in bands]
+    cat = SDSS.query_crossid(SkyCoord(ra=204.46376, dec=35.79883, unit="deg"),
+                             data_release=16,
+                             photoobj_fields=mcol + ecol + ["specObjID"])
+    shdus = SDSS.get_spectra(plate=2101, mjd=53858, fiberID=220)[0]
+    assert int(shdus[2].data["SpecObjID"][0]) == cat[0]["specObjID"]
+
+    fnames = [f"sdss_{b}0" for b in bands]
+    maggies = np.array([10**(-0.4 * cat[0][f"cModelMag_{b}"]) for b in bands])
+    magerr = np.array([cat[0][f"cModelMagErr_{b}"] for b in bands])
+    magerr = np.hypot(magerr, 0.05)
+
+    phot = Photometry(filters=fnames, flux=maggies, uncertainty=magerr*maggies/1.086,
+                      name=f'sdss_phot_specobjID{cat[0]["specObjID"]}')
+
+    obslist = [phot]
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+if __name__ == "__main__":
+
+    parser = get_parser()
+    parser.set_defaults(nested_target_n_effective=256,
+                        verbose=0)
+    args = parser.parse_args()
+    run_params = vars(args)
+    run_params["parameter_file"] = __file__
+
+    # test the parsing
+    run_params["nested_sampler"] = "dynesty"
+    nr, ns = parse_nested_kwargs(**run_params)
+    print(nr)
+    print(ns)
+
+    # build stuff
+    model = build_model()
+    obs = build_obs()
+    sps = get_sps()
+
+    # do a first model caching
+    (phot,), mfrac = model.predict(model.theta, obs, sps=sps)
+    print(model)
+
+    # loop over samplers
+    results = {}
+    samplers = ["nautilus", "ultranest", "dynesty"]
+    for sampler in samplers:
+        print(sampler)
+        run_params["nested_sampler"] = sampler
+        out = fit_model(obs, model, sps, **run_params)
+        results[sampler] = out["sampling"]
+        hfile = f"./{sampler}_test.h5"
+        write_hdf5(hfile,
+                   run_params,
+                   model,
+                   obs,
+                   results[sampler],
+                   None,
+                   sps=sps)
+
+    for sampler in samplers:
+        print(sampler, results[sampler]["duration"])
+
+
+    colors = ["royalblue", "darkorange", "firebrick"]
+    import matplotlib.pyplot as pl
+    from prospect.plotting import corner
+    ndim = model.ndim
+    cfig, axes = pl.subplots(ndim, ndim, figsize=(10,9))
+    for sampler, color in zip(samplers, colors):
+        out = results[sampler]
+        axes = corner.allcorner(out["points"].T,
+                                model.theta_labels(),
+                                axes,
+                                color=color,
+                                weights= np.exp(out["log_weight"]),
+                                show_titles=True)
\ No newline at end of file

From 4da9a264cff7ef648c179094554b070de4231798 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 28 Aug 2024 17:22:58 -0400
Subject: [PATCH 112/132] propagate n_eff properly; have test output produce
 files from which models can be read.

---
 prospect/fitting/fitting.py | 11 +++++++++--
 prospect/fitting/nested.py  |  2 ++
 tests/tests_samplers.py     | 14 +++++++++-----
 3 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index 70e8cf34..aa4c0a22 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -430,7 +430,7 @@ def run_nested(observations, model, sps,
                lnprobfn=lnprobfn,
                nested_sampler="dynesty",
                nested_nlive=1000,
-               nested_neff=1000,
+               nested_target_n_effective=1000,
                verbose=False,
                **kwargs):
     """Thin wrapper on :py:class:`prospect.fitting.nested.run_nested_sampler`
@@ -454,6 +454,13 @@ def run_nested(observations, model, sps,
         ``model``, and ``sps`` as keywords. By default use the
         :py:func:`lnprobfn` defined above.
 
+    nested_target_n_effective : int
+        Target number of effective samples
+
+    nested_nlive : int
+        Number of live points for the nested sampler.  Meaning somewhat
+        dependent on the chosen sampler
+
     Returns
     --------
     result: Dictionary
@@ -476,7 +483,7 @@ def run_nested(observations, model, sps,
                                 nested_sampler=nested_sampler,
                                 verbose=verbose,
                                 nested_nlive=nested_nlive,
-                                nested_neff=nested_neff,
+                                nested_neff=nested_target_n_effective,
                                 nested_sampler_kwargs=ns_kwargs,
                                 nested_run_kwargs=nr_kwargs)
     info, result_obj = output
diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index 3b467bf8..f0f25185 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -53,6 +53,8 @@ def run_nested_sampler(model,
     obj : Object
         The sampling object.  This will depend on the nested sampler being used.
     """
+    if verbose:
+        print(f"running {nested_sampler} for {nested_neff} effective samples")
 
     go = time.time()
 
diff --git a/tests/tests_samplers.py b/tests/tests_samplers.py
index 6bf59582..8c47d85f 100644
--- a/tests/tests_samplers.py
+++ b/tests/tests_samplers.py
@@ -13,15 +13,15 @@
 from prospect.fitting import fit_model
 from prospect.fitting.nested import parse_nested_kwargs
 from prospect.io.write_results import write_hdf5
-
+from prospect.io.read_results import results_from
 
 #@pytest.fixture
-def get_sps():
+def get_sps(**kwargs):
     sps = CSPSpecBasis(zcontinuous=1)
     return sps
 
 
-def build_model(add_neb=False, add_outlier=False):
+def build_model(add_neb=False, add_outlier=False, **kwargs):
     model_params = templates.TemplateLibrary["parametric_sfh"]
     model_params["logzsol"]["isfree"] = False  # built for speed
     if add_neb: # skip for speed
@@ -63,10 +63,11 @@ def build_obs(**kwargs):
 
     parser = get_parser()
     parser.set_defaults(nested_target_n_effective=256,
+                        nested_nlive=512,
                         verbose=0)
     args = parser.parse_args()
     run_params = vars(args)
-    run_params["parameter_file"] = __file__
+    run_params["param_file"] = __file__
 
     # test the parsing
     run_params["nested_sampler"] = "dynesty"
@@ -99,11 +100,14 @@ def build_obs(**kwargs):
                    results[sampler],
                    None,
                    sps=sps)
+        ires, iobs, im = results_from(hfile)
+        assert (im is not None)
 
+    # compare runtime
     for sampler in samplers:
         print(sampler, results[sampler]["duration"])
 
-
+    # compare posteriors
     colors = ["royalblue", "darkorange", "firebrick"]
     import matplotlib.pyplot as pl
     from prospect.plotting import corner

From 31167bc35b1885466e7892f74b1bf7d246bc135d Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 28 Aug 2024 18:01:27 -0400
Subject: [PATCH 113/132] [ci skip] update readme.

---
 README.md | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 214e68c6..fe0914e7 100644
--- a/README.md
+++ b/README.md
@@ -21,15 +21,16 @@ Work to do includes:
 - [x] Update demo scripts
 - [x] Account for undersampled spectra via explicit rebinning.
 - [ ] Account for undersampled spectra via a square convolution in pixel space.
+- [x] Implement UltraNest and Nautilus backends
+- [x] Test i/o with structured arrays
+- [ ] Structured ndarray for derived parameters
+- [ ] Store samples of spectra, photometry, and mfrac (blobs)
 - [ ] Update notebooks
 - [ ] Update plotting module
-- [ ] Test i/o with structured arrays
 - [ ] Test multi-spectral calibration, smoothing, and noise modeling
 - [ ] Test smoothing accounting for library, instrumental & physical smoothing
-- [ ] Structured ndarray for derived parameters
-- [ ] Store samples of spectra, photometry, and mfrac (blobs)
 - [ ] Implement an emulator-based SpecModel class
-- [ ] Implement UltraNest and Nautilus backends
+
 
 
 Migration from < v2.0
@@ -58,19 +59,28 @@ It is recommended to do the conversion within the `build_obs()` method, if
 possible. This list of observations is then supplied to `fit_model`.  Because
 noise models are now attached explicitly to each observation, they do not need
 to be generated separately or supplied to `fit_model()`, which no longer accepts
-a `noise=` argument.
+a `noise=` argument.  For outlier models, the the noise model should be
+instantiated with names for the outlier model that correspond to fixed or free
+parameters of the model.
 
 ```py
 from prospect.fitting import fit_model
 output = fit_model(observations, model, sps, **config)
 ```
 
-Another change is that spectral response functions (i.e. calibration vectors) are now handled by specialized sub-classes of these `Observation` classes.  See the [spectroscopy docs](docs/spectra.rst) for details.
+Another change is that spectral response functions (i.e. calibration vectors)
+are now handled by specialized sub-classes of these `Observation` classes.  See
+the [spectroscopy docs](docs/spectra.rst) for details.
+
+The interface to `write_model` has been changed and simplified.  See
+[usage](docs/usage.rst) for details.
 
 Finally, the output chain or samples is now stored as a structured array, where
 each row corresponds to a sample, and each column is a parameter (possibly
 multidimensional).  Additional information (such as sample weights, likelihoods,
-and poster probabilities) are stored as additional datasets in the output.
+and poster probabilities) are stored as additional datasets in the output.  The
+`unstructured_chain` dataset of the output contains an old-style simple
+`numpy.ndarray` of shape `(nsample, ndim)`
 
 
 Purpose

From dfb367507ad31b3db320b64adafc94398f12d3af Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Wed, 28 Aug 2024 18:16:53 -0400
Subject: [PATCH 114/132] [ci skip] fix readme links.

---
 README.md                               |  4 ++--
 demo/demo_mock_params.py                | 13 ++++++++-----
 demo/demo_mpi_params.py                 | 14 +++++++++-----
 demo/timing.py => tests/timing_basis.py | 18 +++++++++---------
 tests/{timing.py => timing_fsps.py}     |  0
 5 files changed, 28 insertions(+), 21 deletions(-)
 rename demo/timing.py => tests/timing_basis.py (97%)
 rename tests/{timing.py => timing_fsps.py} (100%)

diff --git a/README.md b/README.md
index fe0914e7..57a95449 100644
--- a/README.md
+++ b/README.md
@@ -70,10 +70,10 @@ output = fit_model(observations, model, sps, **config)
 
 Another change is that spectral response functions (i.e. calibration vectors)
 are now handled by specialized sub-classes of these `Observation` classes.  See
-the [spectroscopy docs](docs/spectra.rst) for details.
+the [spectroscopy docs](doc/spectra.rst) for details.
 
 The interface to `write_model` has been changed and simplified.  See
-[usage](docs/usage.rst) for details.
+[usage](doc/usage.rst) for details.
 
 Finally, the output chain or samples is now stored as a structured array, where
 each row corresponds to a sample, and each column is a parameter (possibly
diff --git a/demo/demo_mock_params.py b/demo/demo_mock_params.py
index 1647ff3a..a8cbea57 100644
--- a/demo/demo_mock_params.py
+++ b/demo/demo_mock_params.py
@@ -92,7 +92,7 @@ def build_obs(snr=10.0, filterset=["sdss_g0", "sdss_r0"],
     :param add_noise: (optional, boolean, default: True)
         If True, add a realization of the noise to the mock spectrum
     """
-    from prospect.data.observation import Photometry, Spectrum
+    from prospect.observation import Photometry, Spectrum
 
     # We'll put the mock data in this dictionary, just as we would for real
     # data.  But we need to know which bands (and wavelengths if doing
@@ -228,13 +228,16 @@ def build_all(config):
     output = fit_model(obs, model, sps, **config)
 
     print("writing to {}".format(hfile))
-    writer.write_hdf5(hfile, run_params, model, obs,
-                      output["sampling"][0], output["optimization"][0],
-                      tsample=output["sampling"][1],
-                      toptimize=output["optimization"][1],
+    writer.write_hdf5(hfile,
+                      config,
+                      model,
+                      obs,
+                      output["sampling"],
+                      output["optimization"],
                       sps=sps
                       )
 
+
     try:
         hfile.close()
     except(AttributeError):
diff --git a/demo/demo_mpi_params.py b/demo/demo_mpi_params.py
index 8660e967..b8f6b7db 100644
--- a/demo/demo_mpi_params.py
+++ b/demo/demo_mpi_params.py
@@ -351,11 +351,15 @@ def build_all(**kwargs):
 
 
     hfile = "{0}_{1}_mcmc.h5".format(args.outfile, int(time.time()))
-    writer.write_hdf5(hfile, run_params, model, obs,
-                      output["sampling"][0], output["optimization"][0],
-                      tsample=output["sampling"][1],
-                      toptimize=output["optimization"][1],
-                      sps=sps)
+    writer.write_hdf5(hfile,
+                      run_params,
+                      model,
+                      obs,
+                      output["sampling"],
+                      output["optimization"],
+                      sps=sps
+                      )
+
 
     try:
         hfile.close()
diff --git a/demo/timing.py b/tests/timing_basis.py
similarity index 97%
rename from demo/timing.py
rename to tests/timing_basis.py
index a130c4db..49054949 100644
--- a/demo/timing.py
+++ b/tests/timing_basis.py
@@ -40,12 +40,12 @@ def make_agebins(nbin=5, minage=7.0, **extras):
     allages = np.linspace(minage, np.log10(tuniv), nbin)
     allages = np.insert(allages, 0, 0.)
     agebins = np.array([allages[:-1], allages[1:]]).T
-    return agebins    
+    return agebins
 
 
 
 if __name__ == "__main__":
-    
+
     step_params = {'agebins':[[]],
                    'mass': [],
                    'tage': np.array([13.7]),
@@ -63,8 +63,8 @@ def make_agebins(nbin=5, minage=7.0, **extras):
     zlist = [1, 2]
     nlist = [False, True]
 
-    print("Using {} isochrones and {} spectra.\nAsking for single ages.".format(*libs)) 
-    
+    print("Using {} isochrones and {} spectra.\nAsking for single ages.".format(*libs))
+
     # FSPS
     string = "StellarPopulation takes {:7.5f}s per call {} nebular emission and zcontinuous={}."
     params = deepcopy(csp_params)
@@ -84,7 +84,7 @@ def make_agebins(nbin=5, minage=7.0, **extras):
             sps = CSPBasis(zcontinuous=zcont)
             dur = call_duration(sps, ntry, add_neb_emission=[neb], **params)
             print(string.format(dur, w[int(neb)], zcont))
-            
+
     # Step SFH
     nbin = 10
 
@@ -92,7 +92,7 @@ def make_agebins(nbin=5, minage=7.0, **extras):
     params['agebins'] = make_agebins(nbin)
     params['mass'] = np.ones(nbin) * 1.0
     string = "FastStepBasis ({} bins) takes {:7.5f}s per call {} nebular emission and zcontinuous={}."
-    
+
     for zcont in zlist:
         print("\n")
         for neb in nlist:
@@ -101,12 +101,12 @@ def make_agebins(nbin=5, minage=7.0, **extras):
             #print(sps.params, sps.ssp.params['add_neb_emission'])
             print(string.format(nbin, dur, w[int(neb)], zcont))
 
-    
 
-    
+
+
    # sys.exit()
 
-    
+
     # Now time calls for random Z (which always causes dirtiness=1)
     #setup = "from __main__ import test; import numpy as np"
     #call = "out=get_model(sps, logzsol=[np.random.uniform(-1, 0)], **params)"
diff --git a/tests/timing.py b/tests/timing_fsps.py
similarity index 100%
rename from tests/timing.py
rename to tests/timing_fsps.py

From 40e2614fc3639cf639169b5a754765fa4ac958c2 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Fri, 30 Aug 2024 19:46:55 -0400
Subject: [PATCH 115/132] fixes, test, and docs for Lines prediction.

---
 doc/dataformat.rst                  | 66 ++++++++++++++++-------------
 prospect/io/read_results.py         |  5 ++-
 prospect/models/sedmodel.py         |  2 +-
 prospect/observation/observation.py | 56 +++++++++++++++---------
 tests/test_predict.py               | 43 ++++++++++++++++---
 5 files changed, 113 insertions(+), 59 deletions(-)

diff --git a/doc/dataformat.rst b/doc/dataformat.rst
index 29051163..1bba2862 100644
--- a/doc/dataformat.rst
+++ b/doc/dataformat.rst
@@ -9,13 +9,16 @@ The `Observation` class
 returned by :py:meth:`build_obs` (see below). Each Observation instance
 corresponds to a single dataset, and is basically a namespace that also supports
 dict-like accessing of important attributes.  In addition to holding data and
-uncertainties thereon, they tell prospector what data to predict, contain
+uncertainties thereon, they tell |Codename| what data to predict, contain
 dataset-specific information for how to predict that data, and can even store
 methods for computing likelihoods in the case of complicated, dataset-specific
-noise models. There are two fundamental kinds of data, `Photometry` and
-`Spectrum` that are each subclasses of `Observation`. There is also also a
-`Lines` class for integrated emission line fluxes. They have the following
-attributes, most of which can also be accessed as dictionary keys.
+noise models.
+
+There are two fundamental kinds of data, :py:class:`Photometry` and
+:py:class:`Spectrum` that are each sub-classes of :py:class:`Observation`. There
+is also also a :py:class:`Lines` class for integrated emission line fluxes. They
+have the following attributes, most of which can also be accessed as dictionary
+keys:
 
 
 - ``wavelength``
@@ -24,32 +27,35 @@ attributes, most of which can also be accessed as dictionary keys.
     Generally these should be observed frame wavelengths.
 
 - ``flux``
-    The flux vector for a `Spectrum`, or the broadband fluxes for `Photometry`
-    ndarray of same length as the wavelength vector. For `Photometry` the units
-    are *maggies*. Maggies are a linear flux density unit  defined as
-    :math:`{\rm maggie} = 10^{-0.4 \, m_{AB}}` where :math:`m_{AB}` is the AB
-    apparent magnitude. That is, 1 maggie is the flux density in Janskys divided
-    by 3631. If absolute spectrophotometry is available, the units for a
-    `Spectrum`` should also be maggies, otherwise photometry must be present and
-    a calibration vector must be supplied or fit.  Note that for convenience
-    there is a `maggies_to_nJy` attribute of `Observation` that gives the
-    conversion factor.
+    The flux vector for a :py:class:`Spectrum`, or the broadband fluxes for
+    :py:class:`Photometry` ndarray of same length as the wavelength vector.
+
+    For `Photometry` the units are *maggies*. Maggies are a linear flux density
+    unit  defined as :math:`{\rm maggie} = 10^{-0.4 \, m_{AB}}` where
+    :math:`m_{AB}` is the AB apparent magnitude. That is, 1 maggie is the flux
+    density in Janskys divided by 3631. If absolute spectrophotometry is
+    available, the units for a :py:class:`Spectrum`` should also be maggies,
+    otherwise photometry must be present and a calibration vector must be
+    supplied or fit.  Note that for convenience there is a `maggies_to_nJy`
+    attribute of `Observation` that gives the conversion factor. For
+    :py:class:`Lines`, the units should be erg/s/cm^2
 
 - ``uncertainty``
     The uncertainty vector (sigma), in same units as ``flux``, ndarray of same
     length as the wavelength vector.
 
 - ``mask``
-   A boolean array of same length as the wavelength vector, where ``False``
-   elements are ignored in the likelihood calculation.
+    A boolean array of same length as the wavelength vector, where ``False``
+    elements are ignored in the likelihood calculation.
 
 - ``filters``
-   For a `Photometry`, this is a list of strings corresponding to filter names
-   in `sedpy <https://github.com/bd-j/sedpy>`_
+    For a `Photometry`, this is a list of strings corresponding to filter names
+    in `sedpy <https://github.com/bd-j/sedpy>`_
 
 - ``line_ind``
-  For a `Lines` instance, the (zero-based) index of the emission line in the
-  FSPS emission line table.
+    For a `Lines` instance, the (zero-based) index of the emission line in the
+    FSPS emission line
+    `table <https://github.com/cconroy20/fsps/blob/master/data/emlines_info.dat>`_
 
 In addition to these attributes, several additional aspects of an observation
 are used to help predict data or to compute likelihoods.  The latter is
@@ -57,18 +63,18 @@ particularly important in the case of complicated noise models, including outlie
 models, jitter terms, or covariant noise.
 
 - ``name``
-  A string that can be used to identify the dataset.  This can be useful for
-  dataset-specfic parameters.  By default the name is constructed from the
-  `kind` and the memory location of the object.
+    A string that can be used to identify the dataset.  This can be useful for
+    dataset-specfic parameters.  By default the name is constructed from the
+    `kind` and the memory location of the object.
 
 - ``resolution``
-   For a `Spectrum` this defines the instrumental resolution.  Analagously to
-   the ``filters`` attribute for `Photometry`, this knowledge is used to
-   accurately predict the model in the space of the data.
+    For a `Spectrum` this defines the instrumental resolution.  Analagously to
+    the ``filters`` attribute for `Photometry`, this knowledge is used to
+    accurately predict the model in the space of the data.
 
-- ``noise`` A :py:class:`NoiseModel` instance.  By default this implements a
-  simple chi-square calculation of independent noise, but it can be
-  complexified.
+- ``noise``
+    A :py:class:`NoiseModel` instance.  By default this implements a simple
+    chi-square calculation of independent noise, but it can be complexified.
 
 
 Example
diff --git a/prospect/io/read_results.py b/prospect/io/read_results.py
index 0e9dac33..c4dd3e5c 100644
--- a/prospect/io/read_results.py
+++ b/prospect/io/read_results.py
@@ -185,7 +185,10 @@ def read_hdf5(filename, **extras):
         res["optimization"] = groups["optimization"]
         # do observations
         if 'observations' in hf:
-            obs = obs_from_h5(hf['observations'])
+            try:
+                obs = obs_from_h5(hf['observations'])
+            except:
+                obs = None
         else:
             obs = None
 
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index b7e73477..6a30764d 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -369,7 +369,7 @@ def predict_lines(self, obs, **extras):
         # find the indices of the observed emission lines
         #dw = np.abs(self._ewave_obs[:, None] - self._outwave[None, :])
         #self._predicted_line_inds = np.argmin(dw, axis=0)
-        self._predicted_line_inds = obs.get("line_ind")
+        self._predicted_line_inds = obs["line_inds"]
         self._speccal = 1.0
 
         self.line_norm = self.flux_norm() / (1 + self._zred) * (3631*jansky_cgs)
diff --git a/prospect/observation/observation.py b/prospect/observation/observation.py
index 60f916c3..0062db13 100644
--- a/prospect/observation/observation.py
+++ b/prospect/observation/observation.py
@@ -100,17 +100,19 @@ def rectify(self):
         appropriate sizes.  Also auto-masks non-finite data or negative
         uncertainties.
         """
+        n = self.__repr__
         if self.flux is None:
-            print(f"{self.__repr__} has no data")
+            print(f"{n} has no data")
             return
 
-        assert self.wavelength.ndim == 1, "`wavelength` is not 1-d array"
-        assert self.flux.ndim == 1, "flux is not a 1d array"
-        assert self.uncertainty.ndim == 1, "uncertainty is not a 1d array"
-        assert self.ndata > 0, "no wavelength points supplied!"
-        assert self.uncertainty is not None, "No uncertainties."
-        assert len(self.wavelength) == len(self.flux), "Flux array not same shape as wavelength."
-        assert len(self.wavelength) == len(self.uncertainty), "Uncertainty array not same shape as wavelength."
+        assert self.flux.ndim == 1, f"{n}: flux is not a 1d array"
+        assert self.uncertainty.ndim == 1, f"{n}: uncertainty is not a 1d array"
+        assert self.ndata > 0, f"{n} no data supplied!"
+        assert self.uncertainty is not None, f"{n} No uncertainties."
+        assert len(self.flux) == len(self.uncertainty), f"{n}: flux and uncertainty of different length"
+        if self.wavelength is not None:
+            assert self.wavelength.ndim == 1, f"{n}: `wavelength` is not 1-d array"
+            assert len(self.wavelength) == len(self.flux), f"{n}: Wavelength array not same shape as flux array"
 
         self._automask()
 
@@ -145,10 +147,10 @@ def ndof(self):
     @property
     def ndata(self):
         # TODO: cache this?
-        if self.wavelength is None:
+        if self.flux is None:
             return 0
         else:
-            return len(self.wavelength)
+            return len(self.flux)
 
     @property
     def wave_min(self):
@@ -240,7 +242,7 @@ def __init__(self, filters=[],
             The names or instances of Filters to use
 
         flux : iterable of floats
-            The flux through the filters, in units of maggies
+            The flux through the filters, in units of maggies.
 
         uncertainty : iterable of floats
             The uncertainty on the flux
@@ -301,7 +303,6 @@ def __init__(self,
                  response=None,
                  name=None,
                  lambda_pad=100,
-                 polynomial_order=0.,
                  **kwargs):
 
         """
@@ -311,7 +312,8 @@ def __init__(self,
             The wavelength of each flux measurement, in vacuum AA
 
         flux : iterable of floats
-            The flux at each wavelength, in units of maggies, same length as ``wavelength``
+            The flux at each wavelength, in units of maggies, same length as
+            ``wavelength``
 
         uncertainty : iterable of floats
             The uncertainty on the flux
@@ -329,7 +331,7 @@ def __init__(self,
         self.resolution = resolution
         self.response = response
         self.instrument_smoothing_parameters = dict(smoothtype="vel", fftsmooth=True)
-        self.wavelength = wavelength
+        self.wavelength = np.atleast_1d(wavelength)
 
     @property
     def wavelength(self):
@@ -439,7 +441,6 @@ def instrumental_smoothing(self, model_wave_obsframe, model_flux, zred=0, libres
 
         return outspec_padded[self._unpadded_inds]
 
-
     def compute_response(self, **extras):
         if self.response is not None:
             return self.response
@@ -447,7 +448,7 @@ def compute_response(self, **extras):
             return 1.0
 
 
-class Lines(Spectrum):
+class Lines(Observation):
 
     _kind = "lines"
     alias = dict(spectrum="flux",
@@ -458,11 +459,12 @@ class Lines(Spectrum):
 
     _meta = ("name", "kind")
     _data = ("wavelength", "flux", "uncertainty", "mask",
-             "resolution", "calibration", "line_ind")
+             "line_ind")
 
     def __init__(self,
                  line_ind=None,
                  line_names=None,
+                 wavelength=None,
                  name=None,
                  **kwargs):
 
@@ -476,7 +478,8 @@ def __init__(self,
             The wavelength of each flux measurement, in vacuum AA
 
         flux : iterable of floats
-            The flux at each wavelength, in units of maggies, same length as ``wavelength``
+            The flux at each wavelength, in units of erg/s/cm^2, same length as
+            ``wavelength``
 
         uncertainty : iterable of floats
             The uncertainty on the flux
@@ -492,16 +495,25 @@ def __init__(self,
         :param calibration:
             not sure yet ....
         """
-        super(Lines, self).__init__(name=name, resolution=None, **kwargs)
+        super(Lines, self).__init__(name=name, **kwargs)
         assert (line_ind is not None), "You must identify the lines by their index in the FSPS emission line array"
-        self.line_ind = np.array(line_ind).as_type(int)
+        self.line_ind = np.array(line_ind).astype(int)
         self.line_names = line_names
 
+        if wavelength is not None:
+            self._wavelength = np.atleast_1d(wavelength)
+        else:
+            self._wavelength = None
+
+    @property
+    def wavelength(self):
+        return self._wavelength
+
 
 class UndersampledSpectrum(Spectrum):
     """
     As for Spectrum, but account for pixelization effects when pixels
-    undersamplesthe instrumental LSF.
+    undersample the instrumental LSF.
     """
     #TODO: Implement as a convolution with a square kernel (or sinc in frequency space)
 
@@ -754,6 +766,8 @@ def from_oldstyle(obs, **kwargs):
 
 
 def from_serial(arr, meta):
+    # TODO: This does not account for composite or special classes, or include
+    # noise models
     kind = obstypes[meta.pop("kind")]
 
     adict = {a:arr[a] for a in arr.dtype.names}
diff --git a/tests/test_predict.py b/tests/test_predict.py
index b474b4bc..7f57282f 100644
--- a/tests/test_predict.py
+++ b/tests/test_predict.py
@@ -6,7 +6,7 @@
 
 from prospect.sources import CSPSpecBasis
 from prospect.models import SpecModel, templates
-from prospect.observation import Spectrum, Photometry
+from prospect.observation import Spectrum, Photometry, Lines
 
 
 @pytest.fixture(scope="module")
@@ -22,7 +22,7 @@ def build_model(add_neb=False):
     return SpecModel(model_params)
 
 
-def build_obs(multispec=True):
+def build_obs(multispec=True, add_lines=False):
     N = 1500 * (2 - multispec)
     wmax = 7000
     wsplit = wmax - N * multispec
@@ -39,9 +39,26 @@ def build_obs(multispec=True):
                           flux=np.ones(N), uncertainty=np.ones(N) / 10,
                           mask=slice(None))]
 
-    obslist = spec + phot
-    [obs.rectify() for obs in obslist]
-    return obslist
+    obs = spec + phot
+
+    if add_lines:
+        line_ind = [59, 62, 74, 73, 75] # index of line in FSPS table
+        line_name = ["Hb", "OIII-5007", "Ha", "NII-6548", "NII-6584"]
+        line_wave = [4861, 5007, 6563, 6548, 6584] # can be approximate
+        n_line = len(line_ind)
+        lines = Lines(line_ind=line_ind,
+                      flux=np.ones(n_line), # erg/s/cm^2
+                      uncertainty=np.ones(n_line)/10,
+                      line_names=line_name,  # optional
+                      wavelength=line_wave, # optional
+                    )
+        obs += [lines]
+
+    [ob.rectify() for ob in obs]
+    for ob in obs:
+        assert ob.ndof > 0
+
+    return obs
 
 
 def test_prediction_nodata(build_sps):
@@ -86,12 +103,26 @@ def test_multispec(build_sps, plot=False):
                ax.plot(o.wavelength, p)
 
 
+def test_line(build_sps, plot=False):
+
+    obs = build_obs(multispec=False, add_lines=True)
+    model = build_model(add_neb=True)
+
+    sps = build_sps
+    preds, mfrac = model.predict(model.theta, observations=obs, sps=sps)
+    (spec, phot, lines) = preds
+    assert np.all(lines) > 0
+
+    #print(f"log(OIII[5007]/Hb)={np.log10(lines[1]/lines[0])}")
+    #print(f"log(NII/Ha)={np.log10(lines[-2:]/lines[2])}")
+
+
 def lnlike_testing(build_sps):
     # testing lnprobfn
 
-    sps = build_sps
     observations = build_obs()
     model = build_model(add_neb=True)
+    sps = build_sps
 
     from prospect.likelihood.likelihood import compute_lnlike
     from prospect.fitting import lnprobfn

From 554d68d3f736bc1b1846c33f5069a9512feb4eda Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 12 Sep 2024 11:20:09 -0400
Subject: [PATCH 116/132] [ci skip] Add documentation for use of HyperSpecModel
 with stochastic SFH parameters (#342)

---
 doc/sfhs.rst                 |  4 +++-
 prospect/models/templates.py | 11 ++++++-----
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/doc/sfhs.rst b/doc/sfhs.rst
index 6727e8a8..aa0cd649 100644
--- a/doc/sfhs.rst
+++ b/doc/sfhs.rst
@@ -151,7 +151,9 @@ details.  This prior is adapted from the Extended Regulator model developed in
 `Caplar & Tacchella (2019) <https://ui.adsabs.harvard.edu/abs/2019MNRAS.487.3845C/abstract>`_ and `Tacchella, Forbes & Caplar (2020) <https://ui.adsabs.harvard.edu/abs/2020MNRAS.497..698T/abstract>`_ , in
 conjunction with the GP implementation of `Iyer & Speagle et al. (2024) <https://ui.adsabs.harvard.edu/abs/2024ApJ...961...53I/abstract>`_ taken from `this module <https://github.com/kartheikiyer/GP-SFH>`_ .
 
-
+Use of this SFH prior requires that
+:py:class:`prospect.models.sedmodel.HyperSpecModel` be used as the model base
+class (instead of :py:class:`SpecModel`).
 
 Dirichlet SFH
 ^^^^^^^^^^^^^
diff --git a/prospect/models/templates.py b/prospect/models/templates.py
index b76d5a37..7911c03e 100755
--- a/prospect/models/templates.py
+++ b/prospect/models/templates.py
@@ -706,18 +706,18 @@ def adjust_stochastic_params(parset, tuniv=13.7):
 
 # Sets the PSD parameters & priors
 # sigma_reg: Overall stochasticity coming from gas inflow
-_stochastic_["sigma_reg"] = {'name': 'sigma_reg', 'N': 1, 'isfree': True, 'init': 0.3, 
+_stochastic_["sigma_reg"] = {'name': 'sigma_reg', 'N': 1, 'isfree': True, 'init': 0.3,
                              'prior': priors.LogUniform(mini=0.01, maxi=5.0), 'units': 'dex^2'}
 # tau_eq: Timescale associated with equilibrium gas cycling in gas reservoir (related to depletion timescale)
-_stochastic_["tau_eq"] = {'name': 'tau_eq', 'N': 1, 'isfree': True, 'init': 2.5, 
+_stochastic_["tau_eq"] = {'name': 'tau_eq', 'N': 1, 'isfree': True, 'init': 2.5,
                           'prior': priors.TopHat(mini=0.01, maxi=7.0), 'units': 'Gyr'}
 # tau_in: Characteristic timescale associated with gas inflow into gas reservoir
 _stochastic_["tau_in"] = {'name': 'tau_in', 'N': 1, 'isfree': False, 'init': 7.0, 'units': 'Gyr'}
 # sigma_dyn: Overall stochasticity coming from short-term, dynamical processes (e.g., creation/destruction of GMCs)
-_stochastic_["sigma_dyn"] = {'name': 'sigma_dyn', 'N': 1, 'isfree': True, 'init': 0.01, 
+_stochastic_["sigma_dyn"] = {'name': 'sigma_dyn', 'N': 1, 'isfree': True, 'init': 0.01,
                              'prior': priors.LogUniform(mini=0.001, maxi=0.1), 'units': 'dex^2'}
 # tau_dyn: Characteristic timescale associated with short-term, dynamical processes
-_stochastic_["tau_dyn"] = {'name': 'tau_dyn', 'N': 1, 'isfree': True, 'init': 0.025, 
+_stochastic_["tau_dyn"] = {'name': 'tau_dyn', 'N': 1, 'isfree': True, 'init': 0.025,
                            'prior': priors.ClippedNormal(mini=0.005, maxi=0.2, mean=0.01, sigma=0.02), 'units': 'Gyr'}
 
 _stochastic_["logsfr_ratios"] = {'N': 7, 'isfree': True, 'init': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
@@ -734,7 +734,8 @@ def adjust_stochastic_params(parset, tuniv=13.7):
 #                                  'prior': priors.MultiVariateNormal(mean=[0.]*7, Sigma=sfr_ratio_covar)}
 
 TemplateLibrary["stochastic_sfh"] = (_stochastic_,
-                                     "Stochastic SFH which correlates the SFRs between time bins based on model in TFC2020")
+                                     ("Stochastic SFH which correlates the SFRs between time bins based on model in TFC2020."
+                                      " Requires `HyperSpecModel` as the base model class."))
 
 
 # ----------------------------

From 1bf1bc4b6534b6d4cc41141c0053e3e7ae405582 Mon Sep 17 00:00:00 2001
From: "Johannes U. Lange" <julange.astro@pm.me>
Date: Wed, 25 Sep 2024 16:03:29 -0400
Subject: [PATCH 117/132] restructure of nested samplers, fixed crash in
 nautilus

---
 prospect/fitting/fitting.py |   8 +-
 prospect/fitting/nested.py  | 298 +++++++++---------------------------
 2 files changed, 78 insertions(+), 228 deletions(-)

diff --git a/prospect/fitting/fitting.py b/prospect/fitting/fitting.py
index aa4c0a22..2342afec 100755
--- a/prospect/fitting/fitting.py
+++ b/prospect/fitting/fitting.py
@@ -15,7 +15,7 @@
 
 from .minimizer import minimize_wrapper, minimizer_ball
 from .ensemble import run_emcee_sampler
-from .nested import run_nested_sampler, parse_nested_kwargs
+from .nested import run_nested_sampler
 from ..likelihood.likelihood import compute_chi, compute_lnlike
 
 
@@ -475,17 +475,13 @@ def run_nested(observations, model, sps,
     # wrap the probability fiunction, making sure it's a likelihood
     likelihood = wrap_lnp(lnprobfn, observations, model, sps, nested=True)
 
-    # which keywords do we have for this fitter?
-    ns_kwargs, nr_kwargs = parse_nested_kwargs(nested_sampler=nested_sampler,**kwargs)
-
     output = run_nested_sampler(model,
                                 likelihood,
                                 nested_sampler=nested_sampler,
                                 verbose=verbose,
                                 nested_nlive=nested_nlive,
                                 nested_neff=nested_target_n_effective,
-                                nested_sampler_kwargs=ns_kwargs,
-                                nested_run_kwargs=nr_kwargs)
+                                **kwargs)
     info, result_obj = output
 
     return info
diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index f0f25185..7080322c 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -1,36 +1,8 @@
+import inspect
 import time
 import numpy as np
 
-__all__ = ["run_nested_sampler", "parse_nested_kwargs"]
-
-
-def parse_nested_kwargs(nested_sampler=None, **kwargs):
-
-    # TODO:
-    #   something like 'enlarge'
-    #   something like 'bootstrap' or N_networks or?
-
-    sampler_kwargs = {}
-    run_kwargs = {}
-
-    if nested_sampler == "dynesty":
-        sampler_kwargs["bound"] = kwargs["nested_bound"]
-        sampler_kwargs["sample"] = kwargs["nested_sample"]
-        sampler_kwargs["walks"] = kwargs["nested_walks"]
-        run_kwargs["dlogz_init"] = kwargs["nested_dlogz"]
-
-    elif nested_sampler == "ultranest":
-        #run_kwargs["dlogz"] = kwargs["nested_dlogz"]
-        pass
-
-    elif nested_sampler == "nautilus":
-        pass
-
-    else:
-        # say what?
-        raise ValueError(f"{nested_sampler} not a valid fitter")
-
-    return sampler_kwargs, run_kwargs
+__all__ = ["run_nested_sampler"]
 
 
 
@@ -40,8 +12,7 @@ def run_nested_sampler(model,
                        nested_nlive=1000,
                        nested_neff=1000,
                        verbose=False,
-                       nested_run_kwargs={},
-                       nested_sampler_kwargs={}):
+                       **kwargs):
     """We give a model -- parameter discription and prior transform -- and a
     likelihood function. We get back samples, weights, and likelihood values.
 
@@ -51,209 +22,92 @@ def run_nested_sampler(model,
         Loctions, log-weights, and log-likelihoods for the samples
 
     obj : Object
-        The sampling object.  This will depend on the nested sampler being used.
+        The sampling results object. This will depend on the nested sampler being used.
     """
     if verbose:
         print(f"running {nested_sampler} for {nested_neff} effective samples")
 
     go = time.time()
 
-    # --- Nautilus ---
-    if nested_sampler == "nautilus":
+    # Initialize the sampler.
+    if nested_sampler == 'nautilus':
         from nautilus import Sampler
-
-        sampler = Sampler(model.prior_transform,
-                          likelihood_function,
-                          n_dim=model.ndim,
-                          pass_dict=False, # likelihood expects array, not dict
-                          n_live=nested_nlive,
-                          **nested_sampler_kwargs)
-        sampler.run(n_eff=nested_neff,
-                    verbose=verbose,
-                    **nested_run_kwargs)
-        obj = sampler
-
-        points, log_w, log_like = sampler.posterior()
-
-    # --- Ultranest ---
-    if nested_sampler == "ultranest":
-
+        sampler_init = Sampler
+        init_args = (model.prior_transform, likelihood_function)
+        init_kwargs = dict(pass_dict=False, n_live=nested_nlive,
+                           n_dim=model.ndim)
+    elif nested_sampler == 'ultranest':
         from ultranest import ReactiveNestedSampler
-        parameter_names = model.theta_labels()
-        sampler = ReactiveNestedSampler(parameter_names,
-                                        likelihood_function,
-                                        model.prior_transform,
-                                        **nested_sampler_kwargs)
-        result = sampler.run(min_ess=nested_neff,
-                             min_num_live_points=nested_nlive,
-                             show_status=verbose,
-                             **nested_run_kwargs)
-        obj = result
-
-        points = np.array(result['weighted_samples']['points'])
-        log_w = np.log(np.array(result['weighted_samples']['weights']))
-        log_like = np.array(result['weighted_samples']['logl'])
-
-    # --- Dynesty ---
-    if nested_sampler == "dynesty":
+        sampler_init = ReactiveNestedSampler
+        init_args = (model.theta_labels(), likelihood_function,
+                     model.prior_transform)
+        init_kwargs = dict()
+    elif nested_sampler == 'dynesty':
         from dynesty import DynamicNestedSampler
-
-        sampler = DynamicNestedSampler(likelihood_function,
-                                       model.prior_transform,
-                                       model.ndim,
-                                       nlive=nested_nlive,
-                                       **nested_sampler_kwargs)
-        sampler.run_nested(n_effective=nested_neff,
-                           print_progress=verbose,
-                           **nested_run_kwargs)
+        sampler_init = DynamicNestedSampler
+        init_args = (likelihood_function, model.prior_transform, model.ndim)
+        init_kwargs = dict(nlive=nested_nlive)
+    elif nested_sampler == 'nestle':
+        import nestle
+        init_kwargs = dict()
+    else:
+        raise ValueError(f"No nested sampler called '{nested_sampler}'.")
+
+    if nested_sampler != 'nestle':
+        sig = inspect.signature(sampler_init).bind_partial()
+        sig.apply_defaults()
+        init_kwargs = {
+            **{key: kwargs[key] for key in sig.kwargs.keys() & kwargs.keys()},
+            **init_kwargs}
+        sampler = sampler_init(*init_args, **init_kwargs)
+
+    # Run the sampler.
+    if nested_sampler == 'nautilus':
+        sampler_run = sampler.run
+        run_args = ()
+        run_kwargs = dict(n_eff=nested_neff, verbose=verbose)
+    elif nested_sampler == 'ultranest':
+        sampler_run = sampler.run
+        run_args = ()
+        run_kwargs = dict(
+            min_ess=nested_neff, min_num_live_points=nested_nlive,
+            show_status=verbose)
+    elif nested_sampler == 'dynesty':
+        sampler_run = sampler.run_nested
+        run_args = ()
+        run_kwargs = dict(n_effective=nested_neff, print_progress=verbose)
+    elif nested_sampler == 'nestle':
+        sampler_run = nestle.sample
+        run_args = (likelihood_function, model.prior_transform, model.ndim)
+        run_kwargs = dict()
+
+    sig = inspect.signature(sampler_run).bind_partial()
+    sig.apply_defaults()
+    run_kwargs = {
+        **{key: kwargs[key] for key in sig.kwargs.keys() & kwargs.keys()},
+        **run_kwargs}
+    run_return = sampler_run(*run_args, **run_kwargs)
+
+    if sampler == 'nautilus':
+        obj = sampler
+        points, log_w, log_like = sampler.posterior()
+    elif sampler == 'ultranest':
+        obj = run_return
+        points = np.array(run_return['weighted_samples']['points'])
+        log_w = np.log(np.array(run_return['weighted_samples']['weights']))
+        log_like = np.array(run_return['weighted_samples']['logl'])
+    elif sampler == 'dynesty':
         obj = sampler
-
         points = sampler.results["samples"]
         log_w = sampler.results["logwt"]
         log_like = sampler.results["logl"]
-
-    # --- Nestle ---
-    if nested_sampler == "nestle":
-        import nestle
-        result = nestle.sample(likelihood_function,
-                               model.prior_transform,
-                               model.ndim,
-                               **nested_sampler_kwargs)
-        obj = result
-
-        points = result["samples"]
-        log_w = result["logwt"]
-        log_like = result["logl"]
+    elif sampler == 'nestle':
+        obj = run_return
+        points = run_return["samples"]
+        log_w = run_return["logwt"]
+        log_like = run_return["logl"]
 
     dur = time.time() - go
 
-    return dict(points=points, log_weight=log_w, log_like=log_like, duration=dur), obj
-
-
-# OMG
-NESTED_KWARGS = {
-"dynesty_sampler_kwargs" : dict(nlive=None,
-                                bound='multi',
-                                sample='auto',
-                                #periodic=None,
-                                #reflective=None,
-                                update_interval=None,
-                                first_update=None,
-                                npdim=None,
-                                #rstate=None,
-                                queue_size=None,
-                                pool=None,
-                                use_pool=None,
-                                #logl_args=None,
-                                #logl_kwargs=None,
-                                #ptform_args=None,
-                                #ptform_kwargs=None,
-                                #gradient=None,
-                                #grad_args=None,
-                                #grad_kwargs=None,
-                                #compute_jac=False,
-                                enlarge=None,
-                                bootstrap=None,
-                                walks=None,
-                                facc=0.5,
-                                slices=None,
-                                fmove=0.9,
-                                max_move=100,
-                                #update_func=None,
-                                ncdim=None,
-                                blob=False,
-                                #save_history=False,
-                                #history_filename=None)
-                             ),
-"dynesty_run_kwargs" : dict(nlive_init=None, # nlive0
-                            maxiter_init=None,
-                            maxcall_init=None,
-                            dlogz_init=0.01,
-                            logl_max_init=np.inf,
-                            n_effective_init=np.inf, # deprecated
-                            nlive_batch=None, #nlive0
-                            wt_function=None,
-                            wt_kwargs=None,
-                            maxiter_batch=None,
-                            maxcall_batch=None,
-                            maxiter=None,
-                            maxcall=None,
-                            maxbatch=None,
-                            n_effective=None,
-                            stop_function=None,
-                            stop_kwargs=None,
-                            #use_stop=True,
-                            #save_bounds=True, # doesn't hurt...?
-                            print_progress=True,
-                            #print_func=None,
-                            live_points=None,
-                            #resume=False,
-                            #checkpoint_file=None,
-                            #checkpoint_every=60)
-                            ),
-"ultranest_sampler_kwargs":dict(transform=None,
-                                #derived_param_names=[],
-                                #wrapped_params=None,
-                                #resume='subfolder',
-                                #run_num=None,
-                                #log_dir=None,
-                                #num_test_samples=2,
-                                draw_multiple=True,
-                                num_bootstraps=30,
-                                #vectorized=False,
-                                ndraw_min=128,
-                                ndraw_max=65536,
-                                storage_backend='hdf5',
-                                warmstart_max_tau=-1,
-                                ),
-"ultranest_run_kwargs":dict(update_interval_volume_fraction=0.8,
-                            update_interval_ncall=None,
-                            #log_interval=None,
-                            show_status=True,
-                            #viz_callback='auto',
-                            dlogz=0.5,
-                            dKL=0.5,
-                            frac_remain=0.01,
-                            Lepsilon=0.001,
-                            min_ess=400,
-                            max_iters=None,
-                            max_ncalls=None,
-                            max_num_improvement_loops=-1,
-                            min_num_live_points=400,
-                            cluster_num_live_points=40,
-                            insertion_test_window=10,
-                            insertion_test_zscore_threshold=4,
-                            region_class="MLFriends",
-                            #widen_before_initial_plateau_num_warn=10000,
-                            #widen_before_initial_plateau_num_max=50000,
-                            ),
-"nautilus_sampler_kwargs":dict(n_live=2000,
-                               n_update=None,
-                               enlarge_per_dim=1.1,
-                               n_points_min=None,
-                               split_threshold=100,
-                               n_networks=4,
-                               neural_network_kwargs={},
-                               #prior_args=[],
-                               #prior_kwargs={},
-                               #likelihood_args=[],
-                               #likelihood_kwargs={},
-                               n_batch=None,
-                               n_like_new_bound=None,
-                               #vectorized=False,
-                               #pass_dict=None,
-                               pool=None,
-                               seed=None,
-                               blobs_dtype=None,
-                               #filepath=None,
-                               #resume=True
-                               ),
-"nautilus_run_kwargs":dict(f_live=0.01,
-                           n_shell=1,
-                           n_eff=10000,
-                           n_like_max=np.inf,
-                           discard_exploration=False,
-                           timeout=np.inf,
-                           verbose=False
-                           ),
-}
+    return dict(points=points, log_weight=log_w, log_like=log_like,
+                duration=dur), obj

From e754d980e83673d4a06d7f9f399570b5d12c73d2 Mon Sep 17 00:00:00 2001
From: "Johannes U. Lange" <julange.astro@pm.me>
Date: Wed, 25 Sep 2024 21:11:51 -0400
Subject: [PATCH 118/132] fixed crash

---
 prospect/fitting/nested.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index 7080322c..a24cbafb 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -88,20 +88,20 @@ def run_nested_sampler(model,
         **run_kwargs}
     run_return = sampler_run(*run_args, **run_kwargs)
 
-    if sampler == 'nautilus':
+    if nested_sampler == 'nautilus':
         obj = sampler
         points, log_w, log_like = sampler.posterior()
-    elif sampler == 'ultranest':
+    elif nested_sampler == 'ultranest':
         obj = run_return
         points = np.array(run_return['weighted_samples']['points'])
         log_w = np.log(np.array(run_return['weighted_samples']['weights']))
         log_like = np.array(run_return['weighted_samples']['logl'])
-    elif sampler == 'dynesty':
+    elif nested_sampler == 'dynesty':
         obj = sampler
         points = sampler.results["samples"]
         log_w = sampler.results["logwt"]
         log_like = sampler.results["logl"]
-    elif sampler == 'nestle':
+    elif nested_sampler == 'nestle':
         obj = run_return
         points = run_return["samples"]
         log_w = run_return["logwt"]

From 707a199d3637a69fe1a8b8783fc2249a16d1d55f Mon Sep 17 00:00:00 2001
From: "Johannes U. Lange" <julange.astro@pm.me>
Date: Thu, 26 Sep 2024 10:49:38 -0400
Subject: [PATCH 119/132] added appropriate users warnings

---
 prospect/fitting/nested.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index a24cbafb..0bec4725 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -1,6 +1,7 @@
 import inspect
-import time
 import numpy as np
+import time
+import warnings
 
 __all__ = ["run_nested_sampler"]
 
@@ -56,6 +57,8 @@ def run_nested_sampler(model,
     if nested_sampler != 'nestle':
         sig = inspect.signature(sampler_init).bind_partial()
         sig.apply_defaults()
+        for key in kwargs.keys() & init_kwargs.keys():
+            warnings.warn(f"Value of key '{key}' overwritten.")
         init_kwargs = {
             **{key: kwargs[key] for key in sig.kwargs.keys() & kwargs.keys()},
             **init_kwargs}
@@ -83,10 +86,14 @@ def run_nested_sampler(model,
 
     sig = inspect.signature(sampler_run).bind_partial()
     sig.apply_defaults()
+    for key in kwargs.keys() & run_kwargs.keys():
+        warnings.warn(f"Value of key '{key}' overwritten.")
     run_kwargs = {
         **{key: kwargs[key] for key in sig.kwargs.keys() & kwargs.keys()},
         **run_kwargs}
     run_return = sampler_run(*run_args, **run_kwargs)
+    for key in kwargs.keys() - (init_kwargs.keys() | run_kwargs.keys()):
+        warnings.warn(f"Key '{key}' not recognized by the sampler.")
 
     if nested_sampler == 'nautilus':
         obj = sampler

From 2e7c470683798b3877b0652496f8609c4c684e6a Mon Sep 17 00:00:00 2001
From: "Johannes U. Lange" <julange.astro@pm.me>
Date: Thu, 26 Sep 2024 15:48:35 -0400
Subject: [PATCH 120/132] updated docstrings

---
 prospect/fitting/nested.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index 0bec4725..88c78ca2 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -6,7 +6,6 @@
 __all__ = ["run_nested_sampler"]
 
 
-
 def run_nested_sampler(model,
                        likelihood_function,
                        nested_sampler="dynesty",
@@ -17,6 +16,19 @@ def run_nested_sampler(model,
     """We give a model -- parameter discription and prior transform -- and a
     likelihood function. We get back samples, weights, and likelihood values.
 
+    Parameters
+    ----------
+    model : instance of the :py:class:`prospect.models.SpecModel`
+        The model parameterization and parameter state.
+    likelihood_function : callable
+        Likelihood function
+    nested_live : int
+        Number of live points.
+    nested_neff : float
+        Minimum effective sample size.
+    verbose : bool
+        Whether to output sampler progress.
+
     Returns
     -------
     samples : 3-tuple of ndarrays (loc, logwt, loglike)

From f4765e10f0068d46b988bf5bf7737e03acdddf49 Mon Sep 17 00:00:00 2001
From: "Johannes U. Lange" <julange.astro@pm.me>
Date: Mon, 30 Sep 2024 13:30:00 -0400
Subject: [PATCH 121/132] fix for numpy 2.0

---
 prospect/plotting/corner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prospect/plotting/corner.py b/prospect/plotting/corner.py
index 5c1cf794..93c9144b 100644
--- a/prospect/plotting/corner.py
+++ b/prospect/plotting/corner.py
@@ -305,7 +305,7 @@ def corner(samples, paxes, weights=None, span=None, smooth=0.02,
     :returns paxes:
     """
     assert samples.ndim > 1
-    assert np.product(samples.shape[1:]) > samples.shape[0]
+    assert np.prod(samples.shape[1:]) > samples.shape[0]
     ndim = len(samples)
 
     # Determine plotting bounds.

From 9334fc901fcf0edbb88452142cf3447eb46d55cc Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 1 Oct 2024 11:43:49 -0400
Subject: [PATCH 122/132] remove unused kwargs warning for samplers; update
 tests_samplers

---
 prospect/fitting/nested.py |  4 ++--
 tests/tests_samplers.py    | 10 ++--------
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/prospect/fitting/nested.py b/prospect/fitting/nested.py
index 88c78ca2..c8aaabc6 100644
--- a/prospect/fitting/nested.py
+++ b/prospect/fitting/nested.py
@@ -104,8 +104,8 @@ def run_nested_sampler(model,
         **{key: kwargs[key] for key in sig.kwargs.keys() & kwargs.keys()},
         **run_kwargs}
     run_return = sampler_run(*run_args, **run_kwargs)
-    for key in kwargs.keys() - (init_kwargs.keys() | run_kwargs.keys()):
-        warnings.warn(f"Key '{key}' not recognized by the sampler.")
+    #for key in kwargs.keys() - (init_kwargs.keys() | run_kwargs.keys()):
+    #    warnings.warn(f"Key '{key}' not recognized by the sampler.")
 
     if nested_sampler == 'nautilus':
         obj = sampler
diff --git a/tests/tests_samplers.py b/tests/tests_samplers.py
index 8c47d85f..3c231071 100644
--- a/tests/tests_samplers.py
+++ b/tests/tests_samplers.py
@@ -11,7 +11,6 @@
 from prospect.models import SpecModel, templates
 from prospect.observation import Photometry
 from prospect.fitting import fit_model
-from prospect.fitting.nested import parse_nested_kwargs
 from prospect.io.write_results import write_hdf5
 from prospect.io.read_results import results_from
 
@@ -69,12 +68,6 @@ def build_obs(**kwargs):
     run_params = vars(args)
     run_params["param_file"] = __file__
 
-    # test the parsing
-    run_params["nested_sampler"] = "dynesty"
-    nr, ns = parse_nested_kwargs(**run_params)
-    print(nr)
-    print(ns)
-
     # build stuff
     model = build_model()
     obs = build_obs()
@@ -120,4 +113,5 @@ def build_obs(**kwargs):
                                 axes,
                                 color=color,
                                 weights= np.exp(out["log_weight"]),
-                                show_titles=True)
\ No newline at end of file
+                                show_titles=True)
+    cfig.savefig("sampler_test_corner.png")
\ No newline at end of file

From e6af39afa285b8240ed2ac025517f6fe711bf43e Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Tue, 1 Oct 2024 14:13:41 -0400
Subject: [PATCH 123/132] de-alias dynesty parameters in the parser, to
 maintain some backwards compat.

---
 prospect/utils/prospect_args.py | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/prospect/utils/prospect_args.py b/prospect/utils/prospect_args.py
index 7e257a5e..d0b0aa93 100644
--- a/prospect/utils/prospect_args.py
+++ b/prospect/utils/prospect_args.py
@@ -118,30 +118,34 @@ def add_nested_args(parser):
                         help="Number of live points for the nested sampling run.")
 
     parser.add_argument("--nested_target_n_effective", type=int, default=10000,
-                        help=("Stop when the number of *effective* posterior samples as estimated "
-                              "by dynesty reaches the target number."))
+                        help=("Stop when the estimated number of *effective* posterior samples "
+                              "reaches the target number."))
 
     parser.add_argument("--nested_dlogz", type=float, default=0.05,
-                        help=("Stop the initial run when the remaining evidence is estimated "
+                        dest="dlogz_init",
+                        help=("Stop the initial dynesty run when the remaining evidence is estimated "
                               "to be less than this."))
 
     parser.add_argument("--nested_bound", type=str, default="multi",
+                        dest="bound",
                         choices=["single", "multi", "balls", "cubes"],
-                        help=("Method for bounding the prior volume when drawing new points. "
+                        help=("Method for bounding the prior volume when drawing new points with dynesty. "
                               "One of single | multi | balls | cubes"))
 
-    parser.add_argument("--nested_sample", "--nested_method", type=str, dest="nested_sample",
+    parser.add_argument("--nested_sample", "--nested_method", type=str, dest="sample",
                         default="auto", choices=["auto", "unif", "rwalk", "slice", "hslice"],
-                        help=("Method for drawing new points during sampling.  "
+                        help=("Method for drawing new points during dynesty sampling.  "
                               "One of auto | unif | rwalk | slice | hslice"))
 
     parser.add_argument("--nested_walks", type=int, default=48,
-                        help=("Number of Metropolis steps to take when "
+                        dest="walks",
+                        help=("Number of Metropolis steps for dynesty to take when "
                               "`nested_sample` is 'rwalk'"))
 
     parser.add_argument("--nested_bootstrap", type=int, default=0,
-                         help=("Number of bootstrap resamplings to use when estimating "
-                               "ellipsoid expansion factor."))
+                        dest="bootstrap",
+                        help=("Number of bootstrap resamplings to use when estimating "
+                              "ellipsoid expansion factor with dynesty."))
 
     return parser
 

From 2f0588ba1929a73d912b193684f2c0e848f13e17 Mon Sep 17 00:00:00 2001
From: Benjamin Johnson <benjamin.duncan.johnson@gmail.com>
Date: Thu, 26 Sep 2024 19:43:40 -0400
Subject: [PATCH 124/132] only compute lya damping above zmin.

---
 prospect/models/sedmodel.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 6a30764d..681b1fc8 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -797,9 +797,10 @@ def add_dla(self, wave_rest, spec):
         return spec
 
     def add_damping_wing(self, wave_rest, spec):
-        if np.any(self.params.get("igm_damping", False)):
+        zmin = 5.0
+        if (self._zred > zmin) & np.any(self.params.get("igm_damping", False)):
             x_HI = self.params.get("igm_factor", 1.0)
-            tau = tau_damping(wave_rest, self._zred, x_HI, cosmo=cosmo)
+            tau = tau_damping(wave_rest, self._zred, x_HI, zmin=zmin, cosmo=cosmo)
             spec *= np.exp(-tau)
         return spec
 

From b4ed6edceaed133a572c3b56274bf50d4adf25e2 Mon Sep 17 00:00:00 2001
From: Bingjie Wang <bwang.jhu@gmail.com>
Date: Fri, 22 Nov 2024 09:55:17 -0500
Subject: [PATCH 125/132] return model=None if dangerous=False

---
 prospect/io/read_results.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/prospect/io/read_results.py b/prospect/io/read_results.py
index c4dd3e5c..386a25a5 100644
--- a/prospect/io/read_results.py
+++ b/prospect/io/read_results.py
@@ -70,7 +70,8 @@ def results_from(filename, model_file=None, dangerous=True, **kwargs):
     """
     # Read the basic chain, parameter, and run_params info
     res, obs = read_hdf5(filename, **kwargs)
-
+    model = None
+    
     # Now try to instantiate the model object from the paramfile
     if dangerous:
         try:

From 8f842110267ec4b640df311f90f3e9f850318426 Mon Sep 17 00:00:00 2001
From: yi-jia-li <yzl466@psu.edu>
Date: Thu, 5 Dec 2024 06:26:11 -0500
Subject: [PATCH 126/132] merge add_cue branch with main

---
 prospect/models/sedmodel.py      |  20 +++-
 prospect/sources/fake_fsps.py    | 177 +++++++++++++++++++++++++++++++
 prospect/sources/nebssp_basis.py | 127 ++++++++++++++++++++++
 3 files changed, 321 insertions(+), 3 deletions(-)
 create mode 100644 prospect/sources/fake_fsps.py
 create mode 100644 prospect/sources/nebssp_basis.py

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 681b1fc8..355b13ee 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -20,6 +20,11 @@
 from ..sources.constants import to_cgs_at_10pc as to_cgs
 from ..sources.constants import cosmo, lightspeed, ckms, jansky_cgs
 
+try:
+    from cue.utils import sigma_line_for_fsps
+except:
+    pass
+
 
 __all__ = ["SpecModel",
            "HyperSpecModel",
@@ -54,6 +59,7 @@ def _available_parameters(self):
                     ("eline_sigma", ""),
                     ("use_eline_priors", ""),
                     ("eline_prior_width", ""),
+                    ("use_eline_nn_unc", ""),
                     ("dla_logNh", "log_10 HI column density for damped Lyman-alpha absorption"),
                     ("dla_redshift", "redshift of the DLA; if greater than zred then no absorption occurs"),
                     ("igm_damping", "boolean switch to turn on IGM damping wing redward of 1216 rest")]
@@ -140,8 +146,14 @@ def predict_init(self, theta, sps):
         # cache eline mle info
         self._ln_eline_penalty = 0
         self._eline_lum_mle = self._eline_lum.copy()
-        self._eline_lum_covar = np.diag((self.params.get('eline_prior_width', 0.0) *
-                                         self._eline_lum)**2)
+        if self.params.get('use_eline_nn_unc', False):
+            self._eline_lum_covar = np.diag((self.params.get('eline_prior_width', 0.0) *
+                                             self._eline_lum)**2) + 
+                                    (sigma_line_for_fsps *
+                                     self._eline_lum)**2
+        else:
+            self._eline_lum_covar = np.diag((self.params.get('eline_prior_width', 0.0) *
+                                             self._eline_lum)**2)
 
         # physical velocity smoothing of the whole UV/NIR spectrum
         self._smooth_spec = self.losvd_smoothing(self._wave, self._norm_spec)
@@ -150,7 +162,8 @@ def predict_init(self, theta, sps):
         self._smooth_spec = self.add_dla(self._wave, self._smooth_spec)
         self._smooth_spec = self.add_damping_wing(self._wave, self._smooth_spec)
 
-    def predict_obs(self, obs):
+
+    def predict_obs(self, obs, sigma_spec=None):
         if obs.kind == "spectrum":
             prediction = self.predict_spec(obs)
         elif obs.kind == "lines":
@@ -324,6 +337,7 @@ def predict_spec(self, obs):
 
         return inst_spec
 
+
     def predict_lines(self, obs, **extras):
         """Generate a prediction for the observed nebular line fluxes.  This method assumes
         that the model parameters have been set, that any adjustments to the
diff --git a/prospect/sources/fake_fsps.py b/prospect/sources/fake_fsps.py
new file mode 100644
index 00000000..f48efa4c
--- /dev/null
+++ b/prospect/sources/fake_fsps.py
@@ -0,0 +1,177 @@
+import numpy as np
+
+__all__ = ["add_dust", "add_igm"]
+
+
+def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=0.0,dust1=0.0,**kwargs):
+    """
+    wave: wavelength vector in Angstroms
+    specs: spectral flux density, in (young, old) pairs
+    line_waves: list of emission line wavelengths (Angstroms)
+    lines: emission line flux density, in (young, old) pairs
+    """
+
+    attenuated_specs = np.zeros_like(specs)
+    attenuated_lines = np.zeros_like(lines)
+
+    # Loop over the (young,old) pairs for both lines and continuum
+    for i, (spec, line) in enumerate(zip(specs,lines)):
+        if (i == 0):
+            d1 = dust1
+        else:
+            d1 = 0.0
+
+        attenuated_specs[i] = attenuate(spec,wave,dust_type=dust_type,dust_index=dust_index,dust2=dust2,dust1_index=dust1_index,dust1=d1)
+        attenuated_lines[i] = attenuate(line,line_waves,dust_type=dust_type,dust_index=dust_index,dust2=dust2,dust1_index=dust1_index,dust1=d1)
+
+    attenuated_specs = attenuated_specs[0] + attenuated_specs[1]
+    attenuated_lines = attenuated_lines[0] + attenuated_lines[1]
+    return attenuated_specs, attenuated_lines
+
+
+def attenuate(spec,lam,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=0.0,dust1=0.0):
+    """returns F(obs) / F(emitted) for a given attenuation curve + dust1 + dust2
+    """
+
+    ### constants from FSPS
+    dd63 = 6300.00
+    lamv = 5500.0
+    dlam = 350.0
+    lamuvb = 2175.0
+
+    ### check for out-of-bounds dust type
+    if (dust_type < 0) | (dust_type > 6):
+        raise ValueError('ATTN_CURVE ERROR: dust_type out of range:{0}'.format(dust_type))
+
+    ### power-law attenuation
+    if (dust_type == 0):
+        attn_curve = (lam/lamv)**dust_index * dust2
+
+    ### CCM89 extinction curve
+    elif (dust_type == 1):
+        raise(NotImplementedError)
+
+    ### Calzetti et al. 2000 attenuation
+    elif (dust_type == 2):
+        #Calzetti curve, below 6300 Angstroms, else no addition
+        cal00 = np.zeros_like(lam)
+        gt_dd63 = lam > dd63
+        le_dd63 = ~gt_dd63
+        if gt_dd63.sum() > 0:
+            cal00[gt_dd63] = 1.17*( -1.857+1.04*(1e4/lam[gt_dd63]) ) + 1.78
+        if le_dd63.sum() > 0:
+            cal00[le_dd63]  = 1.17*(-2.156+1.509*(1e4/lam[le_dd63])-\
+                              0.198*(1E4/lam[le_dd63])**2 + \
+                              0.011*(1E4/lam[le_dd63])**3) + 1.78
+        cal00 = cal00/0.44/4.05  # R = 4.05
+        cal00 = np.clip(cal00, 0.0, np.inf)  # no negative attenuation
+
+        attn_curve = cal00 * dust2
+
+    ### Witt & Gordon 2000 attenuation
+    elif (dust_type == 3):
+        raise(NotImplementedError)
+
+
+    ### Kriek & Conroy 2013 attenuation
+    elif (dust_type == 4):
+        #Calzetti curve, below 6300 Angstroms, else no addition
+        cal00 = np.zeros_like(lam)
+        gt_dd63 = lam > dd63
+        le_dd63 = ~gt_dd63
+        if gt_dd63.sum() > 0:
+            cal00[gt_dd63] = 1.17*( -1.857+1.04*(1e4/lam[gt_dd63]) ) + 1.78
+        if le_dd63.sum() > 0:
+            cal00[le_dd63]  = 1.17*(-2.156+1.509*(1e4/lam[le_dd63])-\
+                              0.198*(1E4/lam[le_dd63])**2 + \
+                              0.011*(1E4/lam[le_dd63])**3) + 1.78
+        cal00 = cal00/0.44/4.05  # R = 4.05
+        cal00 = np.clip(cal00, 0.0, np.inf)  # no negative attenuation
+
+        eb = 0.85 - 1.9 * dust_index  #KC13 Eqn 3
+
+        #Drude profile for 2175A bump
+        drude = eb*(lam*dlam)**2 / ( (lam**2-lamuvb**2)**2 + (lam*dlam)**2 )
+
+        attn_curve = dust2*(cal00+drude/4.05)*(lam/lamv)**dust_index
+
+    ### Gordon et al. (2003) SMC exctincion
+    elif (dust_type == 5):
+        raise(NotImplementedError)
+
+    ### Reddy et al. (2015) attenuation
+    elif (dust_type == 6):
+        reddy = np.zeros_like(lam)
+
+        # see Eqn. 8 in Reddy et al. (2015)
+        w1 = np.abs(lam - 1500).argmin()
+        w2 = np.abs(lam - 6000).argmin()
+        reddy[w1:w2] = -5.726 + 4.004/(lam[w1:w2]/1e4) - 0.525/(lam[w1:w2]/1e4)**2 + \
+                       0.029/(lam[w1:w2]/1e4)**3 + 2.505
+        reddy[:w1] = reddy[w1]  # constant extrapolation blueward
+
+        w1 = np.abs(lam - 6000).argmin()
+        w2 = np.abs(lam - 28500).argmin()
+        # note the last term is not in Reddy et al. but was included to make the
+        # two functions continuous at 0.6um
+        reddy[w1:w2] = -2.672 - 0.010/(lam[w1:w2]/1e4) + 1.532/(lam[w1:w2]/1e4)**2 + \
+                       -0.412/(lam[w1:w2]/1e4)**3 + 2.505 - 0.036221981
+
+        # convert k_lam to A_lam/A_V assuming Rv=2.505
+        reddy = reddy/2.505
+
+        attn_curve = dust2*reddy
+
+    dust1_ext = np.exp(-dust1*(lam/5500.)**dust1_index)
+    dust2_ext = np.exp(-attn_curve)
+
+    ext_tot = dust2_ext*dust1_ext
+
+    return ext_tot*spec
+
+def add_igm(wave, spec, zred=0., igm_factor=1.0, add_igm_absorption=None, **kwargs):
+    """IGM absorption based on Madau+1995
+    wave: rest-frame wavelength
+    spec: spectral flux density
+
+    returns an attenuated spectrum
+    """
+
+    if add_igm_absorption == False:
+        return spec
+
+    redshifted_wave = np.asarray(wave) * (1+zred)
+
+    lylim = 911.75
+    lyw = np.array([1215.67, 1025.72, 972.537, 949.743, 937.803, 930.748, 926.226, 923.150, 920.963, 919.352,918.129, 917.181, 916.429, 915.824, 915.329, 914.919, 914.576])
+    lycoeff = np.array([0.0036,0.0017,0.0011846,0.0009410,0.0007960,0.0006967,0.0006236,0.0005665,0.0005200,0.0004817,0.0004487, 0.0004200,0.0003947,0.000372,0.000352,0.0003334,0.00031644])
+    nly = len(lyw)
+
+    tau_line = np.zeros_like(redshifted_wave)
+    for i in range(nly):
+        lmin = lyw[i]
+        lmax = lyw[i]*(1.0+zred)
+
+        idx0 = np.where((redshifted_wave>=lmin) & (redshifted_wave<=lmax))[0]
+        tau_line[idx0] += lycoeff[i]*np.exp(3.46*np.log(redshifted_wave[idx0]/lyw[i]))
+
+    xc = redshifted_wave/lylim
+    xem = 1.0+zred
+
+    idx = np.where(xc<1.0)[0]
+    xc[idx] = 1.0
+
+    idx = np.where(xc>xem)[0]
+    xc[idx] = xem
+
+    tau_cont = 0.25*xc**3*(np.exp(0.46*np.log(xem)) - np.exp(0.46*np.log(xc)))
+    tau_cont = tau_cont + 9.4*np.exp(1.5*np.log(xc))*(np.exp(0.18*np.log(xem)) - np.exp(0.18*np.log(xc)))
+    tau_cont = tau_cont - 0.7*xc**3*(np.exp(-1.32*np.log(xc)) - np.exp(-1.32*np.log(xem)))
+    tau_cont = tau_cont - 0.023*(np.exp(1.68*np.log(xem)) - np.exp(1.68*np.log(xc)))
+    tau = tau_line + tau_cont
+
+    # attenuate the input spectrum by the IGM
+    # include a fudge factor to dial up/down the strength
+    res = spec*np.exp(-tau*igm_factor)
+    tiny_number = 10**(-70.0)
+    return np.clip(res, a_min=tiny_number, a_max=None)
diff --git a/prospect/sources/nebssp_basis.py b/prospect/sources/nebssp_basis.py
new file mode 100644
index 00000000..a17afff4
--- /dev/null
+++ b/prospect/sources/nebssp_basis.py
@@ -0,0 +1,127 @@
+### SSP for cue
+import numpy as np
+
+from .galaxy_basis import FastStepBasis
+from .fake_fsps import add_dust, add_igm
+
+try:
+    import cue
+except:
+    pass
+
+
+__all__ = ["NebSSPBasis"]
+
+
+class NebSSPBasis(FastStepBasis):
+
+    """This is a class that wraps the fsps.StellarPopulation object, which is
+    used for producing SSPs.  The ``fsps.StellarPopulation`` object is accessed
+    as ``SSPBasis().ssp``.
+
+    This class allows for the custom calculation of relative SSP weights (by
+    overriding ``all_ssp_weights``) to produce spectra from arbitrary composite
+    SFHs. Alternatively, the entire ``get_galaxy_spectrum`` method can be
+    overridden to produce a galaxy spectrum in some other way, for example
+    taking advantage of weight calculations within FSPS for tabular SFHs or for
+    parameteric SFHs.
+
+    The base implementation here produces an SSP interpolated to the age given
+    by ``tage``, with initial mass given by ``mass``.  However, this is much
+    slower than letting FSPS calculate the weights, as implemented in
+    :py:class:`FastSSPBasis`.
+
+    Furthermore, smoothing, redshifting, and filter projections are handled
+    outside of FSPS, allowing for fast and more flexible algorithms.
+
+    :param reserved_params:
+        These are parameters which have names like the FSPS parameters but will
+        not be passed to the StellarPopulation object because we are overriding
+        their functionality using (hopefully more efficient) custom algorithms.
+    """
+
+    def __init__(self, cue_kwargs={},
+                 **kwargs):
+
+        self.emul = cue.Emulator(**cue_kwargs)
+        # we do these now
+        rp = ["dust1", "dust2", "dust3", "add_dust_emission",
+              "add_igm_absorption", "igm_factor",
+              "add_neb_emission", "add_neb_continuum", "nebemlineinspec",
+              "fagn", "agn_tau"]
+        reserved_params = kwargs.pop("reserved_params", []) + rp
+        super().__init__(reserved_params=reserved_params, **kwargs)
+        for k in ["add_igm_absorption", "add_dust_emission", "add_neb_emission", "nebemlineinspec"]:
+            self.ssp.params[k] = False
+
+    def get_galaxy_spectrum(self, **params):
+        """Construct the tabular SFH and feed it to the ``ssp``.
+        """
+        self.update(**params)
+        # --- check to make sure agebins have minimum spacing of 1million yrs ---
+        #       (this can happen in flex models and will crash FSPS)
+        if np.min(np.diff(10**self.params['agebins'])) < 1e6:
+            raise ValueError
+
+        mtot = self.params['mass'].sum()
+        time, sfr, tmax = self.convert_sfh(self.params['agebins'], self.params['mass'])
+        self.ssp.params["sfh"] = 3  # Hack to avoid rewriting the superclass
+        self.ssp.set_tabular_sfh(time, sfr)
+
+        wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, tage=tmax)
+        self._line_specific_luminosity = lines/mtot
+        if self.params.get("nebemlineinspec", False): # mimic the "nebemlineinspec" function in FSPS
+            if self.ssp.params["smooth_velocity"] == True:
+                dlam = self.ssp.emline_wavelengths*self.ssp.params["sigma_smooth"]/2.9979E18*1E13 #smoothing variable is in km/s
+            else:
+                dlam = self.ssp.params["sigma_smooth"] #smoothing variable is in AA
+            nearest_id = np.searchsorted(wave, self.ssp.emline_wavelengths)
+            neb_res_min = wave[nearest_id]-wave[nearest_id-1]
+            dlam = np.max([dlam,neb_res_min], axis=0)
+            gaussnebarr = [1./np.sqrt(2*np.pi)/dlam[i]*np.exp(-(wave-self.ssp.emline_wavelengths[i])**2/2/dlam[i]**2) \
+            /2.9979E18*self.ssp.emline_wavelengths[i]**2 for i in range(len(lines))]
+            for i in range(len(lines)):
+                spec += lines[i]*gaussnebarr[i]
+        return wave, spec / mtot, self.ssp.stellar_mass / mtot
+
+
+def get_spectrum(ssp, params, emul, tage=0):
+    """
+    Add the nebular continuum from Cue to the young and old population and do the dust attenuation and igm absorption.
+    Also, calculate the line luminoisities from the young csp and old csp and do the dust attenuation and igm absorption.
+    The output spec/line luminosity need to be divided by total formed mass to get the specific number.
+    :param use_stellar_ionizing:
+        If true, fit CSPs and to get the ionizing spectrum parameters, else read from ssp
+    """
+    add_neb = params["add_neb_emission"]
+    use_stars = params["use_stellar_ionizing"]
+    ewave = ssp.emline_wavelengths
+    wave, tspec = ssp.get_spectrum(tage=tage, peraa=False)
+    young, old = ssp._csp_young_old
+    csps = [young, old] # could combine with previous line
+    lines = []
+    mass = np.sum(params.get('mass', 1.0))
+    if not add_neb:
+        lines = [np.zeros_like(ewave), np.zeros_like(ewave)]
+    elif add_neb:
+        if not use_stars:
+            line_prediction = emul.predict_lines(**params)
+            #if ssp.params["sfh"] == 3:
+            #    line_prediction /= mass
+            lines = [line_prediction, np.zeros_like(ewave)]
+            csps[0][wave>=912] += emul.predict_cont(wave[wave>=912], **params)
+        elif use_stars:
+            for spec in csps:
+                ion_params = cue.fit_4loglinear_ionparam(wave, spec)
+                params.update(**ion_params)
+                line_prediction = emul.predict_lines(**params)
+                #if ssp.params["sfh"] == 3:
+                #    line_prediction /= mass
+                lines.append(line_prediction)
+                spec[wave>=912] += emul.predict_cont(wave[wave>=912], **params)
+        else:
+            raise KeyError('No "use_stellar_ionizing" in model')
+
+    sspec, lines = add_dust(wave, csps, ewave, lines, **params)
+    sspec = add_igm(wave, sspec, **params)
+    return wave, sspec, lines

From 73275f1af49b96b88934042212cc5bcf44b496cc Mon Sep 17 00:00:00 2001
From: yi-jia-li <yzl466@psu.edu>
Date: Fri, 6 Dec 2024 11:34:37 -0500
Subject: [PATCH 127/132] updata cue model for v2

---
 prospect/_version.py             |  16 +++++
 prospect/models/sedmodel.py      |   5 +-
 prospect/models/templates.py     |  90 ++++++++++++++++++++++++++
 prospect/sources/fake_fsps.py    |   9 +++
 prospect/sources/nebssp_basis.py | 108 +++++++++++++++++++++++++------
 5 files changed, 207 insertions(+), 21 deletions(-)
 create mode 100644 prospect/_version.py

diff --git a/prospect/_version.py b/prospect/_version.py
new file mode 100644
index 00000000..a8e0e216
--- /dev/null
+++ b/prospect/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '1.2.1.dev170+g8f84211.d20241205'
+__version_tuple__ = version_tuple = (1, 2, 1, 'dev170', 'g8f84211.d20241205')
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 355b13ee..ba32808a 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -148,9 +148,8 @@ def predict_init(self, theta, sps):
         self._eline_lum_mle = self._eline_lum.copy()
         if self.params.get('use_eline_nn_unc', False):
             self._eline_lum_covar = np.diag((self.params.get('eline_prior_width', 0.0) *
-                                             self._eline_lum)**2) + 
-                                    (sigma_line_for_fsps *
-                                     self._eline_lum)**2
+                                             self._eline_lum)**2) + (sigma_line_for_fsps * 
+                                                                     self._eline_lum)**2
         else:
             self._eline_lum_covar = np.diag((self.params.get('eline_prior_width', 0.0) *
                                              self._eline_lum)**2)
diff --git a/prospect/models/templates.py b/prospect/models/templates.py
index 7911c03e..d516d78a 100755
--- a/prospect/models/templates.py
+++ b/prospect/models/templates.py
@@ -290,6 +290,96 @@ def adjust_stochastic_params(parset, tuniv=13.7):
                               ("The set of nebular emission parameters, "
                                "with gas_logz tied to stellar logzsol."))
 
+# new nebular parameters from cue
+use_stellar_ionizing = {'N': 1, "isfree": False, "init": False}
+gas_logz = {'N': 1, 'isfree': False,
+            "init": 0.0, 'units': r"log Z/Z_\odot",
+            "prior": priors.TopHat(mini=-2.2, maxi=0.5)}
+
+gas_logu = {"N": 1, 'isfree': False,
+            "init": -2.0, 'units': r"Q_H/N_H",
+            "prior": priors.TopHat(mini=-4.0, maxi=-1.0)}
+
+gas_lognH = {"N": 1, 'isfree': False,
+             "init": 2.0, 'units': r"n_H",
+             "prior": priors.TopHat(mini=1.0, maxi=4.0)}
+
+gas_logno = {"N": 1, 'isfree': False,
+            "init": 0.0, 'units': r"[N/O]",
+            "prior": priors.TopHat(mini=-1.0, maxi=np.log10(5.4))}
+
+gas_logco = {"N": 1, 'isfree': False,
+            "init": 0.0, 'units': r"[C/O]",
+            "prior": priors.TopHat(mini=-1.0, maxi=np.log10(5.4))}
+
+ionspec_index1 = {"N": 1, 'isfree': False,
+                  "init": 3.3, 'units': r"1st power-law index of ionizing spectrum",
+                  "prior": priors.TopHat(mini=1.0, maxi=42.0)}
+
+ionspec_index2 = {"N": 1, 'isfree': False,
+                  "init": 15.0, 'units': r"2nd power-law index of ionizing spectrum",
+                  "prior": priors.TopHat(mini=-0.3, maxi=30.0)}
+
+ionspec_index3 = {"N": 1, 'isfree': False,
+                  "init": 8.0, 'units': r"3rd power-law index of ionizing spectrum",
+                  "prior": priors.TopHat(mini=-1.0, maxi=14.0)}
+
+ionspec_index4 = {"N": 1, 'isfree': False,
+                  "init": 3.0, 'units': r"4th power-law index of ionizing spectrum",
+                  "prior": priors.TopHat(mini=-1.7, maxi=8.0)}
+
+ionspec_logLratio1 = {"N": 1, 'isfree': False,
+                      "init": 2.0, 'units': r"ratio of 2nd and 1st ionizing spectrum segments",
+                      "prior": priors.TopHat(mini=-1.0, maxi=10.1)}
+
+ionspec_logLratio2 = {"N": 1, 'isfree': False,
+                      "init": 1.0, 'units': r"ratio of 3rd and 2nd ionizing spectrum segments",
+                      "prior": priors.TopHat(mini=-0.5, maxi=1.9)}
+
+ionspec_logLratio3 = {"N": 1, 'isfree': False,
+                      "init": 1.0, 'units': r"ratio of 4th and 3rd ionizing spectrum segments",
+                      "prior": priors.TopHat(mini=-0.4, maxi=2.2)}
+
+log_qion = {"N": 1, 'isfree': False,
+            "init": 52.0, 'units': r"log Q_H",
+            "prior": priors.TopHat(mini=35.0, maxi=65.0)}
+
+_cue_nebular_ = {"add_neb_emission": add_neb,
+                 "add_neb_continuum": neb_cont,
+                 "nebemlineinspec": neb_spec,
+                 "use_stellar_ionizing": use_stellar_ionizing,
+                 "gas_logz": gas_logz,
+                 "gas_logu": gas_logu,
+                 "gas_lognH": gas_lognH,
+                 "gas_logno": gas_logno,
+                 "gas_logco": gas_logco,
+                 "ionspec_index1": ionspec_index1,
+                 "ionspec_index2": ionspec_index2,
+                 "ionspec_index3": ionspec_index3,
+                 "ionspec_index4": ionspec_index4,
+                 "ionspec_logLratio1": ionspec_logLratio1,
+                 "ionspec_logLratio2": ionspec_logLratio2,
+                 "ionspec_logLratio3": ionspec_logLratio3,
+                 "gas_logqion": log_qion,
+                 }
+
+TemplateLibrary["cue_nebular"] = (_cue_nebular_,
+                                 ("The set of nebular emission parameters for cue, where ionizing spectrum is free."))
+
+use_stellar_ionizing = {'N': 1, "isfree": False, "init": True}
+_cue_stellar_nebular_ = {"add_neb_emission": add_neb,
+                         "add_neb_continuum": neb_cont,
+                         "nebemlineinspec": neb_spec,
+                         "use_stellar_ionizing": use_stellar_ionizing,
+                         "gas_logz": gas_logz,
+                         "gas_logu": gas_logu,
+                         "gas_lognH": gas_lognH,
+                         "gas_logno": gas_logno,
+                         "gas_logco": gas_logco
+                         }
+TemplateLibrary["cue_stellar_nebular"] = (_cue_stellar_nebular_,
+                                          ("The set of nebular emission parameters for cue, where ionizing spectrum is fixed to young stellar populations from FSPS."))
+
 # -----------------------------------------
 # --- Nebular Emission Marginalization ----
 # -----------------------------------------
diff --git a/prospect/sources/fake_fsps.py b/prospect/sources/fake_fsps.py
index f48efa4c..1f3ecdc6 100644
--- a/prospect/sources/fake_fsps.py
+++ b/prospect/sources/fake_fsps.py
@@ -1,4 +1,13 @@
 import numpy as np
+import os
+
+# index for the 128 emulated emission lines in fsps new line list
+idx = np.array([0,1,2,3,4,5,6,9,13,14,15,16,17,18,19,20,21,22,23,24,24,25,26,28,29,30,31,
+          32,34,35,37,38,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,57,59,61,62,
+          63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,84,85,86,87,88,89,
+          90,91,92,93,94,95,96,97,100,101,101,102,103,104,105,106,107,108,111,112,
+          114,116,118,119,122,123,125,127,129,130,134,137,139,140,143,145,146,148,
+          151,152,153,154,155,156,157,158,159,160,161,162,163,164,165])
 
 __all__ = ["add_dust", "add_igm"]
 
diff --git a/prospect/sources/nebssp_basis.py b/prospect/sources/nebssp_basis.py
index a17afff4..801f698d 100644
--- a/prospect/sources/nebssp_basis.py
+++ b/prospect/sources/nebssp_basis.py
@@ -1,8 +1,8 @@
 ### SSP for cue
 import numpy as np
 
-from .galaxy_basis import FastStepBasis
-from .fake_fsps import add_dust, add_igm
+from .galaxy_basis import FastStepBasis, CSPSpecBasis
+from .fake_fsps import add_dust, add_igm, idx
 
 try:
     import cue
@@ -10,10 +10,10 @@
     pass
 
 
-__all__ = ["NebSSPBasis"]
+__all__ = ["NebStepBasis", "NebCSPBasis"]
 
 
-class NebSSPBasis(FastStepBasis):
+class NebStepBasis(FastStepBasis):
 
     """This is a class that wraps the fsps.StellarPopulation object, which is
     used for producing SSPs.  The ``fsps.StellarPopulation`` object is accessed
@@ -70,20 +70,90 @@ def get_galaxy_spectrum(self, **params):
 
         wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, tage=tmax)
         self._line_specific_luminosity = lines/mtot
-        if self.params.get("nebemlineinspec", False): # mimic the "nebemlineinspec" function in FSPS
-            if self.ssp.params["smooth_velocity"] == True:
-                dlam = self.ssp.emline_wavelengths*self.ssp.params["sigma_smooth"]/2.9979E18*1E13 #smoothing variable is in km/s
-            else:
-                dlam = self.ssp.params["sigma_smooth"] #smoothing variable is in AA
-            nearest_id = np.searchsorted(wave, self.ssp.emline_wavelengths)
-            neb_res_min = wave[nearest_id]-wave[nearest_id-1]
-            dlam = np.max([dlam,neb_res_min], axis=0)
-            gaussnebarr = [1./np.sqrt(2*np.pi)/dlam[i]*np.exp(-(wave-self.ssp.emline_wavelengths[i])**2/2/dlam[i]**2) \
-            /2.9979E18*self.ssp.emline_wavelengths[i]**2 for i in range(len(lines))]
-            for i in range(len(lines)):
-                spec += lines[i]*gaussnebarr[i]
+#         # mimic the "nebemlineinspec" function in FSPS
+#         if self.params.get("nebemlineinspec", False):
+#             if self.ssp.params["smooth_velocity"] == True:
+#                 dlam = self.ssp.emline_wavelengths*self.ssp.params["sigma_smooth"]/2.9979E18*1E13 #smoothing variable is in km/s
+#             else:
+#                 dlam = self.ssp.params["sigma_smooth"] #smoothing variable is in AA
+#             nearest_id = np.searchsorted(wave, self.ssp.emline_wavelengths)
+#             neb_res_min = wave[nearest_id]-wave[nearest_id-1]
+#             dlam = np.max([dlam,neb_res_min], axis=0)
+#             gaussnebarr = [1./np.sqrt(2*np.pi)/dlam[i]*np.exp(-(wave-self.ssp.emline_wavelengths[i])**2/2/dlam[i]**2) \
+#             /2.9979E18*self.ssp.emline_wavelengths[i]**2 for i in range(len(lines))]
+#             for i in range(len(lines)):
+#                 spec += lines[i]*gaussnebarr[i]
         return wave, spec / mtot, self.ssp.stellar_mass / mtot
 
+    
+class NebCSPBasis(FastStepBasis):
+
+    """A subclass of :py:class:`SSPBasis` for combinations of N composite
+    stellar populations (including single-age populations). The number of
+    composite stellar populations is given by the length of the ``"mass"``
+    parameter. Other population properties can also be vectors of the same
+    length as ``"mass"`` if they are independent for each component.
+    """
+
+    def __init__(self, zcontinuous=1, reserved_params=['sigma_smooth'],
+                 vactoair_flag=False, compute_vega_mags=False, 
+                 cue_kwargs={}, **kwargs):
+
+    # This is a StellarPopulation object from fsps
+    self.ssp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
+                                      zcontinuous=zcontinuous,
+                                      vactoair_flag=vactoair_flag)
+    self.emul = cue.Emulator(**cue_kwargs)
+    # we do these now
+    rp = ["dust1", "dust2", "dust3", "add_dust_emission",
+          "add_igm_absorption", "igm_factor",
+          "add_neb_emission", "add_neb_continuum", "nebemlineinspec",
+          "fagn", "agn_tau"]
+    reserved_params = kwargs.pop("reserved_params", []) + rp
+    super().__init__(reserved_params=reserved_params, **kwargs)
+    for k in ["add_igm_absorption", "add_dust_emission", "add_neb_emission", "nebemlineinspec"]:
+        self.ssp.params[k] = False
+
+    def get_galaxy_spectrum(self, **params):
+        """Update parameters, then loop over each component getting a spectrum
+        for each and sum with appropriate weights.
+
+        :param params:
+            A parameter dictionary that gets passed to the ``self.update``
+            method and will generally include physical parameters that control
+            the stellar population and output spectrum or SED.
+
+        :returns wave:
+            Wavelength in angstroms.
+
+        :returns spectrum:
+            Spectrum in units of Lsun/Hz/solar masses formed.
+
+        :returns mass_fraction:
+            Fraction of the formed stellar mass that still exists.
+        """
+        self.update(**params)
+        spectra, linelum = [], []
+        mass = np.atleast_1d(self.params['mass']).copy()
+        mfrac = np.zeros_like(mass)
+        # Loop over mass components
+        for i, m in enumerate(mass):
+            self.update_component(i)
+            wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, 
+                                             tage=self.ssp.params['tage'], peraa=False)
+            spectra.append(spec)
+            mfrac[i] = (self.ssp.stellar_mass)
+            linelum.append(lines)
+
+        # Convert normalization units from per stellar mass to per mass formed
+        if np.all(self.params.get('mass_units', 'mformed') == 'mstar'):
+            mass /= mfrac
+        spectrum = np.dot(mass, np.array(spectra)) / mass.sum()
+        self._line_specific_luminosity = np.dot(mass, np.array(linelum)) / mass.sum()
+        mfrac_sum = np.dot(mass, mfrac) / mass.sum()
+
+        return wave, spectrum, mfrac_sum
+    
 
 def get_spectrum(ssp, params, emul, tage=0):
     """
@@ -105,7 +175,8 @@ def get_spectrum(ssp, params, emul, tage=0):
         lines = [np.zeros_like(ewave), np.zeros_like(ewave)]
     elif add_neb:
         if not use_stars:
-            line_prediction = emul.predict_lines(**params)
+            line_prediction = np.zeros_like(ewave)
+            line_prediction[idx] = emul.predict_lines(**params)
             #if ssp.params["sfh"] == 3:
             #    line_prediction /= mass
             lines = [line_prediction, np.zeros_like(ewave)]
@@ -114,7 +185,8 @@ def get_spectrum(ssp, params, emul, tage=0):
             for spec in csps:
                 ion_params = cue.fit_4loglinear_ionparam(wave, spec)
                 params.update(**ion_params)
-                line_prediction = emul.predict_lines(**params)
+                line_prediction = np.zeros_like(ewave)
+                line_prediction[idx] = emul.predict_lines(**params)
                 #if ssp.params["sfh"] == 3:
                 #    line_prediction /= mass
                 lines.append(line_prediction)

From 150b64f596486cb478ee190cac35cd78a30ac6ba Mon Sep 17 00:00:00 2001
From: yi-jia-li <yzl466@psu.edu>
Date: Sun, 18 May 2025 03:59:28 -0400
Subject: [PATCH 128/132] use cuejax to predict nebular emission

---
 README.md                        |   9 ++
 prospect/_version.py             |  16 ---
 prospect/models/sedmodel.py      |  16 ++-
 prospect/models/templates.py     |  26 ++---
 prospect/sources/fake_fsps.py    |  12 +-
 prospect/sources/nebssp_basis.py | 189 +++++++++++++++++++++++-------
 tests/test_cue_eline.py          | 192 +++++++++++++++++++++++++++++++
 7 files changed, 376 insertions(+), 84 deletions(-)
 delete mode 100644 prospect/_version.py
 create mode 100644 tests/test_cue_eline.py

diff --git a/README.md b/README.md
index 57a95449..9758af2f 100644
--- a/README.md
+++ b/README.md
@@ -31,6 +31,15 @@ Work to do includes:
 - [ ] Test smoothing accounting for library, instrumental & physical smoothing
 - [ ] Implement an emulator-based SpecModel class
 
+Nebular emission is computed using [`cuejax`](https://github.com/efburnham/cue), a jax-compatible version of `cue` ([Li et al. 2024](https://ui.adsabs.harvard.edu/abs/2024arXiv240504598L/abstract)). 
+`cuejax` requires [`E-FSPS`](https://github.com/efburnham/E-FSPS), a emulator-based stellar population synthesis (SPS) framework.
+The ionizing spectrum that powers the nebular emission can either be modeled as a 4-segment power-law or fixed to the spectrum of stellar populations:
+```py
+from prospect.models.templates import TemplateLibrary
+TemplateLibrary["cue_nebular"] # Uses a power-law ionizing spectrum
+TemplateLibrary["cue_stellar_nebular"] # Uses the stellar ionizing spectrum
+```
+**Note:** Dust emission is not yet implemented for compatibility with nebular emission.
 
 
 Migration from < v2.0
diff --git a/prospect/_version.py b/prospect/_version.py
deleted file mode 100644
index a8e0e216..00000000
--- a/prospect/_version.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# file generated by setuptools_scm
-# don't change, don't track in version control
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple, Union
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-else:
-    VERSION_TUPLE = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-
-__version__ = version = '1.2.1.dev170+g8f84211.d20241205'
-__version_tuple__ = version_tuple = (1, 2, 1, 'dev170', 'g8f84211.d20241205')
diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index ba32808a..33cd7f83 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -453,14 +453,20 @@ def init_eline_info(self, eline_file='emlines_info.dat'):
 
         # get the emission line info
         try:
-            SPS_HOME = os.getenv('SPS_HOME')
-            info = np.genfromtxt(os.path.join(SPS_HOME, 'data', eline_file),
-                                 dtype=[('wave', 'f8'), ('name', '<U20')],
-                                 delimiter=',')
+            if self.params.get("use_stellar_ionizing") is None:
+                SPS_HOME = os.getenv('SPS_HOME')
+                info = np.genfromtxt(os.path.join(SPS_HOME, 'data', eline_file),
+                                     dtype=[('wave', 'f8'), ('name', '<U20')],
+                                     delimiter=',')
+            else:
+                from pkg_resources import resource_filename
+                info = np.genfromtxt(resource_filename("cue", "data/cue_emlines_info.dat"),
+                                     dtype=[('wave', 'f8'), ('name', '<U20')],
+                                     delimiter=',')
             self.emline_info = info
             self._use_eline = np.ones(len(info), dtype=bool)
         except(OSError, KeyError, ValueError) as e:
-            print("Could not read and cache emission line info from $SPS_HOME/data/emlines_info.dat")
+            print("Could not read and cache emission line info")
             self.emline_info = e
 
     @property
diff --git a/prospect/models/templates.py b/prospect/models/templates.py
index d516d78a..b21927d2 100755
--- a/prospect/models/templates.py
+++ b/prospect/models/templates.py
@@ -292,55 +292,55 @@ def adjust_stochastic_params(parset, tuniv=13.7):
 
 # new nebular parameters from cue
 use_stellar_ionizing = {'N': 1, "isfree": False, "init": False}
-gas_logz = {'N': 1, 'isfree': False,
+gas_logz = {'N': 1, 'isfree': True,
             "init": 0.0, 'units': r"log Z/Z_\odot",
             "prior": priors.TopHat(mini=-2.2, maxi=0.5)}
 
-gas_logu = {"N": 1, 'isfree': False,
+gas_logu = {"N": 1, 'isfree': True,
             "init": -2.0, 'units': r"Q_H/N_H",
             "prior": priors.TopHat(mini=-4.0, maxi=-1.0)}
 
-gas_lognH = {"N": 1, 'isfree': False,
+gas_lognH = {"N": 1, 'isfree': True,
              "init": 2.0, 'units': r"n_H",
              "prior": priors.TopHat(mini=1.0, maxi=4.0)}
 
-gas_logno = {"N": 1, 'isfree': False,
+gas_logno = {"N": 1, 'isfree': True,
             "init": 0.0, 'units': r"[N/O]",
             "prior": priors.TopHat(mini=-1.0, maxi=np.log10(5.4))}
 
-gas_logco = {"N": 1, 'isfree': False,
+gas_logco = {"N": 1, 'isfree': True,
             "init": 0.0, 'units': r"[C/O]",
             "prior": priors.TopHat(mini=-1.0, maxi=np.log10(5.4))}
 
-ionspec_index1 = {"N": 1, 'isfree': False,
+ionspec_index1 = {"N": 1, 'isfree': True,
                   "init": 3.3, 'units': r"1st power-law index of ionizing spectrum",
                   "prior": priors.TopHat(mini=1.0, maxi=42.0)}
 
-ionspec_index2 = {"N": 1, 'isfree': False,
+ionspec_index2 = {"N": 1, 'isfree': True,
                   "init": 15.0, 'units': r"2nd power-law index of ionizing spectrum",
                   "prior": priors.TopHat(mini=-0.3, maxi=30.0)}
 
-ionspec_index3 = {"N": 1, 'isfree': False,
+ionspec_index3 = {"N": 1, 'isfree': True,
                   "init": 8.0, 'units': r"3rd power-law index of ionizing spectrum",
                   "prior": priors.TopHat(mini=-1.0, maxi=14.0)}
 
-ionspec_index4 = {"N": 1, 'isfree': False,
+ionspec_index4 = {"N": 1, 'isfree': True,
                   "init": 3.0, 'units': r"4th power-law index of ionizing spectrum",
                   "prior": priors.TopHat(mini=-1.7, maxi=8.0)}
 
-ionspec_logLratio1 = {"N": 1, 'isfree': False,
+ionspec_logLratio1 = {"N": 1, 'isfree': True,
                       "init": 2.0, 'units': r"ratio of 2nd and 1st ionizing spectrum segments",
                       "prior": priors.TopHat(mini=-1.0, maxi=10.1)}
 
-ionspec_logLratio2 = {"N": 1, 'isfree': False,
+ionspec_logLratio2 = {"N": 1, 'isfree': True,
                       "init": 1.0, 'units': r"ratio of 3rd and 2nd ionizing spectrum segments",
                       "prior": priors.TopHat(mini=-0.5, maxi=1.9)}
 
-ionspec_logLratio3 = {"N": 1, 'isfree': False,
+ionspec_logLratio3 = {"N": 1, 'isfree': True,
                       "init": 1.0, 'units': r"ratio of 4th and 3rd ionizing spectrum segments",
                       "prior": priors.TopHat(mini=-0.4, maxi=2.2)}
 
-log_qion = {"N": 1, 'isfree': False,
+log_qion = {"N": 1, 'isfree': True,
             "init": 52.0, 'units': r"log Q_H",
             "prior": priors.TopHat(mini=35.0, maxi=65.0)}
 
diff --git a/prospect/sources/fake_fsps.py b/prospect/sources/fake_fsps.py
index 1f3ecdc6..a21e864a 100644
--- a/prospect/sources/fake_fsps.py
+++ b/prospect/sources/fake_fsps.py
@@ -12,7 +12,7 @@
 __all__ = ["add_dust", "add_igm"]
 
 
-def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=0.0,dust1=0.0,**kwargs):
+def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=-1.0,dust1=0.0,**kwargs):
     """
     wave: wavelength vector in Angstroms
     specs: spectral flux density, in (young, old) pairs
@@ -30,16 +30,16 @@ def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=0.0,dust2=0.0,du
         else:
             d1 = 0.0
 
-        attenuated_specs[i] = attenuate(spec,wave,dust_type=dust_type,dust_index=dust_index,dust2=dust2,dust1_index=dust1_index,dust1=d1)
-        attenuated_lines[i] = attenuate(line,line_waves,dust_type=dust_type,dust_index=dust_index,dust2=dust2,dust1_index=dust1_index,dust1=d1)
-
+        attenuated_lines[i], diff_dust = attenuate(line,line_waves,dust_type=dust_type,dust_index=dust_index,dust2=dust2,dust1_index=dust1_index,dust1=d1)
+        attenuated_specs[i], diff_dust = attenuate(spec,wave,dust_type=dust_type,dust_index=dust_index,dust2=dust2,dust1_index=dust1_index,dust1=d1)
+        
     attenuated_specs = attenuated_specs[0] + attenuated_specs[1]
     attenuated_lines = attenuated_lines[0] + attenuated_lines[1]
     return attenuated_specs, attenuated_lines
 
 
 def attenuate(spec,lam,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=0.0,dust1=0.0):
-    """returns F(obs) / F(emitted) for a given attenuation curve + dust1 + dust2
+    """returns F(obs) for a given attenuation curve + dust1 + dust2
     """
 
     ### constants from FSPS
@@ -136,7 +136,7 @@ def attenuate(spec,lam,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=0.0,dust
 
     ext_tot = dust2_ext*dust1_ext
 
-    return ext_tot*spec
+    return ext_tot*spec, dust2_ext
 
 def add_igm(wave, spec, zred=0., igm_factor=1.0, add_igm_absorption=None, **kwargs):
     """IGM absorption based on Madau+1995
diff --git a/prospect/sources/nebssp_basis.py b/prospect/sources/nebssp_basis.py
index 801f698d..63d9947d 100644
--- a/prospect/sources/nebssp_basis.py
+++ b/prospect/sources/nebssp_basis.py
@@ -1,11 +1,14 @@
 ### SSP for cue
 import numpy as np
+from pkg_resources import resource_filename
 
+import fsps
 from .galaxy_basis import FastStepBasis, CSPSpecBasis
 from .fake_fsps import add_dust, add_igm, idx
 
 try:
-    import cue
+    import cuejax as cue
+    from cuejax import Emulator
 except:
     pass
 
@@ -43,7 +46,7 @@ class NebStepBasis(FastStepBasis):
     def __init__(self, cue_kwargs={},
                  **kwargs):
 
-        self.emul = cue.Emulator(**cue_kwargs)
+        self.emul = Emulator(**cue_kwargs)
         # we do these now
         rp = ["dust1", "dust2", "dust3", "add_dust_emission",
               "add_igm_absorption", "igm_factor",
@@ -53,6 +56,10 @@ def __init__(self, cue_kwargs={},
         super().__init__(reserved_params=reserved_params, **kwargs)
         for k in ["add_igm_absorption", "add_dust_emission", "add_neb_emission", "nebemlineinspec"]:
             self.ssp.params[k] = False
+            
+        self.emline_wavelengths = np.genfromtxt(resource_filename("cue", "data/cue_emlines_info.dat"),
+                                                dtype=[('wave', 'f8'), ('name', '<U20')],
+                                                delimiter=',')['wave']
 
     def get_galaxy_spectrum(self, **params):
         """Construct the tabular SFH and feed it to the ``ssp``.
@@ -68,25 +75,56 @@ def get_galaxy_spectrum(self, **params):
         self.ssp.params["sfh"] = 3  # Hack to avoid rewriting the superclass
         self.ssp.set_tabular_sfh(time, sfr)
 
-        wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, tage=tmax)
+        wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, self.emline_wavelengths, tage=tmax)
         self._line_specific_luminosity = lines/mtot
-#         # mimic the "nebemlineinspec" function in FSPS
-#         if self.params.get("nebemlineinspec", False):
-#             if self.ssp.params["smooth_velocity"] == True:
-#                 dlam = self.ssp.emline_wavelengths*self.ssp.params["sigma_smooth"]/2.9979E18*1E13 #smoothing variable is in km/s
-#             else:
-#                 dlam = self.ssp.params["sigma_smooth"] #smoothing variable is in AA
-#             nearest_id = np.searchsorted(wave, self.ssp.emline_wavelengths)
-#             neb_res_min = wave[nearest_id]-wave[nearest_id-1]
-#             dlam = np.max([dlam,neb_res_min], axis=0)
-#             gaussnebarr = [1./np.sqrt(2*np.pi)/dlam[i]*np.exp(-(wave-self.ssp.emline_wavelengths[i])**2/2/dlam[i]**2) \
-#             /2.9979E18*self.ssp.emline_wavelengths[i]**2 for i in range(len(lines))]
-#             for i in range(len(lines)):
-#                 spec += lines[i]*gaussnebarr[i]
+        # mimic the "nebemlineinspec" function in FSPS
+        if self.params.get("nebemlineinspec", False):
+            if self.ssp.params["smooth_velocity"] == True:
+                dlam = self.emline_wavelengths*self.ssp.params["sigma_smooth"]/2.9979E18*1E13 #smoothing variable is in km/s
+            else:
+                dlam = self.ssp.params["sigma_smooth"] #smoothing variable is in AA
+            nearest_id = np.searchsorted(wave, self.emline_wavelengths)
+            neb_res_min = wave[nearest_id]-wave[nearest_id-1]
+            dlam = np.max([dlam,neb_res_min*2], axis=0)
+            gaussnebarr = [1./np.sqrt(2*np.pi)/dlam[i]*np.exp(-(wave-self.emline_wavelengths[i])**2/2/dlam[i]**2) \
+            /2.9979E18*self.emline_wavelengths[i]**2 for i in range(len(lines))]
+            for i in range(len(lines)):
+                spec += lines[i]*gaussnebarr[i]
         return wave, spec / mtot, self.ssp.stellar_mass / mtot
 
+    def get_galaxy_elines(self):
+        """Get the wavelengths and specific emission line luminosity of the nebular emission lines
+        predicted by FSPS. These lines are in units of Lsun/solar mass formed.
+        This assumes that `get_galaxy_spectrum` has already been called.
+
+        :returns ewave:
+            The *restframe* wavelengths of the emission lines, AA
+
+        :returns elum:
+            Specific luminosities of the nebular emission lines,
+            Lsun/stellar mass formed
+        """
+        
+        # This allows subclasses to set their own specific emission line
+        # luminosities within other methods, e.g., get_galaxy_spectrum, by
+        # populating the `_specific_line_luminosity` attribute.
+        elum = getattr(self, "_line_specific_luminosity", None)
+        ewave = self.emline_wavelengths
+        
+        if elum is None:
+            ewave = self.ssp.emline_wavelengths
+            elum = self.ssp.emline_luminosity.copy()
+            if elum.ndim > 1:
+                elum = elum[0]
+            if self.ssp.params["sfh"] == 3:
+                # tabular sfh
+                mass = np.sum(self.params.get('mass', 1.0))
+                elum /= mass
+
+        return ewave, elum
+
     
-class NebCSPBasis(FastStepBasis):
+class NebCSPBasis(CSPSpecBasis):
 
     """A subclass of :py:class:`SSPBasis` for combinations of N composite
     stellar populations (including single-age populations). The number of
@@ -99,20 +137,24 @@ def __init__(self, zcontinuous=1, reserved_params=['sigma_smooth'],
                  vactoair_flag=False, compute_vega_mags=False, 
                  cue_kwargs={}, **kwargs):
 
-    # This is a StellarPopulation object from fsps
-    self.ssp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
-                                      zcontinuous=zcontinuous,
-                                      vactoair_flag=vactoair_flag)
-    self.emul = cue.Emulator(**cue_kwargs)
-    # we do these now
-    rp = ["dust1", "dust2", "dust3", "add_dust_emission",
-          "add_igm_absorption", "igm_factor",
-          "add_neb_emission", "add_neb_continuum", "nebemlineinspec",
-          "fagn", "agn_tau"]
-    reserved_params = kwargs.pop("reserved_params", []) + rp
-    super().__init__(reserved_params=reserved_params, **kwargs)
-    for k in ["add_igm_absorption", "add_dust_emission", "add_neb_emission", "nebemlineinspec"]:
-        self.ssp.params[k] = False
+        # This is a StellarPopulation object from fsps
+        self.ssp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
+                                          zcontinuous=zcontinuous,
+                                          vactoair_flag=vactoair_flag)
+        self.emul = Emulator(**cue_kwargs)
+        # we do these now
+        rp = ["dust1", "dust2", "dust3", "add_dust_emission",
+              "add_igm_absorption", "igm_factor",
+              "add_neb_emission", "add_neb_continuum", "nebemlineinspec",
+              "fagn", "agn_tau"]
+        reserved_params = kwargs.pop("reserved_params", []) + rp
+        super().__init__(reserved_params=reserved_params, **kwargs)
+        for k in ["add_igm_absorption", "add_dust_emission", "add_neb_emission", "nebemlineinspec"]:
+            self.ssp.params[k] = False
+            
+        self.emline_wavelengths = np.genfromtxt(resource_filename("cue", "data/cue_emlines_info.dat"),
+                                                dtype=[('wave', 'f8'), ('name', '<U20')],
+                                                delimiter=',')['wave']
 
     def get_galaxy_spectrum(self, **params):
         """Update parameters, then loop over each component getting a spectrum
@@ -139,8 +181,8 @@ def get_galaxy_spectrum(self, **params):
         # Loop over mass components
         for i, m in enumerate(mass):
             self.update_component(i)
-            wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, 
-                                             tage=self.ssp.params['tage'], peraa=False)
+            wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, self.emline_wavelengths,
+                                             tage=self.ssp.params['tage'])
             spectra.append(spec)
             mfrac[i] = (self.ssp.stellar_mass)
             linelum.append(lines)
@@ -148,14 +190,74 @@ def get_galaxy_spectrum(self, **params):
         # Convert normalization units from per stellar mass to per mass formed
         if np.all(self.params.get('mass_units', 'mformed') == 'mstar'):
             mass /= mfrac
+        
+        # mimic the "nebemlineinspec" function in FSPS
+        if self.params.get("nebemlineinspec", False):
+            if self.ssp.params["smooth_velocity"] == True:
+                dlam = self.emline_wavelengths*self.ssp.params["sigma_smooth"]/2.9979E18*1E13 #smoothing variable is in km/s
+            else:
+                dlam = self.ssp.params["sigma_smooth"] #smoothing variable is in AA
+            nearest_id = np.searchsorted(wave, self.emline_wavelengths)
+            neb_res_min = wave[nearest_id]-wave[nearest_id-1]
+            dlam = np.max([dlam,neb_res_min*2], axis=0)
+            for spec_id in range(len(spectra)):
+                gaussnebarr = [1./np.sqrt(2*np.pi)/dlam[i]*np.exp(-(wave-self.emline_wavelengths[i])**2/2/dlam[i]**2) \
+                /2.9979E18*self.emline_wavelengths[i]**2 for i in range(len(linelum[spec_id]))]
+                for i in range(len(linelum[spec_id])):
+                    spectra[spec_id] += linelum[spec_id][i]*gaussnebarr[i]
+
         spectrum = np.dot(mass, np.array(spectra)) / mass.sum()
         self._line_specific_luminosity = np.dot(mass, np.array(linelum)) / mass.sum()
         mfrac_sum = np.dot(mass, mfrac) / mass.sum()
+        return wave, spectrum, mfrac_sum  
+    
+    def get_galaxy_elines(self):
+        """Get the wavelengths and specific emission line luminosity of the nebular emission lines
+        predicted by FSPS. These lines are in units of Lsun/solar mass formed.
+        This assumes that `get_galaxy_spectrum` has already been called.
+
+        :returns ewave:
+            The *restframe* wavelengths of the emission lines, AA
 
-        return wave, spectrum, mfrac_sum
+        :returns elum:
+            Specific luminosities of the nebular emission lines,
+            Lsun/stellar mass formed
+        """
+        
+        # This allows subclasses to set their own specific emission line
+        # luminosities within other methods, e.g., get_galaxy_spectrum, by
+        # populating the `_specific_line_luminosity` attribute.
+        elum = getattr(self, "_line_specific_luminosity", None)
+        ewave = self.emline_wavelengths
+        
+        if elum is None:
+            ewave = self.ssp.emline_wavelengths
+            elum = self.ssp.emline_luminosity.copy()
+            if elum.ndim > 1:
+                elum = elum[0]
+            if self.ssp.params["sfh"] == 3:
+                # tabular sfh
+                mass = np.sum(self.params.get('mass', 1.0))
+                elum /= mass
+
+        return ewave, elum
     
 
-def get_spectrum(ssp, params, emul, tage=0):
+cue_keys = ['gas_logz',
+            'gas_logu',
+            'gas_lognH',
+            'gas_logno',
+            'gas_logco',
+            'ionspec_index1',
+            'ionspec_index2',
+            'ionspec_index3',
+            'ionspec_index4',
+            'ionspec_logLratio1',
+            'ionspec_logLratio2',
+            'ionspec_logLratio3',
+            'gas_logqion',]
+
+def get_spectrum(ssp, params, emul, ewave, tage=0):
     """
     Add the nebular continuum from Cue to the young and old population and do the dust attenuation and igm absorption.
     Also, calculate the line luminoisities from the young csp and old csp and do the dust attenuation and igm absorption.
@@ -165,7 +267,7 @@ def get_spectrum(ssp, params, emul, tage=0):
     """
     add_neb = params["add_neb_emission"]
     use_stars = params["use_stellar_ionizing"]
-    ewave = ssp.emline_wavelengths
+    #params = {k: v.item() if isinstance(v, np.ndarray) else v for k, v in params.items()}
     wave, tspec = ssp.get_spectrum(tage=tage, peraa=False)
     young, old = ssp._csp_young_old
     csps = [young, old] # could combine with previous line
@@ -174,26 +276,25 @@ def get_spectrum(ssp, params, emul, tage=0):
     if not add_neb:
         lines = [np.zeros_like(ewave), np.zeros_like(ewave)]
     elif add_neb:
+        cue_params = {k: v.item() if hasattr(v, 'item') else v for k, v in params.items() if k in cue_keys}
         if not use_stars:
-            line_prediction = np.zeros_like(ewave)
-            line_prediction[idx] = emul.predict_lines(**params)
+            line_prediction = np.squeeze(emul.predict_lines(**cue_params))
             #if ssp.params["sfh"] == 3:
             #    line_prediction /= mass
             lines = [line_prediction, np.zeros_like(ewave)]
-            csps[0][wave>=912] += emul.predict_cont(wave[wave>=912], **params)
+            csps[0][wave>=912] += np.squeeze(emul.predict_cont(wave[wave>=912], unit='Lsun/Hz', **cue_params))
         elif use_stars:
             for spec in csps:
                 ion_params = cue.fit_4loglinear_ionparam(wave, spec)
-                params.update(**ion_params)
-                line_prediction = np.zeros_like(ewave)
-                line_prediction[idx] = emul.predict_lines(**params)
+                cue_params.update(**ion_params)
+                line_prediction = np.squeeze(emul.predict_lines(**cue_params))
                 #if ssp.params["sfh"] == 3:
                 #    line_prediction /= mass
                 lines.append(line_prediction)
-                spec[wave>=912] += emul.predict_cont(wave[wave>=912], **params)
+                spec[wave>=912] += np.squeeze(emul.predict_cont(wave[wave>=912], unit='Lsun/Hz', **cue_params))
         else:
             raise KeyError('No "use_stellar_ionizing" in model')
 
-    sspec, lines = add_dust(wave, csps, ewave, lines, **params)
+    sspec, lines = add_dust(wave, csps, ewave, lines, dust1_index=ssp.params['dust1_index'], **params)
     sspec = add_igm(wave, sspec, **params)
     return wave, sspec, lines
diff --git a/tests/test_cue_eline.py b/tests/test_cue_eline.py
new file mode 100644
index 00000000..a4443871
--- /dev/null
+++ b/tests/test_cue_eline.py
@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+
+import pytest
+
+from sedpy import observate
+
+from prospect.observation import from_oldstyle
+from prospect.models.templates import TemplateLibrary
+from prospect.models.sedmodel import SpecModel
+from prospect.sources.nebssp_basis import NebStepBasis, NebCSPBasis
+
+@pytest.fixture
+def get_sps():
+    sps = CSPSpecBasis(zcontinuous=1)
+    return sps
+
+
+# test nebular line specification
+def test_eline_parsing():
+    model_pars = TemplateLibrary["parametric_sfh"]
+    model_pars.update(TemplateLibrary["cue_nebular"])
+
+    # test ignoring a line
+    lya = "Ly-alpha 1215"
+    model_pars["elines_to_ignore"] = dict(init=lya, isfree=False)
+    model = SpecModel(model_pars)
+    model.parse_elines()
+    assert not np.isin(lya, model.emline_info["name"][model._use_eline])
+    assert np.isin("Ba-alpha 6563", model.emline_info["name"][model._use_eline])
+    assert np.all(model._fix_eline)
+    assert model._use_eline.sum() == len(model._use_eline) - 1
+    assert len(model._use_eline) == len(model.emline_info)
+
+    # test fitting all the non-ignored lines
+    model_pars["marginalize_elines"] = dict(init=True)
+    model = SpecModel(model_pars)
+    model.parse_elines()
+    assert model._fit_eline.sum() == len(model._use_eline)
+
+    # test fitting just a line or two
+    fit_lines = ["[O III] 5007"]
+    model_pars["elines_to_fit"] = dict(init=fit_lines)
+    model = SpecModel(model_pars)
+    model.parse_elines()
+    assert model._fit_eline.sum() == len(fit_lines)
+    assert model._fix_eline.sum() == (len(model._use_eline) - len(fit_lines))
+
+    # test fixing a line
+    _ = model_pars.pop("elines_to_fit")
+    fix_lines = ["H beta 4861"]
+    model_pars["elines_to_fix"] = dict(init=fit_lines)
+    model = SpecModel(model_pars)
+    model.parse_elines()
+    assert model._fix_eline.sum() == len(fix_lines)
+    assert model._fit_eline.sum() == (len(model._use_eline) - len(fix_lines))
+
+
+def build_obs(filts):
+    obs = dict(filters=filts,
+               wavelength=np.linspace(3000, 9000, 1000),
+               spectrum=np.ones(1000),
+               unc=np.ones(1000)*0.1,
+               maggies=np.ones(len(filts))*1e-7,
+               maggies_unc=np.ones(len(filts))*1e-8)
+    sdat, pdat = from_oldstyle(obs)
+    obslist = [sdat, pdat]
+    [obs.rectify() for obs in obslist]
+    return obslist
+
+
+def test_nebline_phot_addition(get_sps):
+    fnames = [f"sdss_{b}0" for b in "ugriz"]
+    filts = observate.load_filters(fnames)
+    obslist = build_obs(filts)
+
+    sps = get_sps
+
+    # Make emission lines more prominent
+    zred = 1.0
+
+    # add nebline photometry in FSPS
+    model_pars = TemplateLibrary["parametric_sfh"]
+    model_pars["zred"]["init"] = zred
+    model_pars.update(TemplateLibrary["cue_nebular"])
+    m1 = SpecModel(model_pars)
+
+    # adding nebline photometry by hand
+    model_pars = TemplateLibrary["parametric_sfh"]
+    model_pars["zred"]["init"] = zred
+    model_pars.update(TemplateLibrary["cue_nebular"])
+    model_pars["nebemlineinspec"]["init"] = False
+    m2 = SpecModel(model_pars)
+
+    (s1, p1), _ = m1.predict(m1.theta, obslist, sps)
+    (s2, p2), _ = m2.predict(m2.theta, obslist, sps)
+
+    # make sure some of the lines were important
+    p1n = m1.nebline_photometry(filts)
+    assert np.any(p1n / p1[1] > 0.05)
+
+    # make sure you got the same-ish answer
+    assert np.all((np.abs(p1 - p2) / p1) < 1e-2)
+
+
+def test_filtersets(get_sps):
+    """This test no longer relevant.....
+    """
+    fnames = [f"sdss_{b}0" for b in "ugriz"]
+    flist = observate.load_filters(fnames)
+    obslist = build_obs(flist)
+    sdat, pdat = obslist
+
+    sps = get_sps
+
+    # Make emission lines more prominent
+    zred = 0.5
+    models = []
+
+    # test SpecModel no nebular emission
+    model_pars = TemplateLibrary["parametric_sfh"]
+    model_pars["zred"]["init"] = zred
+    models.append(SpecModel(model_pars))
+
+    # test SpecModel with nebular emission added by SpecModel
+    model_pars = TemplateLibrary["parametric_sfh"]
+    model_pars["zred"]["init"] = zred
+    model_pars.update(TemplateLibrary["cue_nebular"])
+    model_pars["nebemlineinspec"]["init"] = False
+    models.append(SpecModel(model_pars))
+
+    for i, model in enumerate(models):
+        (_, pset), _ = model.predict(model.theta, obslist, sps)
+
+        # make sure some of the filters are affected by lines
+        # ( nebular flux > 10% of total flux)
+        if i == 1:
+            nebphot = model.nebline_photometry(pdat.filterset)
+            assert np.any(nebphot / pset > 0.1)
+
+        # make sure photometry is consistent
+        # make sure we actually used different filter types
+        # We always use filtersets now
+
+
+def test_eline_implementation(get_sps, plot=False):
+
+    test_eline_parsing()
+
+    filters = observate.load_filters([f"sdss_{b}0" for b in "ugriz"])
+    obslist = build_obs(filters)
+
+    model_pars = TemplateLibrary["parametric_sfh"]
+    model_pars.update(TemplateLibrary["cue_nebular"])
+    model_pars["nebemlineinspec"]["init"] = False
+    model_pars["eline_sigma"] = dict(init=500)
+    model_pars["zred"]["init"] = 4
+    model = SpecModel(model_pars)
+
+    sps = get_sps
+
+    # generate with all fixed lines added
+    (spec, phot), mfrac = model.predict(model.theta, obslist, sps=sps)
+
+    # test ignoring a line
+    lya = "Ly-alpha 1215"
+    model_pars["elines_to_ignore"] = dict(init=lya, isfree=False)
+    model = SpecModel(model_pars)
+    (spec_nolya, phot_nolya), mfrac = model.predict(model.theta, obslist, sps=sps)
+    assert np.any((phot - phot_nolya) / phot != 0.0)
+    lint = np.trapz(spec - spec_nolya, obslist[0]["wavelength"])
+    assert lint > 0
+
+    # test igoring a line, phot only
+    model = SpecModel(model_pars)
+    (phot_nolya_2,), mfrac = model.predict(model.theta, [obslist[1]], sps=sps)
+    assert np.all(phot_nolya == phot_nolya_2)
+
+    if plot:
+        import matplotlib.pyplot as pl
+        pl.ion()
+        fig, ax = pl.subplots()
+        ax.plot(obslist[0]["wavelength"], spec)
+        ax.plot(obslist[0]["wavelength"], spec_nolya)
+
+
+#def test_marginalizing_lines():
+    # test marginalizing over lines
+    #model_pars["marginalize_elines"] = dict(init=True)
+    #model = SpecModel(model_pars)

From 1003f968879c21436ca57a863d07dacec88c6621 Mon Sep 17 00:00:00 2001
From: yi-jia-li <yzl466@psu.edu>
Date: Sun, 18 May 2025 09:12:29 -0400
Subject: [PATCH 129/132] implement dust emission

---
 README.md                        |   4 +-
 prospect/sources/fake_fsps.py    | 445 ++++++++++++++++++++++++++++++-
 prospect/sources/nebssp_basis.py |   4 +-
 3 files changed, 446 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 9758af2f..9facb8cc 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ Work to do includes:
 - [ ] Test smoothing accounting for library, instrumental & physical smoothing
 - [ ] Implement an emulator-based SpecModel class
 
-Nebular emission is computed using [`cuejax`](https://github.com/efburnham/cue), a jax-compatible version of `cue` ([Li et al. 2024](https://ui.adsabs.harvard.edu/abs/2024arXiv240504598L/abstract)). 
+Nebular emission is computed using [`cuejax`](https://github.com/efburnham/cue), a jax-compatible version of [`cue`](https://github.com/yi-jia-li/cue) ([Li et al. 2024](https://ui.adsabs.harvard.edu/abs/2024arXiv240504598L/abstract)). 
 `cuejax` requires [`E-FSPS`](https://github.com/efburnham/E-FSPS), a emulator-based stellar population synthesis (SPS) framework.
 The ionizing spectrum that powers the nebular emission can either be modeled as a 4-segment power-law or fixed to the spectrum of stellar populations:
 ```py
@@ -39,8 +39,6 @@ from prospect.models.templates import TemplateLibrary
 TemplateLibrary["cue_nebular"] # Uses a power-law ionizing spectrum
 TemplateLibrary["cue_stellar_nebular"] # Uses the stellar ionizing spectrum
 ```
-**Note:** Dust emission is not yet implemented for compatibility with nebular emission.
-
 
 Migration from < v2.0
 ---------------------
diff --git a/prospect/sources/fake_fsps.py b/prospect/sources/fake_fsps.py
index a21e864a..835354a1 100644
--- a/prospect/sources/fake_fsps.py
+++ b/prospect/sources/fake_fsps.py
@@ -1,6 +1,15 @@
 import numpy as np
 import os
 
+from efsps.sources.constants import lyman_limit
+from efsps.sources.transforms import maggies_to_cgs
+from efsps.models import priors, NebModel
+import jax.numpy as jnp
+import jax
+from pathlib import Path
+
+
+
 # index for the 128 emulated emission lines in fsps new line list
 idx = np.array([0,1,2,3,4,5,6,9,13,14,15,16,17,18,19,20,21,22,23,24,24,25,26,28,29,30,31,
           32,34,35,37,38,39,40,41,43,44,45,46,47,48,49,50,51,52,53,54,57,59,61,62,
@@ -34,8 +43,18 @@ def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=0.0,dust2=0.0,du
         attenuated_specs[i], diff_dust = attenuate(spec,wave,dust_type=dust_type,dust_index=dust_index,dust2=dust2,dust1_index=dust1_index,dust1=d1)
         
     attenuated_specs = attenuated_specs[0] + attenuated_specs[1]
-    attenuated_lines = attenuated_lines[0] + attenuated_lines[1]
-    return attenuated_specs, attenuated_lines
+    attenuated_lines = attenuated_lines[0] + attenuated_lines[1] 
+    
+    if kwargs.get("add_dust_emission", None):
+        dust_specs = DustEmission(dust_file = os.getenv('SPS_HOME'),
+                                  spec_lambda = wave, **kwargs).compute_dust_emission(
+            attenuated_specs, specs[0]+specs[1], wave, 
+            diff_dust, attenuated_lines, lines[0]+lines[1])[0]
+        return dust_specs, attenuated_lines
+    
+    else:
+        return attenuated_specs, attenuated_lines
+
 
 
 def attenuate(spec,lam,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=0.0,dust1=0.0):
@@ -184,3 +203,425 @@ def add_igm(wave, spec, zred=0., igm_factor=1.0, add_igm_absorption=None, **kwar
     res = spec*np.exp(-tau*igm_factor)
     tiny_number = 10**(-70.0)
     return np.clip(res, a_min=tiny_number, a_max=None)
+
+
+def build_cue_model(ionspec_index1=19.7, ionspec_index2=5.3, ionspec_index3=1.6, ionspec_index4=0.6,
+                 ionspec_logLratio1=3.9, ionspec_logLratio2=0.01, ionspec_logLratio3=0.2,
+                 gas_logu=-2.5, gas_logn=2, gas_logz=0., gas_logno=0., gas_logco=0.,
+                 gas_logqion=49.1,num_lines=138,**extras):
+
+    params = {}
+
+    params['ionspec_index1'] = {"N": 1, 'isfree': True,
+            'init': ionspec_index1, 
+            'prior': priors.UniformPrior(min=1, max=42)
+                         }
+    params['ionspec_index2'] = {"N": 1, 'isfree': True,
+            'init': ionspec_index2, 
+            'prior': priors.UniformPrior(min=-0.3, max=30)
+                         }
+    params['ionspec_index3'] = {"N": 1, 'isfree': True,
+            'init': ionspec_index3, 
+            'prior': priors.UniformPrior(min=-1, max=14)
+                         }
+    params['ionspec_index4'] = {"N": 1, 'isfree': True,
+            'init': ionspec_index4, 
+            'prior': priors.UniformPrior(min=-1.7, max=8)
+                         }
+    params['ionspec_logLratio1'] = {"N": 1, 'isfree': True,
+            'init': ionspec_logLratio1, 
+            'prior': priors.UniformPrior(min=-1, max=10.1)
+                         }
+    params['ionspec_logLratio2'] = {"N": 1, 'isfree': True,
+            'init':ionspec_logLratio2, 
+            'prior': priors.UniformPrior(min=-0.5, max=1.9)
+                         }
+    params['ionspec_logLratio3'] = {"N": 1, 'isfree': True,
+            'init': ionspec_logLratio3, 
+            'prior': priors.UniformPrior(min=-0.4, max=2.2)
+                         }
+
+    params['gas_logu'] = {"N": 1, 'isfree': True,
+            'init': gas_logu, 
+            'prior': priors.UniformPrior(min=-4.0, max=-1)
+                         }
+
+     # note that this is NOT in log, as this is a direct input into cue in linear units
+    params['gas_logn'] = {'N': 1, 'isfree': True, 'init': gas_logn,'prior': priors.UniformPrior(min=1, max=4)}
+
+    params['gas_logz'] = {'N': 1, 'isfree': True,
+            'init': gas_logz, 'units': r'log Z/Z_\odot',
+            'prior': priors.UniformPrior(min=-2.0, max=0.5)
+                         }
+
+    params['gas_logno'] = {"N": 1, 'isfree': True,
+            'init': gas_logno, 
+            'prior': priors.UniformPrior(min=-1, max=np.log10(5.4))
+                         }
+
+    params['gas_logco'] = {"N": 1, 'isfree': True,
+            'init': gas_logco, 
+            'prior': priors.UniformPrior(min=-1, max=np.log10(5.4))
+                         }
+
+    params['gas_logqion'] = {'N': 1, 'isfree': True,
+            'init': gas_logqion, 
+            'prior': priors.UniformPrior(min=30, max=50)
+                         }
+
+
+    # --- fixed parameters 
+    params['add_stars'] = {"N": 1, "isfree": False,"init": False} # don't load in the stellar emulators
+    params['use_stellar_ionizing'] = {"N": 1, "isfree": False, "init": False} # don't load in ionizing continuum emulators
+    params["add_duste"] = {"N": 1, "isfree": False, "init": False}
+    params['add_neb_emission'] = {'N': 1, 'isfree': False, 'init':True}
+    params['nebemlineinspec'] = {'N': 1, 'isfree': False, 'init': False}
+    params['add_igm_absorption'] = {'N': 1, 'isfree': False, 'init': False}
+    params['igm_damping'] = {'N': 1, 'isfree': False, 'init': False}
+    params["add_dust_emission"] = {"N": 1, "isfree": False,"init": False}
+    params['add_neb_lines'] = {'N': 1, 'isfree': False, 'init':True} # load in line emulators
+    params['add_neb_continuum'] = {'N': 1, 'isfree': False, 'init': True} # load in the nebular continuum emulator
+
+    return NebModel(params,num_lines=num_lines) # if not predicting stellar continuum, you don't need to set a stellar emulator model path
+
+
+class Emulator():
+    def __init__(self,**kwargs):
+        """
+        Args:
+        - num_lines (int): Number of lines returned by cue. This can either be 128 (the Byler cloudy grid lines,
+
+        """
+        self.model = build_cue_model(**kwargs) # getting ALL of the cue lines, not just the Byler grid lines.
+        self.theta = kwargs.get('theta', self.model.theta)
+        self.cont_lam = self.model.spec_wavelengths
+        self.line_wavelength = self.model.line_wavelengths
+
+        params = ['ionspec_index1', 'ionspec_index2', 'ionspec_index3', 'ionspec_index4',
+                'ionspec_logLratio1', 'ionspec_logLratio2', 'ionspec_logLratio3',
+                'gas_logn', 'gas_logz', 'gas_logno', 'gas_logco','gas_logqion']
+
+        for param in params:
+            setattr(self, param, self.model.params[param])
+
+    def update(self,theta=None,**kwargs):
+        if theta is None:
+            theta = self.model.theta.copy()
+            for param, value in kwargs.items():
+                if value is not None:
+                    setattr(self, param, value)
+                    idx = [i for i, name in enumerate(self.model.free_parameter_order) if name == param]
+                    theta = theta.at[:,idx].set(value) 
+        self.theta = theta
+                
+
+    def predict_lines(self,**kwargs):
+        """
+        hard coded to return the 138 cue lines. Lines in units of Lsun.
+        
+        theta must be inputted as a shape (N,13) in order of:
+            - ionspec_index1
+            - ionspec_index2
+            - ionspec_index3
+            - ionspec_logLratio1
+            - ionspec_logLratio2
+            - ionspec_logLratio3
+            - ionspec_logLratio4
+            - gas_logu
+            - gas_logn
+            - gas_logz
+            - gas_logno
+            - gas_logco
+            - gas_logqion
+        """
+        self.update(**kwargs)
+        return self.model.predict_lines(self.theta) # jit-compiled
+        
+    def predict_cont(self,wave,unit='erg/s/Hz',**kwargs):
+        """
+        continuum in erg/s/Hz or Lsun/Hz.
+        
+        theta must be inputted as a shape (N,14) in order of:
+            - ionspec_index1
+            - ionspec_index2
+            - ionspec_index3
+            - ionspec_index4
+            - ionspec_logLratio1
+            - ionspec_logLratio2
+            - ionspec_logLratio3
+            - gas_logu
+            - gas_logn
+            - gas_logz
+            - gas_logno
+            - gas_logco
+            - gas_logqion
+        """
+        self.update(**kwargs)
+        cont = self.model.predict_cont(self.theta,wave,unit=unit) # jit-compiled, interpolates
+        return cont
+    
+
+class DustEmission:
+
+    def __init__(self, duste_model="DL07",
+                 dust_file=None, spec_lambda=None, **kwargs):
+        """
+        Initialize the DustEmission object with parameters for dust emission modeling.
+
+        Parameters
+        ----------
+        duste_model : str
+            Dust emission model to use: 'DL07' or 'THEMIS'.
+        dust_file : str
+            Path to the dust emission file (required).
+        spec_lambda : ndarray
+            Wavelength grid over which dust emission will be evaluated (required).
+        kwargs : dict
+            Optional keyword arguments to override default dust parameters.
+            Supported: duste_qpah, duste_umin, duste_gamma
+        """
+
+        # Store model choice (e.g., 'DL07' or 'THEMIS')
+        self.duste_model = duste_model
+
+        # Dust parameter values
+        self.duste_qpah = None
+        self.duste_umin = None
+        self.duste_gamma = None
+
+        # Model grid arrays for allowed values of qPAH and Umin
+        self.qpaharr = None
+        self.uminarr = None
+
+        # Placeholder for loaded dust emission spectra
+        self.dustem2_dustem = None
+
+        # File path and wavelength grid
+        self.dust_file = None
+        self.spec_lambda = None
+
+        # Store any additional keyword arguments for later use
+        self.dwargs = kwargs
+
+        # Read in key dust parameters, allowing overrides via kwargs
+        self.duste_qpah = kwargs.pop("duste_qpah", 1.1)
+        self.duste_umin = kwargs.pop("duste_umin", 0.72)
+        self.duste_gamma = kwargs.pop("duste_gamma", 0.5)
+
+        # Set parameter grids based on selected dust model
+        if self.duste_model == "DL07":
+            self.qpaharr = jnp.array([0.47, 1.12, 1.77, 2.50, 3.19, 3.90, 4.58])
+            self.uminarr = jnp.array([
+                0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.7, 0.8, 1.0, 1.2, 1.5, 2.0,
+                2.5, 3.0, 4.0, 5.0, 7.0, 8.0, 12.0, 15.0, 20.0, 25.0
+            ])
+        elif self.duste_model == "THEMIS":
+            # THEMIS model uses smaller qPAH values rescaled to percent
+            self.qpaharr = jnp.array([0.02, 0.06, 0.10, 0.14, 0.17, 0.20, 0.24,
+                                      0.28, 0.32, 0.36, 0.40]) / 2.2 * 100
+            self.uminarr = jnp.array([
+                0.1, 0.12, 0.15, 0.17, 0.2, 0.25, 0.3, 0.35, 0.4, 0.5, 0.6,
+                0.7, 0.8, 1.0, 1.2, 1.5, 1.7, 2.0, 2.5, 3.0, 3.5, 4.0, 5.0,
+                6.0, 7.0, 8.0, 10.0, 12.0, 15.0, 17.0, 20.0, 25.0, 30.0,
+                35.0, 40.0, 50.0, 80.0
+            ])
+        else:
+            raise ValueError("Invalid duste_model. Choose 'DL07' or 'THEMIS'.")
+
+        # Ensure that necessary data is provided
+        if dust_file is None or spec_lambda is None:
+            raise ValueError("If `duste=True`, both `dust_file` and `spec_lambda` must be provided.")
+
+        self.dust_file = dust_file
+        self.spec_lambda = spec_lambda
+
+        # Load emission templates or model data from file
+        self.load_dust_emission(dust_file, spec_lambda)
+
+    def __repr__(self):
+        """
+        Custom string representation of the DustEmission object.
+        Provides a readable summary of model settings and parameters.
+        """
+
+        def format_array(arr):
+            """Helper to format short arrays inline; longer arrays multiline."""
+            if arr is None:
+                return "None"
+            if arr.ndim == 1 and len(arr) <= 5:
+                return f"[{', '.join(map(str, arr))}]"
+            return f"\n    " + "\n    ".join(map(str, arr))
+
+        attributes = {
+            "Duste model": self.duste_model,
+            "DUST qPAH": self.duste_qpah,
+            "DUST Umin": self.duste_umin,
+            "DUST Gamma": self.duste_gamma,
+            f"qpaharr ({self.duste_model})": format_array(self.qpaharr),
+            f"uminarr ({self.duste_model})": format_array(self.uminarr),
+            "dust_file": self.dust_file,
+            "spec_lambda": self.spec_lambda.shape if self.spec_lambda is not None else None,
+        }
+
+        if self.dwargs:
+            attributes["Extra parameters (dwargs)"] = self.dwargs
+
+        attr_str = "\n".join(f"  {k:<30}: {v}" for k, v in attributes.items() if v is not None)
+        return f"\nDustEmission Model:\n{'='*50}\n{attr_str}\n{'='*50}"
+
+    def load_dust_emission(self, dust_file=None, spec_lambda=None):
+        
+        # Use default paths if not provided
+        if dust_file is None:
+            dust_file = self.dust_file
+        if spec_lambda is None:
+            spec_lambda = self.spec_lambda
+
+        # Select dust model parameters
+        dust_model_params = {
+            "DL07": (7, 1001, 22),
+            "THEMIS": (11, 576, 37),
+        }
+        
+        if self.duste_model not in dust_model_params:
+            raise ValueError("Invalid duste_model. Choose 'DL07' or 'THEMIS'.")
+
+        nqpah_dustem, ndim_dustem, numin_dustem = dust_model_params[self.duste_model]
+
+        # Initialize storage for interpolated spectra (JAX-compatible)
+        dustem2_dustem = np.zeros((len(spec_lambda), nqpah_dustem, numin_dustem * 2))
+
+        # Read and interpolate dust emission spectra
+        for k in range(nqpah_dustem):
+            filename = Path(dust_file) / "dust" / "dustem" / f"{self.duste_model}_MW3.1_{'100' if k == 10 else f'{k}0'}.dat"
+
+            if not filename.exists():
+                raise FileNotFoundError(f"Error opening dust emission file: {filename}. File does not exist.")
+
+            with filename.open('r') as f:
+                next(f)  # Skip first header line
+                next(f)  # Skip second header line
+
+                lambda_dustem = np.zeros(ndim_dustem)
+                dustem_dustem = np.zeros((ndim_dustem, numin_dustem * 2))
+
+                for i in range(ndim_dustem):
+                    try:
+                        values = list(map(float, f.readline().strip().split()))
+                        lambda_dustem[i], dustem_dustem[i, :] = values[0], values[1:]
+                    except Exception:
+                        raise RuntimeError(f"Error reading dust emission file: {filename}")
+
+            # Convert wavelength from microns to Angstroms
+            lambda_dustem *= 1E4  
+
+            # Interpolate dust spectra onto the master wavelength array
+            jj = jnp.searchsorted(spec_lambda / 1E4, 1, side='left')
+            for j in range(numin_dustem * 2):
+                dustem2_dustem[jj:, k, j] = jnp.interp(spec_lambda[jj:], lambda_dustem, dustem_dustem[:, j])
+
+        self.dustem2_dustem = jnp.array(dustem2_dustem)
+
+    def compute_dust_emission(self, specdust, csp_spectra, spec_lambda, diff_dust, 
+                              linedust, line,
+                              duste_qpah=None, duste_umin=None, duste_gamma=None):
+        """
+        Compute dust emission using JAX-optimized vectorization for GPU acceleration.
+
+        Parameters:
+            specdust (jnp.ndarray): Attenuated spectrum after dust absorption.
+            csp_spectra (jnp.ndarray): Stellar spectrum before attenuation.
+            spec_lambda (jnp.ndarray): Wavelength array in Angstroms.
+            duste_qpah (float, optional): PAH fraction. Defaults to self.duste_qpah if None.
+            duste_umin (float, optional): Minimum U radiation field. Defaults to self.duste_umin if None.
+            duste_gamma (float, optional): Fraction of high U component. Defaults to self.duste_gamma if None.
+
+        Returns:
+            tuple: (Updated spectrum with dust emission added, Estimated dust mass)
+        """
+
+        # Use provided parameters if given, otherwise fallback to self attributes
+        duste_qpah = duste_qpah if duste_qpah is not None else self.duste_qpah
+        duste_umin = duste_umin if duste_umin is not None else self.duste_umin
+        duste_gamma = duste_gamma if duste_gamma is not None else self.duste_gamma
+
+
+        # Compute total luminosity before and after attenuation
+        nu = 2.9979E18 / spec_lambda  # Frequency in Hz (c / λ)
+        lbold = jnp.trapezoid(nu * specdust, -nu) + jnp.sum(linedust)  # L_bol after attenuation
+        lboln = jnp.trapezoid(nu * csp_spectra, -nu) + jnp.sum(line)  # L_bol before attenuation
+                
+        # Interpolation indices for PAH fraction and Umin
+        qlo = jnp.clip(jnp.searchsorted(self.qpaharr, duste_qpah) - 1, 0, len(self.qpaharr) - 2)
+        dq = jnp.clip((duste_qpah - self.qpaharr[qlo]) / (self.qpaharr[qlo + 1] - self.qpaharr[qlo]), 0.0, 1.0)
+        ulo = jnp.clip(jnp.searchsorted(self.uminarr, duste_umin) - 1, 0, len(self.uminarr) - 2)
+        du = jnp.clip((duste_umin - self.uminarr[ulo]) / (self.uminarr[ulo + 1] - self.uminarr[ulo]), 0.0, 1.0)
+    
+
+        # Ensure gamma fraction is within [0,1]
+        gamma = jnp.clip(duste_gamma, 0.0, 1.0)
+
+        # Perform bilinear interpolation over qpah and Umin using `vmap`
+        def interpolate_dustem(i):
+            return (
+                (1 - dq) * (1 - du) * self.dustem2_dustem[i, qlo, 2 * ulo - 1] +
+                dq * (1 - du) * self.dustem2_dustem[i, qlo + 1, 2 * ulo - 1] +
+                dq * du * self.dustem2_dustem[i, qlo + 1, 2 * (ulo + 1) - 1] +
+                (1 - dq) * du * self.dustem2_dustem[i, qlo, 2 * (ulo + 1) - 1]
+            ), (
+                (1 - dq) * (1 - du) * self.dustem2_dustem[i, qlo, 2 * ulo] +
+                dq * (1 - du) * self.dustem2_dustem[i, qlo + 1, 2 * ulo] +
+                dq * du * self.dustem2_dustem[i, qlo + 1, 2 * (ulo + 1)] +
+                (1 - dq) * du * self.dustem2_dustem[i, qlo, 2 * (ulo + 1)]
+            )
+
+        dumin, dumax = jax.vmap(interpolate_dustem)(jnp.arange(len(spec_lambda)))
+
+        # Compute dust emission spectrum
+        mduste = (1 - gamma) * dumin + gamma * dumax
+        mduste = jnp.maximum(mduste, 1e-70)
+        
+        # Normalize to absorbed luminosity
+        labs = lboln - lbold  # Energy absorbed by dust
+        norm = jnp.trapezoid(nu * mduste, -nu)  # Normalization factor
+        duste = mduste / norm * labs  # Normalize dust emission
+        duste = jnp.maximum(duste, 1e-70)
+
+        # Iterative correction for dust self-absorption using `jax.lax.while_loop`
+        # sometimes this was stalled; use python while function instead
+#         def cond_fn(state):
+#             lbold, lboln, _ = state
+#             return jnp.abs(lboln - lbold) > 1e-2
+
+#         def body_fn(state):
+#             lbold, lboln, tduste = state
+#             oduste = duste
+#             duste_att = duste * diff_dust # Apply diffuse attenuation, duste *jnp.exp(-self.diffuse_tau)  
+#             tduste = tduste + duste_att
+
+#             lbold = jnp.trapezoid(nu * duste_att, -nu)  # Update L_bol after self-absorption
+#             lboln = jnp.trapezoid(nu * oduste, -nu)  # Before self-absorption
+
+#             duste = jnp.maximum(mduste / norm * (lboln - lbold), 1e-70)
+#             return lbold, lboln, tduste
+
+#         _, _, tduste = jax.lax.while_loop(cond_fn, body_fn, (lbold, lboln, jnp.zeros_like(duste)))
+
+        tduste = jnp.zeros_like(duste)
+        while jnp.abs(lboln - lbold) > 1e-2:
+            oduste = duste
+            duste_att = duste * diff_dust # Apply diffuse attenuation, duste *jnp.exp(-self.diffuse_tau)  
+            tduste = tduste + duste_att
+
+            lbold = jnp.trapezoid(nu * duste_att, -nu)  # Update L_bol after self-absorption
+            lboln = jnp.trapezoid(nu * oduste, -nu)  # Before self-absorption
+
+            duste = jnp.maximum(mduste / norm * (lboln - lbold), 1e-70)
+
+        # Compute estimated dust mass
+        mdust = 3.21E-3 / (4 * jnp.pi) * labs / norm
+  
+        # Add dust emission to the stellar spectrum
+        specdust = specdust + tduste
+
+        return specdust, mdust
diff --git a/prospect/sources/nebssp_basis.py b/prospect/sources/nebssp_basis.py
index 63d9947d..20844b3e 100644
--- a/prospect/sources/nebssp_basis.py
+++ b/prospect/sources/nebssp_basis.py
@@ -7,8 +7,8 @@
 from .fake_fsps import add_dust, add_igm, idx
 
 try:
-    import cuejax as cue
-    from cuejax import Emulator
+    import cue
+    from .fake_fsps import Emulator
 except:
     pass
 

From 09506eb3b74c8b0b229cdce05189e455a0a214a2 Mon Sep 17 00:00:00 2001
From: yi-jia-li <yzl466@psu.edu>
Date: Mon, 9 Jun 2025 15:00:06 -0400
Subject: [PATCH 130/132] switch to fast cuejax prediction

---
 prospect/models/sedmodel.py      |   6 +-
 prospect/models/templates.py     |   3 +
 prospect/sources/fake_fsps.py    | 181 ++--------------------
 prospect/sources/nebssp_basis.py | 254 ++++++++++++++++++++++++++-----
 4 files changed, 232 insertions(+), 212 deletions(-)

diff --git a/prospect/models/sedmodel.py b/prospect/models/sedmodel.py
index 33cd7f83..d684eea5 100644
--- a/prospect/models/sedmodel.py
+++ b/prospect/models/sedmodel.py
@@ -21,7 +21,7 @@
 from ..sources.constants import cosmo, lightspeed, ckms, jansky_cgs
 
 try:
-    from cue.utils import sigma_line_for_fsps
+    from ..sources.fake_fsps import frac_line_err # a very rough estimate of the emission line emulator error
 except:
     pass
 
@@ -148,7 +148,7 @@ def predict_init(self, theta, sps):
         self._eline_lum_mle = self._eline_lum.copy()
         if self.params.get('use_eline_nn_unc', False):
             self._eline_lum_covar = np.diag((self.params.get('eline_prior_width', 0.0) *
-                                             self._eline_lum)**2) + (sigma_line_for_fsps * 
+                                             self._eline_lum)**2) + (frac_line_err * 
                                                                      self._eline_lum)**2
         else:
             self._eline_lum_covar = np.diag((self.params.get('eline_prior_width', 0.0) *
@@ -460,7 +460,7 @@ def init_eline_info(self, eline_file='emlines_info.dat'):
                                      delimiter=',')
             else:
                 from pkg_resources import resource_filename
-                info = np.genfromtxt(resource_filename("cue", "data/cue_emlines_info.dat"),
+                info = np.genfromtxt(resource_filename("cuejax", "data/cue_emlines_info.dat"),
                                      dtype=[('wave', 'f8'), ('name', '<U20')],
                                      delimiter=',')
             self.emline_info = info
diff --git a/prospect/models/templates.py b/prospect/models/templates.py
index b21927d2..54afad9d 100755
--- a/prospect/models/templates.py
+++ b/prospect/models/templates.py
@@ -291,6 +291,7 @@ def adjust_stochastic_params(parset, tuniv=13.7):
                                "with gas_logz tied to stellar logzsol."))
 
 # new nebular parameters from cue
+use_eline_nn_unc = {'N': 1, "isfree": False, "init": True}
 use_stellar_ionizing = {'N': 1, "isfree": False, "init": False}
 gas_logz = {'N': 1, 'isfree': True,
             "init": 0.0, 'units': r"log Z/Z_\odot",
@@ -347,6 +348,7 @@ def adjust_stochastic_params(parset, tuniv=13.7):
 _cue_nebular_ = {"add_neb_emission": add_neb,
                  "add_neb_continuum": neb_cont,
                  "nebemlineinspec": neb_spec,
+                 "use_eline_nn_unc": use_eline_nn_unc,
                  "use_stellar_ionizing": use_stellar_ionizing,
                  "gas_logz": gas_logz,
                  "gas_logu": gas_logu,
@@ -370,6 +372,7 @@ def adjust_stochastic_params(parset, tuniv=13.7):
 _cue_stellar_nebular_ = {"add_neb_emission": add_neb,
                          "add_neb_continuum": neb_cont,
                          "nebemlineinspec": neb_spec,
+                         "use_eline_nn_unc": use_eline_nn_unc,
                          "use_stellar_ionizing": use_stellar_ionizing,
                          "gas_logz": gas_logz,
                          "gas_logu": gas_logu,
diff --git a/prospect/sources/fake_fsps.py b/prospect/sources/fake_fsps.py
index 835354a1..613741f0 100644
--- a/prospect/sources/fake_fsps.py
+++ b/prospect/sources/fake_fsps.py
@@ -1,9 +1,8 @@
 import numpy as np
 import os
+import dill as pickle
+from pkg_resources import resource_filename
 
-from efsps.sources.constants import lyman_limit
-from efsps.sources.transforms import maggies_to_cgs
-from efsps.models import priors, NebModel
 import jax.numpy as jnp
 import jax
 from pathlib import Path
@@ -18,7 +17,10 @@
           114,116,118,119,122,123,125,127,129,130,134,137,139,140,143,145,146,148,
           151,152,153,154,155,156,157,158,159,160,161,162,163,164,165])
 
-__all__ = ["add_dust", "add_igm"]
+out = pickle.load(open(resource_filename("cuejax", "data/nn_stats_v0.pkl"), "rb"))
+frac_line_err = 1./out['SN_quantile'][1][np.argsort(out['wav'])] # 1 / upper 2 sigma quantike of SN of the cue test set
+
+__all__ = ["add_dust", "add_igm", "DustEmission"]
 
 
 def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=-1.0,dust1=0.0,**kwargs):
@@ -157,6 +159,7 @@ def attenuate(spec,lam,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=0.0,dust
 
     return ext_tot*spec, dust2_ext
 
+
 def add_igm(wave, spec, zred=0., igm_factor=1.0, add_igm_absorption=None, **kwargs):
     """IGM absorption based on Madau+1995
     wave: rest-frame wavelength
@@ -205,162 +208,6 @@ def add_igm(wave, spec, zred=0., igm_factor=1.0, add_igm_absorption=None, **kwar
     return np.clip(res, a_min=tiny_number, a_max=None)
 
 
-def build_cue_model(ionspec_index1=19.7, ionspec_index2=5.3, ionspec_index3=1.6, ionspec_index4=0.6,
-                 ionspec_logLratio1=3.9, ionspec_logLratio2=0.01, ionspec_logLratio3=0.2,
-                 gas_logu=-2.5, gas_logn=2, gas_logz=0., gas_logno=0., gas_logco=0.,
-                 gas_logqion=49.1,num_lines=138,**extras):
-
-    params = {}
-
-    params['ionspec_index1'] = {"N": 1, 'isfree': True,
-            'init': ionspec_index1, 
-            'prior': priors.UniformPrior(min=1, max=42)
-                         }
-    params['ionspec_index2'] = {"N": 1, 'isfree': True,
-            'init': ionspec_index2, 
-            'prior': priors.UniformPrior(min=-0.3, max=30)
-                         }
-    params['ionspec_index3'] = {"N": 1, 'isfree': True,
-            'init': ionspec_index3, 
-            'prior': priors.UniformPrior(min=-1, max=14)
-                         }
-    params['ionspec_index4'] = {"N": 1, 'isfree': True,
-            'init': ionspec_index4, 
-            'prior': priors.UniformPrior(min=-1.7, max=8)
-                         }
-    params['ionspec_logLratio1'] = {"N": 1, 'isfree': True,
-            'init': ionspec_logLratio1, 
-            'prior': priors.UniformPrior(min=-1, max=10.1)
-                         }
-    params['ionspec_logLratio2'] = {"N": 1, 'isfree': True,
-            'init':ionspec_logLratio2, 
-            'prior': priors.UniformPrior(min=-0.5, max=1.9)
-                         }
-    params['ionspec_logLratio3'] = {"N": 1, 'isfree': True,
-            'init': ionspec_logLratio3, 
-            'prior': priors.UniformPrior(min=-0.4, max=2.2)
-                         }
-
-    params['gas_logu'] = {"N": 1, 'isfree': True,
-            'init': gas_logu, 
-            'prior': priors.UniformPrior(min=-4.0, max=-1)
-                         }
-
-     # note that this is NOT in log, as this is a direct input into cue in linear units
-    params['gas_logn'] = {'N': 1, 'isfree': True, 'init': gas_logn,'prior': priors.UniformPrior(min=1, max=4)}
-
-    params['gas_logz'] = {'N': 1, 'isfree': True,
-            'init': gas_logz, 'units': r'log Z/Z_\odot',
-            'prior': priors.UniformPrior(min=-2.0, max=0.5)
-                         }
-
-    params['gas_logno'] = {"N": 1, 'isfree': True,
-            'init': gas_logno, 
-            'prior': priors.UniformPrior(min=-1, max=np.log10(5.4))
-                         }
-
-    params['gas_logco'] = {"N": 1, 'isfree': True,
-            'init': gas_logco, 
-            'prior': priors.UniformPrior(min=-1, max=np.log10(5.4))
-                         }
-
-    params['gas_logqion'] = {'N': 1, 'isfree': True,
-            'init': gas_logqion, 
-            'prior': priors.UniformPrior(min=30, max=50)
-                         }
-
-
-    # --- fixed parameters 
-    params['add_stars'] = {"N": 1, "isfree": False,"init": False} # don't load in the stellar emulators
-    params['use_stellar_ionizing'] = {"N": 1, "isfree": False, "init": False} # don't load in ionizing continuum emulators
-    params["add_duste"] = {"N": 1, "isfree": False, "init": False}
-    params['add_neb_emission'] = {'N': 1, 'isfree': False, 'init':True}
-    params['nebemlineinspec'] = {'N': 1, 'isfree': False, 'init': False}
-    params['add_igm_absorption'] = {'N': 1, 'isfree': False, 'init': False}
-    params['igm_damping'] = {'N': 1, 'isfree': False, 'init': False}
-    params["add_dust_emission"] = {"N": 1, "isfree": False,"init": False}
-    params['add_neb_lines'] = {'N': 1, 'isfree': False, 'init':True} # load in line emulators
-    params['add_neb_continuum'] = {'N': 1, 'isfree': False, 'init': True} # load in the nebular continuum emulator
-
-    return NebModel(params,num_lines=num_lines) # if not predicting stellar continuum, you don't need to set a stellar emulator model path
-
-
-class Emulator():
-    def __init__(self,**kwargs):
-        """
-        Args:
-        - num_lines (int): Number of lines returned by cue. This can either be 128 (the Byler cloudy grid lines,
-
-        """
-        self.model = build_cue_model(**kwargs) # getting ALL of the cue lines, not just the Byler grid lines.
-        self.theta = kwargs.get('theta', self.model.theta)
-        self.cont_lam = self.model.spec_wavelengths
-        self.line_wavelength = self.model.line_wavelengths
-
-        params = ['ionspec_index1', 'ionspec_index2', 'ionspec_index3', 'ionspec_index4',
-                'ionspec_logLratio1', 'ionspec_logLratio2', 'ionspec_logLratio3',
-                'gas_logn', 'gas_logz', 'gas_logno', 'gas_logco','gas_logqion']
-
-        for param in params:
-            setattr(self, param, self.model.params[param])
-
-    def update(self,theta=None,**kwargs):
-        if theta is None:
-            theta = self.model.theta.copy()
-            for param, value in kwargs.items():
-                if value is not None:
-                    setattr(self, param, value)
-                    idx = [i for i, name in enumerate(self.model.free_parameter_order) if name == param]
-                    theta = theta.at[:,idx].set(value) 
-        self.theta = theta
-                
-
-    def predict_lines(self,**kwargs):
-        """
-        hard coded to return the 138 cue lines. Lines in units of Lsun.
-        
-        theta must be inputted as a shape (N,13) in order of:
-            - ionspec_index1
-            - ionspec_index2
-            - ionspec_index3
-            - ionspec_logLratio1
-            - ionspec_logLratio2
-            - ionspec_logLratio3
-            - ionspec_logLratio4
-            - gas_logu
-            - gas_logn
-            - gas_logz
-            - gas_logno
-            - gas_logco
-            - gas_logqion
-        """
-        self.update(**kwargs)
-        return self.model.predict_lines(self.theta) # jit-compiled
-        
-    def predict_cont(self,wave,unit='erg/s/Hz',**kwargs):
-        """
-        continuum in erg/s/Hz or Lsun/Hz.
-        
-        theta must be inputted as a shape (N,14) in order of:
-            - ionspec_index1
-            - ionspec_index2
-            - ionspec_index3
-            - ionspec_index4
-            - ionspec_logLratio1
-            - ionspec_logLratio2
-            - ionspec_logLratio3
-            - gas_logu
-            - gas_logn
-            - gas_logz
-            - gas_logno
-            - gas_logco
-            - gas_logqion
-        """
-        self.update(**kwargs)
-        cont = self.model.predict_cont(self.theta,wave,unit=unit) # jit-compiled, interpolates
-        return cont
-    
-
 class DustEmission:
 
     def __init__(self, duste_model="DL07",
@@ -548,8 +395,8 @@ def compute_dust_emission(self, specdust, csp_spectra, spec_lambda, diff_dust,
 
         # Compute total luminosity before and after attenuation
         nu = 2.9979E18 / spec_lambda  # Frequency in Hz (c / λ)
-        lbold = jnp.trapezoid(nu * specdust, -nu) + jnp.sum(linedust)  # L_bol after attenuation
-        lboln = jnp.trapezoid(nu * csp_spectra, -nu) + jnp.sum(line)  # L_bol before attenuation
+        lbold = jax.scipy.integrate.trapezoid(nu * specdust, -nu) + jnp.sum(linedust)  # L_bol after attenuation
+        lboln = jax.scipy.integrate.trapezoid(nu * csp_spectra, -nu) + jnp.sum(line)  # L_bol before attenuation
                 
         # Interpolation indices for PAH fraction and Umin
         qlo = jnp.clip(jnp.searchsorted(self.qpaharr, duste_qpah) - 1, 0, len(self.qpaharr) - 2)
@@ -583,7 +430,7 @@ def interpolate_dustem(i):
         
         # Normalize to absorbed luminosity
         labs = lboln - lbold  # Energy absorbed by dust
-        norm = jnp.trapezoid(nu * mduste, -nu)  # Normalization factor
+        norm = jax.scipy.integrate.trapezoid(nu * mduste, -nu)  # Normalization factor
         duste = mduste / norm * labs  # Normalize dust emission
         duste = jnp.maximum(duste, 1e-70)
 
@@ -599,8 +446,8 @@ def interpolate_dustem(i):
 #             duste_att = duste * diff_dust # Apply diffuse attenuation, duste *jnp.exp(-self.diffuse_tau)  
 #             tduste = tduste + duste_att
 
-#             lbold = jnp.trapezoid(nu * duste_att, -nu)  # Update L_bol after self-absorption
-#             lboln = jnp.trapezoid(nu * oduste, -nu)  # Before self-absorption
+#             lbold = jax.scipy.integrate.trapezoid(nu * duste_att, -nu)  # Update L_bol after self-absorption
+#             lboln = jax.scipy.integrate.trapezoid(nu * oduste, -nu)  # Before self-absorption
 
 #             duste = jnp.maximum(mduste / norm * (lboln - lbold), 1e-70)
 #             return lbold, lboln, tduste
@@ -613,8 +460,8 @@ def interpolate_dustem(i):
             duste_att = duste * diff_dust # Apply diffuse attenuation, duste *jnp.exp(-self.diffuse_tau)  
             tduste = tduste + duste_att
 
-            lbold = jnp.trapezoid(nu * duste_att, -nu)  # Update L_bol after self-absorption
-            lboln = jnp.trapezoid(nu * oduste, -nu)  # Before self-absorption
+            lbold = jax.scipy.integrate.trapezoid(nu * duste_att, -nu)  # Update L_bol after self-absorption
+            lboln = jax.scipy.integrate.trapezoid(nu * oduste, -nu)  # Before self-absorption
 
             duste = jnp.maximum(mduste / norm * (lboln - lbold), 1e-70)
 
diff --git a/prospect/sources/nebssp_basis.py b/prospect/sources/nebssp_basis.py
index 20844b3e..2d173346 100644
--- a/prospect/sources/nebssp_basis.py
+++ b/prospect/sources/nebssp_basis.py
@@ -1,22 +1,23 @@
-### SSP for cue
+### SSP for cuejax
 import numpy as np
 from pkg_resources import resource_filename
 
 import fsps
-from .galaxy_basis import FastStepBasis, CSPSpecBasis
+from .galaxy_basis import SSPBasis, FastStepBasis, CSPSpecBasis
 from .fake_fsps import add_dust, add_igm, idx
 
 try:
-    import cue
-    from .fake_fsps import Emulator
+    from cuejax.emulator import Emulator, fast_line_prediction, fast_cont_prediction
+    from cuejax.utils import fit_4loglinear_ionparam
 except:
     pass
 
 
-__all__ = ["NebStepBasis", "NebCSPBasis"]
+__all__ = ["NebSSPBasis", "NebStepBasis", "NebCSPBasis"]
 
 
-class NebStepBasis(FastStepBasis):
+
+class NebSSPBasis(SSPBasis):
 
     """This is a class that wraps the fsps.StellarPopulation object, which is
     used for producing SSPs.  The ``fsps.StellarPopulation`` object is accessed
@@ -43,10 +44,165 @@ class NebStepBasis(FastStepBasis):
         their functionality using (hopefully more efficient) custom algorithms.
     """
 
-    def __init__(self, cue_kwargs={},
+    def __init__(self, zcontinuous=1, reserved_params=['tage', 'sigma_smooth'],
+                 interp_type='logarithmic', flux_interp='linear',
+                 mint_log=-3, compute_vega_mags=False,
+                 cue_kwargs={},
                  **kwargs):
+        """
+        :param interp_type: (default: "logarithmic")
+            Specify whether to linearly interpolate the SSPs in log(t) or t.
+            For the latter, set this to "linear".
+
+        :param flux_interp': (default: "linear")
+            Whether to compute the final spectrum as \sum_i w_i f_i or
+            e^{\sum_i w_i ln(f_i)}.  Basically you should always do the former,
+            which is the default.
+
+        :param mint_log: (default: -3)
+            The log of the age (in years) of the youngest SSP.  Note that the
+            SSP at this age is assumed to have the same spectrum as the minimum
+            age SSP avalibale from fsps.  Typically anything less than 4 or so
+            is fine for this parameter, since the integral converges as log(t)
+            -> -inf
+
+        :param reserved_params:
+            These are parameters which have names like the FSPS parameters but
+            will not be passed to the StellarPopulation object because we are
+            overriding their functionality using (hopefully more efficient)
+            custom algorithms.
+        """
+        self.interp_type = interp_type
+        self.mint_log = mint_log
+        self.flux_interp = flux_interp
+        self.ssp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
+                                          zcontinuous=zcontinuous)
+        # we do these now
+        rp = ["dust1", "dust2", "dust3", "add_dust_emission",
+              "add_igm_absorption", "igm_factor",
+              "add_neb_emission", "add_neb_continuum", "nebemlineinspec",
+              "fagn", "agn_tau"]
+        reserved_params = kwargs.pop("reserved_params", []) + rp
+        super().__init__(reserved_params=reserved_params, **kwargs)
+        for k in ["add_igm_absorption", "add_dust_emission", "add_neb_emission", "nebemlineinspec"]:
+            self.ssp.params[k] = False            
+        self.ssp.params['sfh'] = 0
+        self.reserved_params = reserved_params
+        self.params = {}
+        self.update(**kwargs)
+        
+        self.emul = Emulator(**cue_kwargs) # gas_logqion is fixed to 49.1
+        # compile the functions first to speed up prediction, using an initial set of cue parameters in order
+        _ = fast_line_prediction([19.7, 5.3, 1.6, 0.6, 3.9, 0.01, 0.2, -2.5, 2.0, 0.0, 0.0, 0.0], self.emul)
+        _ = fast_cont_prediction([19.7, 5.3, 1.6, 0.6, 3.9, 0.01, 0.2, -2.5, 2.0, 0.0, 0.0, 0.0], 
+                                 self.ssp.wavelengths,
+                                 self.emul, unit='Lsun/Hz')
+        self.emline_wavelengths = np.genfromtxt(resource_filename("cuejax", "data/cue_emlines_info.dat"),
+                                                dtype=[('wave', 'f8'), ('name', '<U20')],
+                                                delimiter=',')['wave']
 
-        self.emul = Emulator(**cue_kwargs)
+    def get_galaxy_spectrum(self, **params):
+        """Update parameters, then get the SSP spectrum
+
+        Returns
+        -------
+        wave : ndarray
+            Restframe avelength in angstroms.
+
+        spectrum : ndarray
+            Spectrum in units of Lsun/Hz per solar mass formed.
+
+        mass_fraction : float
+            Fraction of the formed stellar mass that still exists.
+        """
+        self.update(**params)
+        wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, self.emline_wavelengths, tage=float(self.params['tage']))
+        self._line_specific_luminosity = lines
+        
+        # mimic the "nebemlineinspec" function in FSPS
+        if self.params.get("nebemlineinspec", False):
+            if self.ssp.params["smooth_velocity"] == True:
+                dlam = self.emline_wavelengths*self.ssp.params["sigma_smooth"]/2.9979E18*1E13 #smoothing variable is in km/s
+            else:
+                dlam = self.ssp.params["sigma_smooth"] #smoothing variable is in AA
+            nearest_id = np.searchsorted(wave, self.emline_wavelengths)
+            neb_res_min = wave[nearest_id]-wave[nearest_id-1]
+            dlam = np.max([dlam,neb_res_min*2], axis=0)
+            gaussnebarr = [1./np.sqrt(2*np.pi)/dlam[i]*np.exp(-(wave-self.emline_wavelengths[i])**2/2/dlam[i]**2) \
+            /2.9979E18*self.emline_wavelengths[i]**2 for i in range(len(lines))]
+            for i in range(len(lines)):
+                spec += lines[i]*gaussnebarr[i]
+
+        return wave, spec, self.ssp.stellar_mass
+
+    def get_galaxy_elines(self):
+        """Get the wavelengths and specific emission line luminosity of the nebular emission lines
+        predicted by FSPS. These lines are in units of Lsun/solar mass formed.
+        This assumes that `get_galaxy_spectrum` has already been called.
+
+        :returns ewave:
+            The *restframe* wavelengths of the emission lines, AA
+
+        :returns elum:
+            Specific luminosities of the nebular emission lines,
+            Lsun/stellar mass formed
+        """
+        ewave = self.emline_wavelengths
+        # This allows subclasses to set their own specific emission line
+        # luminosities within other methods, e.g., get_galaxy_spectrum, by
+        # populating the `_specific_line_luminosity` attribute.
+        elum = getattr(self, "_line_specific_luminosity", None)
+        
+        if elum is None:
+            ewave = self.ssp.emline_wavelengths
+            elum = self.ssp.emline_luminosity.copy()
+        if elum.ndim > 1:
+            elum = elum[0]
+        if self.ssp.params["sfh"] == 3:
+            # tabular sfh
+            mass = np.sum(self.params.get('mass', 1.0))
+            elum /= mass
+
+        return ewave, elum
+
+    
+class NebStepBasis(FastStepBasis):
+
+    """This is a class that wraps the fsps.StellarPopulation object, which is
+    used for producing SSPs.  The ``fsps.StellarPopulation`` object is accessed
+    as ``SSPBasis().ssp``.
+
+    This class allows for the custom calculation of relative SSP weights (by
+    overriding ``all_ssp_weights``) to produce spectra from arbitrary composite
+    SFHs. Alternatively, the entire ``get_galaxy_spectrum`` method can be
+    overridden to produce a galaxy spectrum in some other way, for example
+    taking advantage of weight calculations within FSPS for tabular SFHs or for
+    parameteric SFHs.
+
+    The base implementation here produces an SSP interpolated to the age given
+    by ``tage``, with initial mass given by ``mass``.  However, this is much
+    slower than letting FSPS calculate the weights, as implemented in
+    :py:class:`FastSSPBasis`.
+
+    Furthermore, smoothing, redshifting, and filter projections are handled
+    outside of FSPS, allowing for fast and more flexible algorithms.
+
+    :param reserved_params:
+        These are parameters which have names like the FSPS parameters but will
+        not be passed to the StellarPopulation object because we are overriding
+        their functionality using (hopefully more efficient) custom algorithms.
+    """
+    def __init__(self, zcontinuous=1, reserved_params=['tage', 'sigma_smooth'],
+                 interp_type='logarithmic', flux_interp='linear',
+                 mint_log=-3, compute_vega_mags=False,
+                 cue_kwargs={},
+                 **kwargs):
+        
+        self.interp_type = interp_type
+        self.mint_log = mint_log
+        self.flux_interp = flux_interp
+        self.ssp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
+                                          zcontinuous=zcontinuous)
         # we do these now
         rp = ["dust1", "dust2", "dust3", "add_dust_emission",
               "add_igm_absorption", "igm_factor",
@@ -55,9 +211,19 @@ def __init__(self, cue_kwargs={},
         reserved_params = kwargs.pop("reserved_params", []) + rp
         super().__init__(reserved_params=reserved_params, **kwargs)
         for k in ["add_igm_absorption", "add_dust_emission", "add_neb_emission", "nebemlineinspec"]:
-            self.ssp.params[k] = False
-            
-        self.emline_wavelengths = np.genfromtxt(resource_filename("cue", "data/cue_emlines_info.dat"),
+            self.ssp.params[k] = False            
+        self.ssp.params['sfh'] = 0
+        self.reserved_params = reserved_params
+        self.params = {}
+        self.update(**kwargs)
+
+        self.emul = Emulator(**cue_kwargs) # gas_logqion is fixed to 49.1
+        # compile the functions first to speed up prediction, using an initial set of cue parameters in order
+        _ = fast_line_prediction([19.7, 5.3, 1.6, 0.6, 3.9, 0.01, 0.2, -2.5, 2.0, 0.0, 0.0, 0.0], self.emul)
+        _ = fast_cont_prediction([19.7, 5.3, 1.6, 0.6, 3.9, 0.01, 0.2, -2.5, 2.0, 0.0, 0.0, 0.0], 
+                                 self.ssp.wavelengths,
+                                 self.emul, unit='Lsun/Hz')
+        self.emline_wavelengths = np.genfromtxt(resource_filename("cuejax", "data/cue_emlines_info.dat"),
                                                 dtype=[('wave', 'f8'), ('name', '<U20')],
                                                 delimiter=',')['wave']
 
@@ -76,7 +242,7 @@ def get_galaxy_spectrum(self, **params):
         self.ssp.set_tabular_sfh(time, sfr)
 
         wave, spec, lines = get_spectrum(self.ssp, self.params, self.emul, self.emline_wavelengths, tage=tmax)
-        self._line_specific_luminosity = lines/mtot
+        self._line_specific_luminosity = lines
         # mimic the "nebemlineinspec" function in FSPS
         if self.params.get("nebemlineinspec", False):
             if self.ssp.params["smooth_velocity"] == True:
@@ -114,12 +280,12 @@ def get_galaxy_elines(self):
         if elum is None:
             ewave = self.ssp.emline_wavelengths
             elum = self.ssp.emline_luminosity.copy()
-            if elum.ndim > 1:
-                elum = elum[0]
-            if self.ssp.params["sfh"] == 3:
-                # tabular sfh
-                mass = np.sum(self.params.get('mass', 1.0))
-                elum /= mass
+        if elum.ndim > 1:
+            elum = elum[0]
+        if self.ssp.params["sfh"] == 3:
+            # tabular sfh
+            mass = np.sum(self.params.get('mass', 1.0))
+            elum /= mass
 
         return ewave, elum
 
@@ -141,7 +307,6 @@ def __init__(self, zcontinuous=1, reserved_params=['sigma_smooth'],
         self.ssp = fsps.StellarPopulation(compute_vega_mags=compute_vega_mags,
                                           zcontinuous=zcontinuous,
                                           vactoair_flag=vactoair_flag)
-        self.emul = Emulator(**cue_kwargs)
         # we do these now
         rp = ["dust1", "dust2", "dust3", "add_dust_emission",
               "add_igm_absorption", "igm_factor",
@@ -152,7 +317,13 @@ def __init__(self, zcontinuous=1, reserved_params=['sigma_smooth'],
         for k in ["add_igm_absorption", "add_dust_emission", "add_neb_emission", "nebemlineinspec"]:
             self.ssp.params[k] = False
             
-        self.emline_wavelengths = np.genfromtxt(resource_filename("cue", "data/cue_emlines_info.dat"),
+        self.emul = Emulator(**cue_kwargs)
+        # compile the functions first to speed up prediction, using an initial set of cue parameters in order
+        _ = fast_line_prediction([19.7, 5.3, 1.6, 0.6, 3.9, 0.01, 0.2, -2.5, 0.0, 0.0, 0.0, 49.1], self.emul)
+        _ = fast_cont_prediction([19.7, 5.3, 1.6, 0.6, 3.9, 0.01, 0.2, -2.5, 0.0, 0.0, 0.0, 49.1], 
+                                 self.ssp.wavelengths,
+                                 self.emul, unit='Lsun/Hz')
+        self.emline_wavelengths = np.genfromtxt(resource_filename("cuejax", "data/cue_emlines_info.dat"),
                                                 dtype=[('wave', 'f8'), ('name', '<U20')],
                                                 delimiter=',')['wave']
 
@@ -233,29 +404,28 @@ def get_galaxy_elines(self):
         if elum is None:
             ewave = self.ssp.emline_wavelengths
             elum = self.ssp.emline_luminosity.copy()
-            if elum.ndim > 1:
-                elum = elum[0]
-            if self.ssp.params["sfh"] == 3:
-                # tabular sfh
-                mass = np.sum(self.params.get('mass', 1.0))
-                elum /= mass
+        if elum.ndim > 1:
+            elum = elum[0]
+        if self.ssp.params["sfh"] == 3:
+            # tabular sfh
+            mass = np.sum(self.params.get('mass', 1.0))
+            elum /= mass
 
         return ewave, elum
     
 
-cue_keys = ['gas_logz',
-            'gas_logu',
-            'gas_lognH',
-            'gas_logno',
-            'gas_logco',
-            'ionspec_index1',
+cue_keys = ['ionspec_index1',
             'ionspec_index2',
             'ionspec_index3',
             'ionspec_index4',
             'ionspec_logLratio1',
             'ionspec_logLratio2',
             'ionspec_logLratio3',
-            'gas_logqion',]
+            'gas_logu',
+            'gas_lognH',
+            'gas_logz',
+            'gas_logno',
+            'gas_logco']
 
 def get_spectrum(ssp, params, emul, ewave, tage=0):
     """
@@ -276,22 +446,22 @@ def get_spectrum(ssp, params, emul, ewave, tage=0):
     if not add_neb:
         lines = [np.zeros_like(ewave), np.zeros_like(ewave)]
     elif add_neb:
-        cue_params = {k: v.item() if hasattr(v, 'item') else v for k, v in params.items() if k in cue_keys}
         if not use_stars:
-            line_prediction = np.squeeze(emul.predict_lines(**cue_params))
+            cue_params = {k: params[k] for k in cue_keys}
+            theta = np.array(list(cue_params.values()))
+            line_prediction = fast_line_prediction(theta, emul)[0].squeeze() * 10**(params["gas_logqion"] - 49.1)
             #if ssp.params["sfh"] == 3:
             #    line_prediction /= mass
             lines = [line_prediction, np.zeros_like(ewave)]
-            csps[0][wave>=912] += np.squeeze(emul.predict_cont(wave[wave>=912], unit='Lsun/Hz', **cue_params))
+            csps[0][wave>=912] += fast_cont_prediction(theta, wave[wave>=912], emul, unit='Lsun/Hz')[0].squeeze() * 10**(params["gas_logqion"] - 49.1)
         elif use_stars:
             for spec in csps:
-                ion_params = cue.fit_4loglinear_ionparam(wave, spec)
-                cue_params.update(**ion_params)
-                line_prediction = np.squeeze(emul.predict_lines(**cue_params))
-                #if ssp.params["sfh"] == 3:
-                #    line_prediction /= mass
+                params.update(**fit_4loglinear_ionparam(wave, spec))
+                cue_params = {k: params[k] for k in cue_keys}
+                theta = np.array(list(cue_params.values()))
+                line_prediction = fast_line_prediction(theta, emul)[0].squeeze() * 10**(params["gas_logqion"] - 49.1)
                 lines.append(line_prediction)
-                spec[wave>=912] += np.squeeze(emul.predict_cont(wave[wave>=912], unit='Lsun/Hz', **cue_params))
+                spec[wave>=912] += fast_cont_prediction(theta, wave[wave>=912], emul, unit='Lsun/Hz')[0].squeeze() * 10**(params["gas_logqion"] - 49.1)
         else:
             raise KeyError('No "use_stellar_ionizing" in model')
 

From eb79bd205061234eed7eaaa79e0a2c3ed08265b9 Mon Sep 17 00:00:00 2001
From: yi-jia-li <yzl466@psu.edu>
Date: Fri, 13 Jun 2025 07:23:42 -0400
Subject: [PATCH 131/132] fix bugs in SSP classes

---
 README.md                        | 13 +++++++++++--
 prospect/sources/fake_fsps.py    | 21 +++++++++++----------
 prospect/sources/nebssp_basis.py |  6 +++---
 tests/test_cue_eline.py          | 14 +++++++-------
 4 files changed, 32 insertions(+), 22 deletions(-)

diff --git a/README.md b/README.md
index 9facb8cc..5dbfe012 100644
--- a/README.md
+++ b/README.md
@@ -31,14 +31,23 @@ Work to do includes:
 - [ ] Test smoothing accounting for library, instrumental & physical smoothing
 - [ ] Implement an emulator-based SpecModel class
 
-Nebular emission is computed using [`cuejax`](https://github.com/efburnham/cue), a jax-compatible version of [`cue`](https://github.com/yi-jia-li/cue) ([Li et al. 2024](https://ui.adsabs.harvard.edu/abs/2024arXiv240504598L/abstract)). 
-`cuejax` requires [`E-FSPS`](https://github.com/efburnham/E-FSPS), a emulator-based stellar population synthesis (SPS) framework.
+Nebular emission is computed using [`cuejax`](https://github.com/efburnham/cue), a jax-compatible version of [`cue`](https://github.com/yi-jia-li/cue) ([Li et al. 2024](https://ui.adsabs.harvard.edu/abs/2025ApJ...986....9L/abstract)). 
+
+To install the `cuejax` version adapted to work with this branch of `prospector`:
+```bash
+git clone https://github.com/yi-jia-li/cue.git
+cd cue
+git checkout cuejax
+pip install .
+```
+
 The ionizing spectrum that powers the nebular emission can either be modeled as a 4-segment power-law or fixed to the spectrum of stellar populations:
 ```py
 from prospect.models.templates import TemplateLibrary
 TemplateLibrary["cue_nebular"] # Uses a power-law ionizing spectrum
 TemplateLibrary["cue_stellar_nebular"] # Uses the stellar ionizing spectrum
 ```
+**Note:** Dust emission is not yet fully implemented for compatibility with nebular emission.
 
 Migration from < v2.0
 ---------------------
diff --git a/prospect/sources/fake_fsps.py b/prospect/sources/fake_fsps.py
index 613741f0..3f569e3e 100644
--- a/prospect/sources/fake_fsps.py
+++ b/prospect/sources/fake_fsps.py
@@ -23,7 +23,7 @@
 __all__ = ["add_dust", "add_igm", "DustEmission"]
 
 
-def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=-1.0,dust1=0.0,**kwargs):
+def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=-0.7,dust2=0.0,dust1_index=-1.0,dust1=0.0,**kwargs):
     """
     wave: wavelength vector in Angstroms
     specs: spectral flux density, in (young, old) pairs
@@ -47,19 +47,20 @@ def add_dust(wave,specs,line_waves,lines,dust_type=0,dust_index=0.0,dust2=0.0,du
     attenuated_specs = attenuated_specs[0] + attenuated_specs[1]
     attenuated_lines = attenuated_lines[0] + attenuated_lines[1] 
     
-    if kwargs.get("add_dust_emission", None):
-        dust_specs = DustEmission(dust_file = os.getenv('SPS_HOME'),
-                                  spec_lambda = wave, **kwargs).compute_dust_emission(
-            attenuated_specs, specs[0]+specs[1], wave, 
-            diff_dust, attenuated_lines, lines[0]+lines[1])[0]
-        return dust_specs, attenuated_lines
+#     if kwargs.get("add_dust_emission", None):
+#         dust_specs = DustEmission(dust_file = os.getenv('SPS_HOME'),
+#                                   spec_lambda = wave, **kwargs).compute_dust_emission(
+#             attenuated_specs, specs[0]+specs[1], wave, 
+#             diff_dust, attenuated_lines, lines[0]+lines[1])[0]
+#         return dust_specs, attenuated_lines
     
-    else:
-        return attenuated_specs, attenuated_lines
+#     else:
+#         return attenuated_specs, attenuated_lines
+    return attenuated_specs, attenuated_lines
 
 
 
-def attenuate(spec,lam,dust_type=0,dust_index=0.0,dust2=0.0,dust1_index=0.0,dust1=0.0):
+def attenuate(spec,lam,dust_type=0,dust_index=-0.7,dust2=0.0,dust1_index=0.0,dust1=0.0):
     """returns F(obs) for a given attenuation curve + dust1 + dust2
     """
 
diff --git a/prospect/sources/nebssp_basis.py b/prospect/sources/nebssp_basis.py
index 2d173346..431b27ba 100644
--- a/prospect/sources/nebssp_basis.py
+++ b/prospect/sources/nebssp_basis.py
@@ -151,7 +151,7 @@ def get_galaxy_elines(self):
         # This allows subclasses to set their own specific emission line
         # luminosities within other methods, e.g., get_galaxy_spectrum, by
         # populating the `_specific_line_luminosity` attribute.
-        elum = getattr(self, "_line_specific_luminosity", None)
+        elum = getattr(self, "_line_specific_luminosity", None).copy()
         
         if elum is None:
             ewave = self.ssp.emline_wavelengths
@@ -274,7 +274,7 @@ def get_galaxy_elines(self):
         # This allows subclasses to set their own specific emission line
         # luminosities within other methods, e.g., get_galaxy_spectrum, by
         # populating the `_specific_line_luminosity` attribute.
-        elum = getattr(self, "_line_specific_luminosity", None)
+        elum = getattr(self, "_line_specific_luminosity", None).copy()
         ewave = self.emline_wavelengths
         
         if elum is None:
@@ -398,7 +398,7 @@ def get_galaxy_elines(self):
         # This allows subclasses to set their own specific emission line
         # luminosities within other methods, e.g., get_galaxy_spectrum, by
         # populating the `_specific_line_luminosity` attribute.
-        elum = getattr(self, "_line_specific_luminosity", None)
+        elum = getattr(self, "_line_specific_luminosity", None).copy()
         ewave = self.emline_wavelengths
         
         if elum is None:
diff --git a/tests/test_cue_eline.py b/tests/test_cue_eline.py
index a4443871..c6858c54 100644
--- a/tests/test_cue_eline.py
+++ b/tests/test_cue_eline.py
@@ -10,18 +10,18 @@
 from prospect.observation import from_oldstyle
 from prospect.models.templates import TemplateLibrary
 from prospect.models.sedmodel import SpecModel
-from prospect.sources.nebssp_basis import NebStepBasis, NebCSPBasis
+from prospect.sources.nebssp_basis import NebSSPBasis, NebStepBasis
 
 @pytest.fixture
 def get_sps():
-    sps = CSPSpecBasis(zcontinuous=1)
+    sps = NebSSPBasis(zcontinuous=1)
     return sps
 
 
 # test nebular line specification
 def test_eline_parsing():
     model_pars = TemplateLibrary["parametric_sfh"]
-    model_pars.update(TemplateLibrary["cue_nebular"])
+    model_pars.update(TemplateLibrary["cue_stellar_nebular"])
 
     # test ignoring a line
     lya = "Ly-alpha 1215"
@@ -84,13 +84,13 @@ def test_nebline_phot_addition(get_sps):
     # add nebline photometry in FSPS
     model_pars = TemplateLibrary["parametric_sfh"]
     model_pars["zred"]["init"] = zred
-    model_pars.update(TemplateLibrary["cue_nebular"])
+    model_pars.update(TemplateLibrary["cue_stellar_nebular"])
     m1 = SpecModel(model_pars)
 
     # adding nebline photometry by hand
     model_pars = TemplateLibrary["parametric_sfh"]
     model_pars["zred"]["init"] = zred
-    model_pars.update(TemplateLibrary["cue_nebular"])
+    model_pars.update(TemplateLibrary["cue_stellar_nebular"])
     model_pars["nebemlineinspec"]["init"] = False
     m2 = SpecModel(model_pars)
 
@@ -127,7 +127,7 @@ def test_filtersets(get_sps):
     # test SpecModel with nebular emission added by SpecModel
     model_pars = TemplateLibrary["parametric_sfh"]
     model_pars["zred"]["init"] = zred
-    model_pars.update(TemplateLibrary["cue_nebular"])
+    model_pars.update(TemplateLibrary["cue_stellar_nebular"])
     model_pars["nebemlineinspec"]["init"] = False
     models.append(SpecModel(model_pars))
 
@@ -153,7 +153,7 @@ def test_eline_implementation(get_sps, plot=False):
     obslist = build_obs(filters)
 
     model_pars = TemplateLibrary["parametric_sfh"]
-    model_pars.update(TemplateLibrary["cue_nebular"])
+    model_pars.update(TemplateLibrary["cue_stellar_nebular"])
     model_pars["nebemlineinspec"]["init"] = False
     model_pars["eline_sigma"] = dict(init=500)
     model_pars["zred"]["init"] = 4

From c29991576b6c8b7d90d5552402d70999b124595c Mon Sep 17 00:00:00 2001
From: yi-jia-li <yzl466@psu.edu>
Date: Fri, 13 Jun 2025 09:30:01 -0400
Subject: [PATCH 132/132] add a demo

---
 README.md                        |    2 +-
 demo/prospector+cue.ipynb        | 1028 ++++++++++++++++++++++++++++++
 prospect/sources/nebssp_basis.py |    4 +-
 3 files changed, 1031 insertions(+), 3 deletions(-)
 create mode 100644 demo/prospector+cue.ipynb

diff --git a/README.md b/README.md
index 5dbfe012..80fb0c6a 100644
--- a/README.md
+++ b/README.md
@@ -41,7 +41,7 @@ git checkout cuejax
 pip install .
 ```
 
-The ionizing spectrum that powers the nebular emission can either be modeled as a 4-segment power-law or fixed to the spectrum of stellar populations:
+The ionizing spectrum that powers the nebular emission can either be modeled as a 4-segment power-law or fixed to the spectrum of stellar populations ([example](https://github.com/yi-jia-li/prospector/tree/add_cue/demo/prospector+cue.ipynb)):
 ```py
 from prospect.models.templates import TemplateLibrary
 TemplateLibrary["cue_nebular"] # Uses a power-law ionizing spectrum
diff --git a/demo/prospector+cue.ipynb b/demo/prospector+cue.ipynb
new file mode 100644
index 00000000..ae40675f
--- /dev/null
+++ b/demo/prospector+cue.ipynb
@@ -0,0 +1,1028 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1e1551e6",
+   "metadata": {},
+   "source": [
+    "**An example of using [`Cue`]( https://github.com/yi-jia-li/cue) to predict nebular emission in prospector**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9fde360",
+   "metadata": {},
+   "source": [
+    "We provide three SPS classes in [nebssp_basis.py](https://github.com/yi-jia-li/prospector/tree/add_cue/prospect/sources/nebssp_basis.py) that use the nebular continuum and emission lines predicted by Cue. Previously, nebular emission was added within FSPS using the precomputed [`CloudyFSPS`](https://github.com/nell-byler/cloudyfsps) nebular grid, which was based on SSPs and included two free parameters: the ionization parameter U and the gas-phas metallicity O/H. Switching to Cue allows additional flexibility in modeling the ionizing spectrum, gas density, N/O, and C/O, where we model the ionizing spectrum with 4-piecewise power laws.\n",
+    "\n",
+    "Dust attenuation and IGM absorption have been moved out of FSPS and are applied to the nebular emission in [fake_fsps.py](https://github.com/yi-jia-li/prospector/tree/add_cue/prospect/sources/fake_fsps.py). Dust emission has not yet been fully implemented."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d93f5b30",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:21:56.591776Z",
+     "start_time": "2025-06-13T13:21:48.751716Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# NebStepBasis and NebSSPBasis are adapted from FastStepBasis, SSPBasis to use Cue predictions\n",
+    "from prospect.sources.nebssp_basis import NebStepBasis, NebSSPBasis\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "from sedpy import observate\n",
+    "from prospect.observation import from_oldstyle\n",
+    "from prospect.models.templates import TemplateLibrary\n",
+    "from prospect.models.sedmodel import SpecModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1183eeea",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:21:56.635596Z",
+     "start_time": "2025-06-13T13:21:56.596694Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Build obs with a wide wavelength grid\n",
+    "def build_obs(filts):\n",
+    "    obs = dict(filters=filts,\n",
+    "               wavelength=np.linspace(3000, 30000, 1000),\n",
+    "               spectrum=np.ones(1000),\n",
+    "               unc=np.ones(1000)*0.1,\n",
+    "               maggies=np.ones(len(filts))*1e-7,\n",
+    "               maggies_unc=np.ones(len(filts))*1e-8)\n",
+    "    sdat, pdat = from_oldstyle(obs)\n",
+    "    obslist = [sdat, pdat]\n",
+    "    [obs.rectify() for obs in obslist]\n",
+    "    return obslist\n",
+    "\n",
+    "filters = observate.load_filters([f\"sdss_{b}0\" for b in \"ugriz\"])\n",
+    "obslist = build_obs(filters)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d8f32478",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:22:25.137793Z",
+     "start_time": "2025-06-13T13:21:56.639786Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Build SPS with cue SPS classes\n",
+    "def get_sps():\n",
+    "    sps = NebStepBasis(zcontinuous=1)\n",
+    "    return sps\n",
+    "sps = get_sps()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "581d24c1",
+   "metadata": {},
+   "source": [
+    "Cue parameters and their priors are in:\n",
+    "```py\n",
+    "TemplateLibrary[\"cue_stellar_nebular\"]\n",
+    "TemplateLibrary[\"cue_nebular\"]\n",
+    "```\n",
+    "\n",
+    "Using the `cue_stellar_nebular` option fixes the ionizing sources to the stellar populations. In this case, we fit the ionizing spectra of the young and old stellar population to get the power-law parameters and the nebular emission is modeled with 5 free paramters: \n",
+    "- gas_logu, gas_lognH, gas_logz, gas_logno, gas_logco.\n",
+    "\n",
+    "Using the option `cue_nebular` fits the ionizing spectrum. In this case, the nebular emission is modeled with 13 free paramters: \n",
+    "- 5 parameters for the gas properties (same as above)\n",
+    "- 8 parameters describing the ionizing radiation \n",
+    " - power-law index: ionspec_index1, ionspec_index2, ionspec_index3, ionspec_index4\n",
+    " - ratios of luminosities between adjacent bins: ionspec_logLratio1, ionspec_logLratio2, ionspec_logLratio3\n",
+    " - total ionizing photon output used to scale the cue prediction: gas_logqion\n",
+    "\n",
+    "The option `use_eline_nn_unc` adds uncertainties from cue to the likelihood when fitting emission lines. This is set to False by default."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e867c8c5",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:22:25.162359Z",
+     "start_time": "2025-06-13T13:22:25.143613Z"
+    },
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       ":::::::\n",
+       "<class 'prospect.models.sedmodel.SpecModel'>\n",
+       "\n",
+       "Free Parameters: (name: prior) \n",
+       "-----------\n",
+       "  logzsol: <class 'prospect.models.priors.TopHat'>(mini=-2,maxi=0.19)\n",
+       "  dust2: <class 'prospect.models.priors.TopHat'>(mini=0.0,maxi=2.0)\n",
+       "  logmass: <class 'prospect.models.priors.TopHat'>(mini=7,maxi=12)\n",
+       "  logsfr_ratios: <class 'prospect.models.priors.StudentT'>(mean=[0. 0.],scale=[0.3 0.3],df=[2 2])\n",
+       "  gas_logz: <class 'prospect.models.priors.TopHat'>(mini=-2.2,maxi=0.5)\n",
+       "  gas_logu: <class 'prospect.models.priors.TopHat'>(mini=-4.0,maxi=-1.0)\n",
+       "  gas_lognH: <class 'prospect.models.priors.TopHat'>(mini=1.0,maxi=4.0)\n",
+       "  gas_logno: <class 'prospect.models.priors.TopHat'>(mini=-1.0,maxi=0.7323937598229685)\n",
+       "  gas_logco: <class 'prospect.models.priors.TopHat'>(mini=-1.0,maxi=0.7323937598229685)\n",
+       "\n",
+       "Fixed Parameters: (name: value [, depends_on]) \n",
+       "-----------\n",
+       "  zred: [1.] \n",
+       "  mass: [1000000.] <function logsfr_ratios_to_masses at 0x14c8eaa16440>\n",
+       "  sfh: [3] \n",
+       "  imf_type: [2] \n",
+       "  dust_type: [0] \n",
+       "  agebins: [[ 0.  8.]\n",
+       " [ 8.  9.]\n",
+       " [ 9. 10.]] \n",
+       "  add_neb_emission: [ True] \n",
+       "  add_neb_continuum: [ True] \n",
+       "  nebemlineinspec: [False] \n",
+       "  use_eline_nn_unc: [False] \n",
+       "  use_stellar_ionizing: [ True] "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Build a model with flexible SFH, dust, and nebular emission\n",
+    "model_pars = TemplateLibrary[\"continuity_sfh\"]\n",
+    "model_pars[\"zred\"][\"init\"] = 1.0\n",
+    "model_pars.update(TemplateLibrary[\"cue_stellar_nebular\"])\n",
+    "model_pars[\"nebemlineinspec\"][\"init\"] = False\n",
+    "model_pars['use_eline_nn_unc'][\"init\"] = False\n",
+    "model = SpecModel(model_pars)\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bdc8ad5d",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:22:25.181192Z",
+     "start_time": "2025-06-13T13:22:25.168693Z"
+    },
+    "code_folding": [
+     0
+    ],
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "zred 1.0\n",
+      "mass 1000000.0\n",
+      "logzsol -0.5\n",
+      "dust2 0.6\n",
+      "sfh 3\n",
+      "imf_type 2\n",
+      "dust_type 0\n",
+      "logmass 10\n",
+      "agebins [[ 0.  8.]\n",
+      " [ 8.  9.]\n",
+      " [ 9. 10.]]\n",
+      "logsfr_ratios [0. 0.]\n",
+      "add_neb_emission True\n",
+      "add_neb_continuum True\n",
+      "nebemlineinspec False\n",
+      "use_eline_nn_unc False\n",
+      "use_stellar_ionizing True\n",
+      "gas_logz 0.0\n",
+      "gas_logu -2.0\n",
+      "gas_lognH 2.0\n",
+      "gas_logno 0.0\n",
+      "gas_logco 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Model parameters\n",
+    "for k in model.params:\n",
+    "    print(k, model.params[k].squeeze())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "1b23e666",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:23:26.038297Z",
+     "start_time": "2025-06-13T13:22:25.187781Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "([array([3.32612734e-11, 3.34332987e-11, 3.36741710e-11, 2.61985867e-11,\n",
+       "         3.72183178e-11, 3.29318925e-11, 3.48133953e-11, 3.61936374e-11,\n",
+       "         3.55829416e-11, 3.46668826e-11, 3.60668389e-11, 3.77962145e-11,\n",
+       "         3.72069220e-11, 3.67232955e-11, 3.85776440e-11, 3.79396438e-11,\n",
+       "         3.53451581e-11, 3.87719199e-11, 3.81363788e-11, 3.95781581e-11,\n",
+       "         3.82215038e-11, 3.96516886e-11, 4.09839238e-11, 4.02916679e-11,\n",
+       "         3.96793528e-11, 4.02172005e-11, 3.79197082e-11, 4.00367562e-11,\n",
+       "         4.12465081e-11, 3.83181872e-11, 4.06302829e-11, 4.06338984e-11,\n",
+       "         3.95996814e-11, 4.25258434e-11, 4.14917596e-11, 4.36387153e-11,\n",
+       "         4.25311757e-11, 4.13927101e-11, 4.22285448e-11, 4.32672487e-11,\n",
+       "         4.14802306e-11, 4.38709008e-11, 4.33839027e-11, 4.45115256e-11,\n",
+       "         4.38628090e-11, 4.37768526e-11, 4.57835886e-11, 4.43125782e-11,\n",
+       "         4.54587921e-11, 4.55901004e-11, 4.50646474e-11, 4.57683708e-11,\n",
+       "         4.66663216e-11, 4.51069787e-11, 4.58706219e-11, 4.60621828e-11,\n",
+       "         4.50451712e-11, 4.68762419e-11, 4.73393019e-11, 4.56895606e-11,\n",
+       "         4.64332555e-11, 4.62403240e-11, 4.52153895e-11, 4.58615975e-11,\n",
+       "         4.50833055e-11, 4.49921103e-11, 4.55488049e-11, 4.46825042e-11,\n",
+       "         4.68210506e-11, 4.60633751e-11, 4.73996844e-11, 4.78546334e-11,\n",
+       "         4.71804749e-11, 4.73398245e-11, 4.82436931e-11, 4.75138139e-11,\n",
+       "         4.61743406e-11, 4.62934603e-11, 4.87026999e-11, 4.94673693e-11,\n",
+       "         4.98445445e-11, 4.95687109e-11, 4.82498217e-11, 4.98757761e-11,\n",
+       "         5.11354910e-11, 5.43581396e-11, 5.33379939e-11, 5.39296628e-11,\n",
+       "         5.44002612e-11, 5.42545543e-11, 5.26268910e-11, 5.29874880e-11,\n",
+       "         5.11242024e-11, 5.19786012e-11, 5.38554093e-11, 5.38564041e-11,\n",
+       "         4.79091738e-11, 5.45548116e-11, 5.77124625e-11, 5.62908247e-11,\n",
+       "         5.40522669e-11, 5.76984294e-11, 5.71965926e-11, 5.88548453e-11,\n",
+       "         6.25226706e-11, 6.30423899e-11, 6.17302172e-11, 6.15650760e-11,\n",
+       "         6.28135904e-11, 6.25687682e-11, 6.13830601e-11, 6.32568766e-11,\n",
+       "         6.50322783e-11, 6.53614638e-11, 6.56783141e-11, 6.69277464e-11,\n",
+       "         6.62575921e-11, 6.81368817e-11, 6.54889009e-11, 6.98360985e-11,\n",
+       "         6.80608737e-11, 6.89603774e-11, 6.97986805e-11, 6.79190093e-11,\n",
+       "         7.26585990e-11, 6.95334082e-11, 7.36352232e-11, 7.12860418e-11,\n",
+       "         7.04852694e-11, 7.43025265e-11, 7.65618799e-11, 7.68560281e-11,\n",
+       "         7.68102598e-11, 8.10721185e-11, 7.80218336e-11, 7.81431206e-11,\n",
+       "         7.81536659e-11, 7.87185875e-11, 7.64529855e-11, 7.84887691e-11,\n",
+       "         7.89451254e-11, 8.08656921e-11, 8.05237334e-11, 8.32686286e-11,\n",
+       "         8.05041011e-11, 8.30847404e-11, 8.46647121e-11, 8.72101515e-11,\n",
+       "         8.66449319e-11, 8.68822093e-11, 8.46304751e-11, 9.07829880e-11,\n",
+       "         8.95182137e-11, 8.62034722e-11, 8.47241222e-11, 9.06580501e-11,\n",
+       "         8.97857376e-11, 9.09107781e-11, 9.13029745e-11, 8.46655224e-11,\n",
+       "         8.93360741e-11, 8.57893790e-11, 8.45561353e-11, 8.67467091e-11,\n",
+       "         9.07875502e-11, 1.04791164e-10, 1.00220742e-10, 1.06799451e-10,\n",
+       "         9.75844703e-11, 1.34431092e-10, 1.00052268e-10, 1.34901195e-10,\n",
+       "         1.23675515e-10, 9.46073615e-11, 1.35438349e-10, 1.64194615e-10,\n",
+       "         1.29574880e-10, 1.12903558e-10, 1.40267677e-10, 1.49882952e-10,\n",
+       "         1.23680249e-10, 1.45332501e-10, 1.36312007e-10, 9.85706782e-11,\n",
+       "         1.53226309e-10, 1.66892255e-10, 1.71124642e-10, 1.69674778e-10,\n",
+       "         1.72844897e-10, 1.72512254e-10, 1.68461537e-10, 1.66836427e-10,\n",
+       "         1.50568583e-10, 1.42414642e-10, 1.67215162e-10, 1.72462930e-10,\n",
+       "         1.74926270e-10, 1.77577042e-10, 1.70952358e-10, 1.76467622e-10,\n",
+       "         1.74300358e-10, 1.78237567e-10, 1.74599509e-10, 1.80522168e-10,\n",
+       "         1.79591288e-10, 1.77351092e-10, 1.77309236e-10, 1.65995164e-10,\n",
+       "         1.61086870e-10, 1.72509254e-10, 1.55132404e-10, 1.60358154e-10,\n",
+       "         1.85605628e-10, 1.83558098e-10, 1.82441715e-10, 1.85886055e-10,\n",
+       "         1.92691424e-10, 1.95985928e-10, 1.96476758e-10, 1.91165037e-10,\n",
+       "         2.01554710e-10, 2.01060463e-10, 2.07780182e-10, 2.12081750e-10,\n",
+       "         2.00948984e-10, 2.03976359e-10, 2.04183012e-10, 2.10608807e-10,\n",
+       "         2.07305263e-10, 2.07664329e-10, 2.12471165e-10, 2.15137138e-10,\n",
+       "         2.16588049e-10, 2.16385258e-10, 2.17041979e-10, 2.18188993e-10,\n",
+       "         2.21501007e-10, 2.19507031e-10, 2.21792326e-10, 2.21566841e-10,\n",
+       "         2.24008501e-10, 2.25446307e-10, 2.24947515e-10, 2.26557663e-10,\n",
+       "         2.27027493e-10, 2.28014890e-10, 2.26732915e-10, 2.20951396e-10,\n",
+       "         2.05741889e-10, 2.24931958e-10, 2.12386367e-10, 2.21470393e-10,\n",
+       "         2.29719651e-10, 2.26416513e-10, 2.31920478e-10, 2.34906875e-10,\n",
+       "         3.28770247e-10, 2.35254436e-10, 2.28517449e-10, 2.30487655e-10,\n",
+       "         4.41414230e-10, 2.32621977e-10, 2.30117188e-10, 2.38700520e-10,\n",
+       "         2.38068426e-10, 2.32871365e-10, 2.35148858e-10, 2.35807372e-10,\n",
+       "         2.38146883e-10, 2.34698529e-10, 2.32657026e-10, 2.31276897e-10,\n",
+       "         2.24150199e-10, 2.32308336e-10, 2.35156622e-10, 2.40674481e-10,\n",
+       "         2.39580250e-10, 2.50020258e-10, 2.47121311e-10, 2.35373841e-10,\n",
+       "         2.52069612e-10, 2.54659328e-10, 2.59261298e-10, 2.49709133e-10,\n",
+       "         2.54316240e-10, 2.60405257e-10, 2.61021613e-10, 2.61349005e-10,\n",
+       "         2.58025368e-10, 2.52993536e-10, 2.62811065e-10, 2.59155050e-10,\n",
+       "         2.65039015e-10, 2.65300839e-10, 2.63494734e-10, 2.63617377e-10,\n",
+       "         2.67089896e-10, 2.65888508e-10, 2.68407935e-10, 2.75184081e-10,\n",
+       "         2.75472436e-10, 2.70373808e-10, 2.72114385e-10, 2.66073493e-10,\n",
+       "         2.75807107e-10, 2.74900187e-10, 2.79294407e-10, 2.77213800e-10,\n",
+       "         2.73899788e-10, 2.81800042e-10, 2.80188796e-10, 2.77937832e-10,\n",
+       "         2.80056496e-10, 2.88130440e-10, 2.88670896e-10, 2.86896824e-10,\n",
+       "         2.90382970e-10, 2.84576405e-10, 2.90671905e-10, 2.92270878e-10,\n",
+       "         2.96549343e-10, 2.95748719e-10, 2.91984867e-10, 2.92247464e-10,\n",
+       "         2.99273084e-10, 2.79858561e-10, 2.91420090e-10, 2.93995272e-10,\n",
+       "         2.97498569e-10, 2.97873454e-10, 2.99109292e-10, 3.01708496e-10,\n",
+       "         2.98659892e-10, 3.00341295e-10, 2.98876088e-10, 3.01539042e-10,\n",
+       "         3.07888426e-10, 3.07270079e-10, 3.06490931e-10, 3.07474035e-10,\n",
+       "         3.06329889e-10, 3.05779681e-10, 3.06665475e-10, 3.02514992e-10,\n",
+       "         3.05212945e-10, 3.00664699e-10, 3.04345578e-10, 3.07537167e-10,\n",
+       "         3.10010385e-10, 3.05068465e-10, 3.04606116e-10, 3.03209416e-10,\n",
+       "         3.01595138e-10, 3.09608827e-10, 3.13521048e-10, 3.13473395e-10,\n",
+       "         3.21851459e-10, 3.14440292e-10, 3.16210879e-10, 3.18092237e-10,\n",
+       "         3.17601025e-10, 3.22164570e-10, 3.22044841e-10, 3.20170155e-10,\n",
+       "         3.20228189e-10, 3.22661043e-10, 3.24111354e-10, 3.20379973e-10,\n",
+       "         3.25410697e-10, 3.25194617e-10, 3.18818085e-10, 3.29175070e-10,\n",
+       "         3.30176237e-10, 3.26978527e-10, 4.00987508e-10, 2.62199297e-09,\n",
+       "         5.91345875e-10, 3.27549552e-10, 3.31690875e-10, 3.36155304e-10,\n",
+       "         3.33892069e-10, 3.36356068e-10, 3.35388134e-10, 3.44570711e-10,\n",
+       "         3.38169181e-10, 3.37128476e-10, 4.61759273e-10, 4.83992808e-10,\n",
+       "         3.38020161e-10, 3.39143771e-10, 3.38865455e-10, 3.42309037e-10,\n",
+       "         3.41746619e-10, 3.41688988e-10, 3.45191848e-10, 3.43997864e-10,\n",
+       "         3.43820335e-10, 3.46542697e-10, 3.48284841e-10, 3.50971932e-10,\n",
+       "         3.51963325e-10, 3.50779053e-10, 3.51375729e-10, 3.51400192e-10,\n",
+       "         3.52887357e-10, 3.53120916e-10, 3.53576550e-10, 3.53745145e-10,\n",
+       "         3.52985689e-10, 3.53634160e-10, 3.57601871e-10, 3.56934809e-10,\n",
+       "         3.55895536e-10, 3.54289372e-10, 3.51956669e-10, 3.51722166e-10,\n",
+       "         3.50502355e-10, 4.04244959e-10, 3.50882610e-10, 3.52680391e-10,\n",
+       "         3.54592600e-10, 3.51614061e-10, 3.54495301e-10, 3.56727326e-10,\n",
+       "         3.61839796e-10, 3.64056836e-10, 3.64018310e-10, 3.66508552e-10,\n",
+       "         3.64819001e-10, 3.64545876e-10, 3.68462550e-10, 3.70971797e-10,\n",
+       "         3.74089034e-10, 3.73375290e-10, 3.73585632e-10, 3.76953659e-10,\n",
+       "         3.73539988e-10, 3.74115779e-10, 3.71888151e-10, 3.78520659e-10,\n",
+       "         3.79783550e-10, 3.81400335e-10, 3.83023035e-10, 3.83868673e-10,\n",
+       "         3.82366828e-10, 3.83743998e-10, 3.86746191e-10, 3.90773990e-10,\n",
+       "         3.90903920e-10, 3.90509089e-10, 3.88973118e-10, 3.89519611e-10,\n",
+       "         3.89271202e-10, 3.86961073e-10, 3.91019045e-10, 3.89146287e-10,\n",
+       "         3.80768126e-10, 3.86266088e-10, 3.89552910e-10, 3.87656317e-10,\n",
+       "         3.84962796e-10, 3.90237062e-10, 3.91083774e-10, 3.93587309e-10,\n",
+       "         3.94623654e-10, 3.93533276e-10, 3.95217776e-10, 3.98036549e-10,\n",
+       "         3.98670331e-10, 3.96536171e-10, 3.98381956e-10, 4.00579061e-10,\n",
+       "         3.99216586e-10, 3.97384806e-10, 3.95728138e-10, 3.94124645e-10,\n",
+       "         3.94130670e-10, 3.92186009e-10, 3.98402164e-10, 4.02185359e-10,\n",
+       "         4.02599913e-10, 4.02400328e-10, 4.05587483e-10, 4.05350996e-10,\n",
+       "         4.05871171e-10, 4.06257103e-10, 4.06846365e-10, 4.04646150e-10,\n",
+       "         4.04678097e-10, 4.07194153e-10, 4.09134722e-10, 4.11629256e-10,\n",
+       "         4.12717349e-10, 4.13578642e-10, 4.12345907e-10, 4.07015620e-10,\n",
+       "         4.03844825e-10, 4.05401476e-10, 4.08298780e-10, 4.09631506e-10,\n",
+       "         4.11250911e-10, 4.12896273e-10, 4.12404441e-10, 4.10050959e-10,\n",
+       "         4.08800321e-10, 4.07461632e-10, 4.05739745e-10, 4.09389852e-10,\n",
+       "         4.10110358e-10, 4.08919552e-10, 4.08743560e-10, 4.13829894e-10,\n",
+       "         4.13043189e-10, 4.08113595e-10, 4.08510616e-10, 4.12402857e-10,\n",
+       "         4.11260637e-10, 4.11321804e-10, 3.96171003e-10, 4.05528574e-10,\n",
+       "         4.07523215e-10, 3.75775736e-10, 3.90894675e-10, 4.20569625e-10,\n",
+       "         4.27386901e-10, 4.18954456e-10, 4.19261539e-10, 4.26594166e-10,\n",
+       "         4.31442737e-10, 4.20722247e-10, 3.87582003e-10, 4.02165029e-10,\n",
+       "         4.23274523e-10, 4.32370575e-10, 4.35783006e-10, 4.35513153e-10,\n",
+       "         4.26680722e-10, 4.22350513e-10, 4.33360450e-10, 4.41001919e-10,\n",
+       "         4.39861641e-10, 4.38088371e-10, 4.42227676e-10, 4.42627715e-10,\n",
+       "         4.36808653e-10, 4.24907864e-10, 4.32298309e-10, 4.42869821e-10,\n",
+       "         4.46694323e-10, 4.46608727e-10, 4.46486751e-10, 4.47471823e-10,\n",
+       "         4.49888152e-10, 4.48926064e-10, 4.47444443e-10, 4.39779194e-10,\n",
+       "         4.28831767e-10, 4.33953146e-10, 4.49818512e-10, 4.54907907e-10,\n",
+       "         7.75613370e-10, 4.55697583e-10, 4.48960168e-10, 4.53273214e-10,\n",
+       "         4.56604638e-10, 4.55922005e-10, 4.52970790e-10, 4.50222174e-10,\n",
+       "         4.47897596e-10, 4.46072801e-10, 4.41608231e-10, 4.34431507e-10,\n",
+       "         4.42229635e-10, 4.34705443e-10, 4.42249938e-10, 4.48509397e-10,\n",
+       "         4.52288529e-10, 4.53848866e-10, 4.55489007e-10, 4.56848027e-10,\n",
+       "         4.57140519e-10, 4.55240976e-10, 4.53081245e-10, 4.52990227e-10,\n",
+       "         4.52980030e-10, 4.51230118e-10, 4.50860172e-10, 4.52399280e-10,\n",
+       "         4.53865670e-10, 4.56236864e-10, 4.58616534e-10, 4.59836238e-10,\n",
+       "         4.60306472e-10, 4.59703818e-10, 6.11456675e-10, 5.41398951e-10,\n",
+       "         4.55379487e-10, 4.54843979e-10, 4.61057697e-10, 4.64210351e-10,\n",
+       "         4.65018549e-10, 4.64771346e-10, 4.63632105e-10, 4.62866231e-10,\n",
+       "         4.63092474e-10, 4.64183429e-10, 4.65428896e-10, 4.66590350e-10,\n",
+       "         4.67131280e-10, 4.66536727e-10, 4.66211737e-10, 4.67346939e-10,\n",
+       "         4.68093972e-10, 4.68362822e-10, 4.70702060e-10, 4.74208356e-10,\n",
+       "         4.76189475e-10, 4.76969493e-10, 4.78287415e-10, 4.78019310e-10,\n",
+       "         4.78253932e-10, 4.77894190e-10, 4.77692309e-10, 4.77974591e-10,\n",
+       "         4.78798468e-10, 4.80164659e-10, 4.81606731e-10, 4.82281277e-10,\n",
+       "         4.82068121e-10, 4.81584618e-10, 4.80730273e-10, 4.77253677e-10,\n",
+       "         4.70657299e-10, 5.90248461e-10, 4.71914851e-10, 4.79504137e-10,\n",
+       "         4.84843945e-10, 4.87548630e-10, 4.88007364e-10, 4.87603049e-10,\n",
+       "         4.87102633e-10, 4.88024781e-10, 4.89602992e-10, 4.90358971e-10,\n",
+       "         4.90435868e-10, 4.90840031e-10, 4.92286409e-10, 4.94040867e-10,\n",
+       "         4.94529767e-10, 4.94462165e-10, 4.94764870e-10, 4.95147279e-10,\n",
+       "         4.95049331e-10, 5.00455686e-10, 4.91309422e-10, 4.92061863e-10,\n",
+       "         4.93952548e-10, 4.94378702e-10, 4.94514061e-10, 4.95828534e-10,\n",
+       "         4.97583584e-10, 4.98699579e-10, 4.99231177e-10, 4.98749527e-10,\n",
+       "         4.98692305e-10, 4.99320433e-10, 4.99813358e-10, 5.00469736e-10,\n",
+       "         5.01129290e-10, 5.01855954e-10, 5.02433820e-10, 5.01407225e-10,\n",
+       "         4.98959842e-10, 4.97805954e-10, 4.99378860e-10, 5.02248690e-10,\n",
+       "         5.04418603e-10, 5.03669074e-10, 5.01098970e-10, 4.99169162e-10,\n",
+       "         4.98712274e-10, 5.00345259e-10, 5.01522977e-10, 5.01260777e-10,\n",
+       "         5.01890956e-10, 5.03915840e-10, 5.04915155e-10, 5.04442419e-10,\n",
+       "         5.04471625e-10, 5.04314981e-10, 5.18209274e-10, 6.69827597e-10,\n",
+       "         5.05442020e-10, 5.02916483e-10, 5.00352840e-10, 5.00480761e-10,\n",
+       "         5.00392327e-10, 4.94815260e-10, 4.87809987e-10, 4.87874240e-10,\n",
+       "         4.82726453e-10, 4.83116743e-10, 4.84691765e-10, 4.86732934e-10,\n",
+       "         4.88293481e-10, 4.90330275e-10, 4.93062162e-10, 4.95216089e-10,\n",
+       "         4.96574205e-10, 4.97600677e-10, 4.98261352e-10, 4.98302209e-10,\n",
+       "         4.98239688e-10, 4.98935234e-10, 5.00151574e-10, 5.01215438e-10,\n",
+       "         5.01824239e-10, 5.02145823e-10, 5.03326100e-10, 5.05168714e-10,\n",
+       "         5.05649451e-10, 5.04529726e-10, 5.03999535e-10, 5.05442159e-10,\n",
+       "         5.06391556e-10, 5.06059553e-10, 5.06123376e-10, 5.06566819e-10,\n",
+       "         5.06989013e-10, 5.07574350e-10, 5.07626295e-10, 5.06706904e-10,\n",
+       "         5.06140979e-10, 5.06928166e-10, 5.08594437e-10, 5.10519820e-10,\n",
+       "         5.12825122e-10, 5.14869058e-10, 5.15583098e-10, 5.15532830e-10,\n",
+       "         5.16208401e-10, 5.17558548e-10, 5.18986947e-10, 5.20463928e-10,\n",
+       "         5.21465753e-10, 5.21065337e-10, 5.18454903e-10, 5.14714368e-10,\n",
+       "         5.12985954e-10, 5.14378477e-10, 5.16769132e-10, 5.19003485e-10,\n",
+       "         5.20849500e-10, 5.21240077e-10, 5.21243872e-10, 5.22906118e-10,\n",
+       "         5.25582817e-10, 5.27057742e-10, 5.26717211e-10, 5.25087245e-10,\n",
+       "         5.23419247e-10, 5.23290511e-10, 5.24830279e-10, 5.25316599e-10,\n",
+       "         5.23757946e-10, 5.23941404e-10, 5.26889964e-10, 5.27493944e-10,\n",
+       "         5.24892870e-10, 5.24079532e-10, 5.27633553e-10, 5.31877377e-10,\n",
+       "         5.33455366e-10, 5.32112109e-10, 5.28787447e-10, 5.24957147e-10,\n",
+       "         5.23979599e-10, 5.27056634e-10, 5.30536197e-10, 5.31521212e-10,\n",
+       "         5.32095330e-10, 5.34005573e-10, 5.34839138e-10, 5.33963115e-10,\n",
+       "         5.33270494e-10, 5.34189055e-10, 5.36558979e-10, 5.39213413e-10,\n",
+       "         5.41074580e-10, 5.41759725e-10, 5.41591459e-10, 5.41392692e-10,\n",
+       "         5.41685972e-10, 5.42274058e-10, 5.42879601e-10, 5.43276415e-10,\n",
+       "         5.43014714e-10, 5.42500147e-10, 5.43045983e-10, 5.44528363e-10,\n",
+       "         5.45549826e-10, 5.45748946e-10, 5.45655719e-10, 5.45965104e-10,\n",
+       "         5.46659699e-10, 5.46984927e-10, 5.46700060e-10, 5.46289427e-10,\n",
+       "         5.45885735e-10, 5.46085362e-10, 5.47732314e-10, 5.49708531e-10,\n",
+       "         5.50863318e-10, 5.51197428e-10, 5.50764366e-10, 5.49808426e-10,\n",
+       "         5.49411941e-10, 5.50008874e-10, 5.50753026e-10, 5.57713970e-10,\n",
+       "         5.52521377e-10, 5.52943771e-10, 5.53313320e-10, 5.53394132e-10,\n",
+       "         5.53357115e-10, 5.53636062e-10, 5.54274187e-10, 5.55010218e-10,\n",
+       "         5.56090931e-10, 5.57388311e-10, 5.58163149e-10, 5.58269645e-10,\n",
+       "         5.58398861e-10, 5.58900467e-10, 5.58825407e-10, 5.56616813e-10,\n",
+       "         5.51263775e-10, 5.64960050e-10, 9.79792694e-10, 5.45818715e-10,\n",
+       "         5.52364192e-10, 5.57118351e-10, 5.58163221e-10, 5.57111956e-10,\n",
+       "         5.56613212e-10, 5.57846910e-10, 5.60009733e-10, 5.62204714e-10,\n",
+       "         5.63716106e-10, 5.64217504e-10, 5.64468953e-10, 5.64908560e-10,\n",
+       "         5.65259852e-10, 5.65629756e-10, 5.66394846e-10, 5.67476219e-10,\n",
+       "         5.68245002e-10, 5.68234667e-10, 5.67456715e-10, 5.65966244e-10,\n",
+       "         5.64294966e-10, 5.63518985e-10, 5.64160241e-10, 5.66229957e-10,\n",
+       "         5.68824580e-10, 5.70697655e-10, 5.71692536e-10, 5.72463025e-10,\n",
+       "         5.73275756e-10, 5.73407192e-10, 5.71987182e-10, 5.68903259e-10,\n",
+       "         5.65254217e-10, 5.63015561e-10, 5.62808929e-10, 5.63647153e-10,\n",
+       "         5.64486994e-10, 5.64418891e-10, 5.63447650e-10, 5.62463871e-10,\n",
+       "         5.62155516e-10, 5.62503020e-10, 5.63120635e-10, 5.64005704e-10,\n",
+       "         5.65085609e-10, 5.65766082e-10, 5.65665057e-10, 5.65040452e-10,\n",
+       "         5.64740397e-10, 5.65356114e-10, 5.66156259e-10, 5.66077010e-10,\n",
+       "         5.65306216e-10, 5.64735005e-10, 5.64621592e-10, 5.64723429e-10,\n",
+       "         5.64868415e-10, 5.64917353e-10, 5.65088348e-10, 5.65783867e-10,\n",
+       "         5.66630152e-10, 5.67030305e-10, 5.67289147e-10, 5.68042349e-10,\n",
+       "         5.69310673e-10, 5.70702060e-10, 5.71891037e-10, 5.72738547e-10,\n",
+       "         5.73364058e-10, 5.74016064e-10, 5.74678935e-10, 5.74922204e-10,\n",
+       "         5.74385547e-10, 5.73304922e-10, 5.72425798e-10, 5.72432667e-10,\n",
+       "         5.72892395e-10, 5.72392764e-10, 5.70868747e-10, 5.70318548e-10,\n",
+       "         5.71533286e-10, 5.73151166e-10, 5.74042216e-10, 5.74000473e-10,\n",
+       "         5.73290731e-10, 5.72967594e-10, 5.74016732e-10, 5.75711074e-10,\n",
+       "         5.76449362e-10, 5.75660177e-10, 5.74225827e-10, 5.73264779e-10,\n",
+       "         5.72693036e-10, 5.71669180e-10, 5.70344265e-10, 5.69948591e-10,\n",
+       "         5.70901242e-10, 5.72090974e-10, 5.72470955e-10, 5.72176602e-10,\n",
+       "         5.71715418e-10, 5.71092108e-10, 5.70429079e-10, 5.70522603e-10,\n",
+       "         5.71780930e-10, 5.73247250e-10, 5.74192330e-10, 5.75150385e-10,\n",
+       "         5.76622367e-10, 5.78238297e-10, 5.79563887e-10, 5.80620567e-10,\n",
+       "         5.81392735e-10, 5.81394423e-10, 5.80422509e-10, 5.79347061e-10,\n",
+       "         5.79213363e-10, 5.79949347e-10, 5.81426742e-10, 5.84095460e-10,\n",
+       "         5.86830543e-10, 5.87871488e-10, 5.87313114e-10, 5.86098812e-10,\n",
+       "         5.84653425e-10, 5.83044655e-10, 5.82291786e-10, 5.82983528e-10,\n",
+       "         5.83435196e-10, 5.81502138e-10, 5.78001571e-10, 5.76245978e-10,\n",
+       "         5.77288798e-10, 5.78789178e-10, 5.79554622e-10, 5.79817149e-10,\n",
+       "         5.80034867e-10, 5.81385641e-10, 5.83940001e-10, 5.86220206e-10,\n",
+       "         5.87361186e-10, 5.88078395e-10, 5.89320571e-10, 5.90943602e-10,\n",
+       "         5.92343941e-10, 5.93814488e-10, 5.95857228e-10, 5.97754466e-10,\n",
+       "         5.98347452e-10, 5.97288778e-10, 5.96172536e-10, 5.96983587e-10,\n",
+       "         5.99857760e-10, 6.03317323e-10, 6.05940879e-10, 6.07530544e-10,\n",
+       "         6.08777836e-10, 6.09848896e-10, 6.09376242e-10, 6.06023977e-10]),\n",
+       "  array([3.86053688e-11, 4.64988371e-11, 6.70808604e-11, 1.18056933e-10,\n",
+       "         2.06797442e-10])],\n",
+       " 0.6242218508975912)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.predict(model.theta, obslist, sps)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "f97f67bc",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:23:26.476298Z",
+     "start_time": "2025-06-13T13:23:26.042522Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 840x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot the predicted spectrum\n",
+    "plt.figure(figsize=(7,4), dpi=120)\n",
+    "plt.scatter(obslist[1].wavelength/(1+model.params['zred']), \n",
+    "            model.predict(model.theta, obslist, sps)[0][1], color='dodgerblue', alpha=0.6)\n",
+    "plt.plot(obslist[0].wavelength/(1+model.params['zred']), \n",
+    "         model.predict(model.theta, obslist, sps)[0][0], color='C1', alpha=0.6)\n",
+    "plt.yscale('log')\n",
+    "plt.xlabel(r'rest-frame wavelength [$\\mathrm{\\AA}$]')\n",
+    "plt.ylabel(r'F$_\\nu$ [L$_\\odot$/Hz]');"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "53f80878",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:23:26.495515Z",
+     "start_time": "2025-06-13T13:23:26.482082Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       ":::::::\n",
+       "<class 'prospect.models.sedmodel.SpecModel'>\n",
+       "\n",
+       "Free Parameters: (name: prior) \n",
+       "-----------\n",
+       "  logzsol: <class 'prospect.models.priors.TopHat'>(mini=-2,maxi=0.19)\n",
+       "  dust2: <class 'prospect.models.priors.TopHat'>(mini=0.0,maxi=2.0)\n",
+       "  logmass: <class 'prospect.models.priors.TopHat'>(mini=7,maxi=12)\n",
+       "  logsfr_ratios: <class 'prospect.models.priors.StudentT'>(mean=[0. 0.],scale=[0.3 0.3],df=[2 2])\n",
+       "  gas_logz: <class 'prospect.models.priors.TopHat'>(mini=-2.2,maxi=0.5)\n",
+       "  gas_logu: <class 'prospect.models.priors.TopHat'>(mini=-4.0,maxi=-1.0)\n",
+       "  gas_lognH: <class 'prospect.models.priors.TopHat'>(mini=1.0,maxi=4.0)\n",
+       "  gas_logno: <class 'prospect.models.priors.TopHat'>(mini=-1.0,maxi=0.7323937598229685)\n",
+       "  gas_logco: <class 'prospect.models.priors.TopHat'>(mini=-1.0,maxi=0.7323937598229685)\n",
+       "  ionspec_index1: <class 'prospect.models.priors.TopHat'>(mini=1.0,maxi=42.0)\n",
+       "  ionspec_index2: <class 'prospect.models.priors.TopHat'>(mini=-0.3,maxi=30.0)\n",
+       "  ionspec_index3: <class 'prospect.models.priors.TopHat'>(mini=-1.0,maxi=14.0)\n",
+       "  ionspec_index4: <class 'prospect.models.priors.TopHat'>(mini=-1.7,maxi=8.0)\n",
+       "  ionspec_logLratio1: <class 'prospect.models.priors.TopHat'>(mini=-1.0,maxi=10.1)\n",
+       "  ionspec_logLratio2: <class 'prospect.models.priors.TopHat'>(mini=-0.5,maxi=1.9)\n",
+       "  ionspec_logLratio3: <class 'prospect.models.priors.TopHat'>(mini=-0.4,maxi=2.2)\n",
+       "  gas_logqion: <class 'prospect.models.priors.TopHat'>(mini=35.0,maxi=65.0)\n",
+       "\n",
+       "Fixed Parameters: (name: value [, depends_on]) \n",
+       "-----------\n",
+       "  zred: [1.] \n",
+       "  mass: [1000000.] <function logsfr_ratios_to_masses at 0x14c8eaa16440>\n",
+       "  sfh: [3] \n",
+       "  imf_type: [2] \n",
+       "  dust_type: [0] \n",
+       "  agebins: [[ 0.  8.]\n",
+       " [ 8.  9.]\n",
+       " [ 9. 10.]] \n",
+       "  add_neb_emission: [ True] \n",
+       "  add_neb_continuum: [ True] \n",
+       "  nebemlineinspec: [False] \n",
+       "  use_eline_nn_unc: [False] \n",
+       "  use_stellar_ionizing: [False] "
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Build a model with flexible SFH, dust, and nebular emission\n",
+    "model_pars = TemplateLibrary[\"continuity_sfh\"]\n",
+    "model_pars[\"zred\"][\"init\"] = 1.0\n",
+    "model_pars.update(TemplateLibrary[\"cue_nebular\"])\n",
+    "model_pars[\"gas_logqion\"][\"init\"] = 54.0 # set a high number of ionizing photons so the emission lines are stronger\n",
+    "model_pars[\"nebemlineinspec\"][\"init\"] = False\n",
+    "model_pars['use_eline_nn_unc'][\"init\"] = False\n",
+    "model = SpecModel(model_pars)\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8c1b1a49",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:23:26.525653Z",
+     "start_time": "2025-06-13T13:23:26.499441Z"
+    },
+    "code_folding": [
+     0
+    ]
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "zred 1.0\n",
+      "mass 1000000.0\n",
+      "logzsol -0.5\n",
+      "dust2 0.6\n",
+      "sfh 3\n",
+      "imf_type 2\n",
+      "dust_type 0\n",
+      "logmass 10\n",
+      "agebins [[ 0.  8.]\n",
+      " [ 8.  9.]\n",
+      " [ 9. 10.]]\n",
+      "logsfr_ratios [0. 0.]\n",
+      "add_neb_emission True\n",
+      "add_neb_continuum True\n",
+      "nebemlineinspec False\n",
+      "use_eline_nn_unc False\n",
+      "use_stellar_ionizing False\n",
+      "gas_logz 0.0\n",
+      "gas_logu -2.0\n",
+      "gas_lognH 2.0\n",
+      "gas_logno 0.0\n",
+      "gas_logco 0.0\n",
+      "ionspec_index1 3.3\n",
+      "ionspec_index2 15.0\n",
+      "ionspec_index3 8.0\n",
+      "ionspec_index4 3.0\n",
+      "ionspec_logLratio1 2.0\n",
+      "ionspec_logLratio2 1.0\n",
+      "ionspec_logLratio3 1.0\n",
+      "gas_logqion 54.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Model parameters\n",
+    "for k in model.params:\n",
+    "    print(k, model.params[k].squeeze())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "5c5a80f8",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:23:26.579467Z",
+     "start_time": "2025-06-13T13:23:26.529763Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "([array([3.92276552e-11, 3.94952600e-11, 3.98244811e-11, 3.24312388e-11,\n",
+       "         4.35279956e-11, 3.93136769e-11, 4.12619944e-11, 4.27053006e-11,\n",
+       "         4.21535344e-11, 4.12933253e-11, 4.27457497e-11, 4.45245509e-11,\n",
+       "         4.39781132e-11, 4.35432257e-11, 4.54395411e-11, 4.48412502e-11,\n",
+       "         4.22846284e-11, 4.57469263e-11, 4.51452532e-11, 4.66193524e-11,\n",
+       "         4.52930274e-11, 4.67523400e-11, 4.81122574e-11, 4.74463599e-11,\n",
+       "         4.68590494e-11, 4.74209094e-11, 4.51465510e-11, 4.75766858e-11,\n",
+       "         4.85163164e-11, 4.56554481e-11, 4.78858821e-11, 4.79618418e-11,\n",
+       "         4.69455965e-11, 4.98890244e-11, 4.88720643e-11, 5.10361395e-11,\n",
+       "         4.99458720e-11, 4.88252080e-11, 4.96798883e-11, 5.07387883e-11,\n",
+       "         4.89740536e-11, 5.13829961e-11, 5.09230743e-11, 5.20769383e-11,\n",
+       "         5.14551616e-11, 5.13974146e-11, 5.34338001e-11, 5.19934563e-11,\n",
+       "         5.31713101e-11, 5.33359068e-11, 5.28454852e-11, 5.35858214e-11,\n",
+       "         5.45219925e-11, 5.30024792e-11, 5.38082629e-11, 5.40440943e-11,\n",
+       "         5.30734289e-11, 5.49534083e-11, 5.54676005e-11, 5.38716686e-11,\n",
+       "         5.46716991e-11, 5.48869061e-11, 5.35753251e-11, 5.42868760e-11,\n",
+       "         5.35769794e-11, 5.35575177e-11, 5.41893039e-11, 5.34015972e-11,\n",
+       "         5.56226641e-11, 5.49502399e-11, 5.63744469e-11, 5.69210363e-11,\n",
+       "         5.65575244e-11, 5.66011233e-11, 5.76088563e-11, 5.69866114e-11,\n",
+       "         5.57593836e-11, 5.59953176e-11, 5.85252185e-11, 5.94149875e-11,\n",
+       "         5.99213851e-11, 5.97342089e-11, 5.84292808e-11, 6.01644642e-11,\n",
+       "         6.15733816e-11, 6.49516185e-11, 6.42121628e-11, 6.48523626e-11,\n",
+       "         6.54968521e-11, 6.55316043e-11, 6.40913056e-11, 6.46461634e-11,\n",
+       "         6.29843569e-11, 6.40471577e-11, 6.61397493e-11, 6.63639995e-11,\n",
+       "         6.10035808e-11, 6.75327823e-11, 7.09366597e-11, 6.97700620e-11,\n",
+       "         6.77951821e-11, 7.17134352e-11, 7.14919771e-11, 7.34396587e-11,\n",
+       "         7.74069600e-11, 7.82355098e-11, 7.72392512e-11, 7.74005263e-11,\n",
+       "         7.89854873e-11, 7.90854543e-11, 7.82558830e-11, 8.04964013e-11,\n",
+       "         8.26470554e-11, 8.33627530e-11, 8.40776081e-11, 8.57339963e-11,\n",
+       "         8.54819643e-11, 8.77920604e-11, 8.55844929e-11, 9.03757844e-11,\n",
+       "         8.90339885e-11, 9.03777318e-11, 9.16960491e-11, 9.03161344e-11,\n",
+       "         9.55673201e-11, 9.29656541e-11, 9.76061985e-11, 9.58076368e-11,\n",
+       "         9.55700454e-11, 9.99663694e-11, 1.02817502e-10, 1.03716309e-10,\n",
+       "         1.04291887e-10, 1.09188371e-10, 1.06785610e-10, 1.07571777e-10,\n",
+       "         1.08261026e-10, 1.09519418e-10, 1.07964096e-10, 1.10725696e-10,\n",
+       "         1.11915584e-10, 1.14553900e-10, 1.14451094e-10, 1.17344554e-10,\n",
+       "         1.15325871e-10, 1.18698286e-10, 1.21084079e-10, 1.24451769e-10,\n",
+       "         1.24726291e-10, 1.25817822e-10, 1.24438397e-10, 1.31480339e-10,\n",
+       "         1.31118954e-10, 1.28724480e-10, 1.28184087e-10, 1.35071698e-10,\n",
+       "         1.35169662e-10, 1.37278765e-10, 1.38140663e-10, 1.08200811e-10,\n",
+       "         1.00112440e-10, 9.23907471e-11, 9.09815602e-11, 9.31546658e-11,\n",
+       "         9.71996167e-11, 1.78257317e-10, 1.06637650e-10, 1.13216844e-10,\n",
+       "         1.04004912e-10, 1.40855107e-10, 1.14863323e-10, 1.41332681e-10,\n",
+       "         1.30111223e-10, 1.19811835e-10, 1.41883709e-10, 1.48871803e-10,\n",
+       "         1.36031253e-10, 1.42533259e-10, 1.46735462e-10, 1.56357151e-10,\n",
+       "         1.30161119e-10, 1.51820357e-10, 1.42807202e-10, 1.19725448e-10,\n",
+       "         1.59737247e-10, 1.73411466e-10, 1.77652360e-10, 1.76211437e-10,\n",
+       "         1.79390767e-10, 1.79067629e-10, 1.76834111e-10, 1.75026666e-10,\n",
+       "         1.57154675e-10, 1.70189148e-10, 1.73823415e-10, 1.79082853e-10,\n",
+       "         1.81558097e-10, 1.84221208e-10, 1.77609098e-10, 1.83137183e-10,\n",
+       "         1.80983416e-10, 1.84934350e-10, 1.81310217e-10, 1.87247439e-10,\n",
+       "         1.86331198e-10, 1.84105761e-10, 1.84079524e-10, 1.72781379e-10,\n",
+       "         1.67889223e-10, 1.79328096e-10, 2.01512696e-10, 1.67215533e-10,\n",
+       "         1.92001105e-10, 1.90446270e-10, 1.89348031e-10, 1.92811072e-10,\n",
+       "         1.99635534e-10, 2.02949444e-10, 2.03460048e-10, 1.98168513e-10,\n",
+       "         2.10163293e-10, 2.08105207e-10, 2.14846112e-10, 2.19169242e-10,\n",
+       "         2.08058515e-10, 2.11108285e-10, 2.11337621e-10, 2.17786454e-10,\n",
+       "         2.14506546e-10, 2.14889515e-10, 2.19720417e-10, 2.22410988e-10,\n",
+       "         2.23886893e-10, 2.23709494e-10, 2.24391996e-10, 2.25565182e-10,\n",
+       "         2.28783131e-10, 2.26936631e-10, 2.28703132e-10, 2.29051573e-10,\n",
+       "         2.31376102e-10, 2.32987552e-10, 2.32517690e-10, 2.34156936e-10,\n",
+       "         2.34656354e-10, 2.35673814e-10, 2.34422179e-10, 2.28671558e-10,\n",
+       "         2.13493655e-10, 3.71198315e-10, 2.20202420e-10, 2.29317759e-10,\n",
+       "         2.37599637e-10, 2.34329664e-10, 2.39867598e-10, 2.42889688e-10,\n",
+       "         2.76068247e-10, 2.43312666e-10, 2.36605108e-10, 2.38539905e-10,\n",
+       "         3.11087931e-10, 2.40816764e-10, 2.38346744e-10, 2.46967064e-10,\n",
+       "         2.46372468e-10, 2.41213165e-10, 2.43528881e-10, 2.44226244e-10,\n",
+       "         2.46604853e-10, 2.43196014e-10, 2.41194553e-10, 2.39854745e-10,\n",
+       "         2.32768720e-10, 2.40939554e-10, 2.43922415e-10, 2.49417582e-10,\n",
+       "         2.48365543e-10, 2.58848202e-10, 2.55992271e-10, 2.44288224e-10,\n",
+       "         2.61028043e-10, 2.63662150e-10, 2.68308823e-10, 2.58801784e-10,\n",
+       "         2.63454444e-10, 2.69589424e-10, 2.70252186e-10, 2.70626272e-10,\n",
+       "         2.67349721e-10, 2.62365638e-10, 2.72231143e-10, 2.68623507e-10,\n",
+       "         2.74556624e-10, 2.74867734e-10, 2.73111156e-10, 2.73283864e-10,\n",
+       "         2.76806828e-10, 2.75963826e-10, 2.78234486e-10, 2.86498174e-10,\n",
+       "         2.85395616e-10, 2.80349733e-10, 2.82136852e-10, 2.76155618e-10,\n",
+       "         2.85943284e-10, 2.85090625e-10, 2.89539406e-10, 2.87513818e-10,\n",
+       "         2.84255436e-10, 2.92211477e-10, 2.90655914e-10, 2.88460393e-10,\n",
+       "         2.90635154e-10, 2.98766090e-10, 2.99363913e-10, 2.98405745e-10,\n",
+       "         3.01191102e-10, 2.95442736e-10, 3.01596865e-10, 3.03254873e-10,\n",
+       "         3.07592844e-10, 3.06851976e-10, 3.03148146e-10, 3.03471198e-10,\n",
+       "         3.14566956e-10, 2.91204380e-10, 3.02827874e-10, 3.05465120e-10,\n",
+       "         3.09030625e-10, 3.09468125e-10, 3.10767102e-10, 3.13429754e-10,\n",
+       "         3.10444725e-10, 3.12190133e-10, 3.10789364e-10, 3.13517191e-10,\n",
+       "         3.19931831e-10, 3.19379157e-10, 3.18666115e-10, 3.19715332e-10,\n",
+       "         3.18637600e-10, 3.18154366e-10, 3.19107603e-10, 3.15024855e-10,\n",
+       "         3.17790791e-10, 3.13310957e-10, 3.17060583e-10, 3.20321238e-10,\n",
+       "         3.22863907e-10, 3.17991688e-10, 3.17599286e-10, 3.16272918e-10,\n",
+       "         3.14729443e-10, 3.22814407e-10, 3.26798315e-10, 3.27098415e-10,\n",
+       "         3.45647063e-10, 3.27934638e-10, 3.29777671e-10, 3.31732233e-10,\n",
+       "         3.31517973e-10, 3.35952185e-10, 3.35906467e-10, 3.34106102e-10,\n",
+       "         3.34239129e-10, 3.36747501e-10, 3.38273582e-10, 3.34618116e-10,\n",
+       "         3.39724978e-10, 3.39585425e-10, 3.33286031e-10, 3.43721172e-10,\n",
+       "         3.44802070e-10, 3.42080395e-10, 1.15771315e-09, 9.15026423e-09,\n",
+       "         2.75081426e-09, 3.44700964e-10, 3.46784998e-10, 3.51323364e-10,\n",
+       "         3.49131655e-10, 3.51667728e-10, 3.50775837e-10, 3.68418635e-10,\n",
+       "         3.53732481e-10, 3.52760355e-10, 8.91111047e-10, 9.82029966e-10,\n",
+       "         3.53923513e-10, 3.55106428e-10, 3.54911519e-10, 3.58438938e-10,\n",
+       "         3.57960934e-10, 3.57988197e-10, 3.61576160e-10, 3.60467462e-10,\n",
+       "         3.60375410e-10, 3.63183490e-10, 3.65011846e-10, 3.67785568e-10,\n",
+       "         3.68863832e-10, 3.67766730e-10, 3.68450986e-10, 3.68563518e-10,\n",
+       "         3.70138858e-10, 3.70460635e-10, 3.71004696e-10, 3.71262484e-10,\n",
+       "         3.70592633e-10, 3.71330704e-10, 3.75388136e-10, 3.74811258e-10,\n",
+       "         3.75129847e-10, 3.72347434e-10, 3.70105857e-10, 3.69963040e-10,\n",
+       "         3.68835222e-10, 4.22733240e-10, 3.69400043e-10, 3.71290230e-10,\n",
+       "         3.73295167e-10, 3.70409808e-10, 3.73384593e-10, 3.75710367e-10,\n",
+       "         3.80916798e-10, 3.83228215e-10, 3.83284568e-10, 3.85870044e-10,\n",
+       "         3.84275711e-10, 3.84097881e-10, 3.88109895e-10, 3.94519242e-10,\n",
+       "         3.95446334e-10, 3.93311363e-10, 3.93619089e-10, 3.97084542e-10,\n",
+       "         3.93768170e-10, 3.94440936e-10, 3.92309811e-10, 3.99037087e-10,\n",
+       "         4.00392409e-10, 4.02104096e-10, 4.03824388e-10, 4.04768873e-10,\n",
+       "         4.03366386e-10, 4.04843212e-10, 4.07945250e-10, 4.12072897e-10,\n",
+       "         4.12303169e-10, 4.12009489e-10, 4.10574860e-10, 4.11222536e-10,\n",
+       "         4.11075124e-10, 4.08866271e-10, 4.13025935e-10, 4.11255270e-10,\n",
+       "         4.02979453e-10, 4.08580115e-10, 4.11969933e-10, 4.10176308e-10,\n",
+       "         4.07586080e-10, 4.12963915e-10, 4.13913952e-10, 4.16511256e-10,\n",
+       "         4.17661808e-10, 4.16675871e-10, 4.18464837e-10, 4.21382877e-10,\n",
+       "         4.22098562e-10, 4.20012493e-10, 4.21883097e-10, 4.24113652e-10,\n",
+       "         4.22823337e-10, 4.21093367e-10, 4.19541829e-10, 4.18043806e-10,\n",
+       "         4.18155489e-10, 4.16316424e-10, 4.22638223e-10, 4.26527264e-10,\n",
+       "         4.27047932e-10, 4.26954536e-10, 4.30248191e-10, 4.30118686e-10,\n",
+       "         4.30745905e-10, 4.31239111e-10, 4.31936023e-10, 4.29843455e-10,\n",
+       "         4.29982875e-10, 4.32606399e-10, 4.34655008e-10, 4.37257582e-10,\n",
+       "         4.38446843e-10, 4.39287945e-10, 4.37204713e-10, 4.29279388e-10,\n",
+       "         4.21208801e-10, 4.18222916e-10, 4.18368078e-10, 4.18209871e-10,\n",
+       "         4.19231794e-10, 4.20802665e-10, 4.20319338e-10, 4.17980446e-10,\n",
+       "         4.16748158e-10, 4.15429305e-10, 4.13727727e-10, 4.17398252e-10,\n",
+       "         4.18139184e-10, 4.16968838e-10, 4.16813334e-10, 4.21920187e-10,\n",
+       "         4.21154119e-10, 4.16245245e-10, 4.16663007e-10, 4.20576057e-10,\n",
+       "         4.19454747e-10, 4.19536913e-10, 4.04407080e-10, 4.13785543e-10,\n",
+       "         4.15801076e-10, 3.84074678e-10, 3.99214842e-10, 4.28911251e-10,\n",
+       "         4.56014000e-10, 4.27338572e-10, 4.27666847e-10, 4.35021021e-10,\n",
+       "         4.39891017e-10, 4.29191844e-10, 3.96072961e-10, 4.10677508e-10,\n",
+       "         4.31808696e-10, 4.40926518e-10, 4.44360662e-10, 4.44113801e-10,\n",
+       "         4.35301907e-10, 4.30993711e-10, 4.42025694e-10, 4.49689071e-10,\n",
+       "         4.48570705e-10, 4.46819419e-10, 4.50980779e-10, 4.51403037e-10,\n",
+       "         4.45606290e-10, 4.33727742e-10, 4.41140296e-10, 4.51733957e-10,\n",
+       "         4.55580855e-10, 4.55517857e-10, 4.55418531e-10, 4.56426173e-10,\n",
+       "         4.58864991e-10, 4.57925311e-10, 4.56466060e-10, 4.48823324e-10,\n",
+       "         4.46536662e-10, 4.43176956e-10, 4.58929799e-10, 4.64039472e-10,\n",
+       "         1.43477666e-09, 4.71808817e-10, 4.58160368e-10, 4.62499156e-10,\n",
+       "         4.68647390e-10, 4.65319649e-10, 4.62267229e-10, 4.59541713e-10,\n",
+       "         4.57240347e-10, 4.55438840e-10, 4.50997605e-10, 4.43844255e-10,\n",
+       "         4.85091285e-10, 4.44198618e-10, 4.51732823e-10, 4.58015661e-10,\n",
+       "         4.61818251e-10, 4.63402173e-10, 4.65065933e-10, 4.66448542e-10,\n",
+       "         4.66764762e-10, 4.64889114e-10, 4.62753241e-10, 4.62685961e-10,\n",
+       "         4.62699497e-10, 4.60973454e-10, 4.60627477e-10, 4.62190616e-10,\n",
+       "         4.63681037e-10, 4.66076147e-10, 4.68479693e-10, 4.69723396e-10,\n",
+       "         4.70217684e-10, 4.69638577e-10, 9.38150171e-10, 7.39148557e-10,\n",
+       "         4.84638553e-10, 4.64875870e-10, 4.71114351e-10, 4.74291307e-10,\n",
+       "         4.75123818e-10, 4.74901123e-10, 4.73786442e-10, 4.73045108e-10,\n",
+       "         4.73295976e-10, 4.74411571e-10, 4.75681602e-10, 4.76867603e-10,\n",
+       "         4.77433144e-10, 4.76863292e-10, 4.76563128e-10, 4.77723177e-10,\n",
+       "         4.78495019e-10, 4.78788644e-10, 4.81152704e-10, 4.84683957e-10,\n",
+       "         4.86690144e-10, 4.87495277e-10, 4.91616743e-10, 4.88598883e-10,\n",
+       "         4.88854640e-10, 4.88519871e-10, 4.88343042e-10, 4.88650528e-10,\n",
+       "         4.89499673e-10, 4.90891088e-10, 4.92358367e-10, 4.93058123e-10,\n",
+       "         4.92870201e-10, 4.92412059e-10, 4.91583155e-10, 4.88131984e-10,\n",
+       "         4.82507954e-10, 9.48335951e-10, 4.82880355e-10, 4.90483952e-10,\n",
+       "         4.95849489e-10, 4.98579972e-10, 4.99064475e-10, 4.98685861e-10,\n",
+       "         4.98211084e-10, 4.99158874e-10, 5.00762772e-10, 5.01544482e-10,\n",
+       "         5.01647162e-10, 5.02077137e-10, 5.03549352e-10, 5.05329679e-10,\n",
+       "         5.05844454e-10, 5.05802751e-10, 5.06131422e-10, 5.06539848e-10,\n",
+       "         5.06486483e-10, 5.27668185e-10, 5.02782826e-10, 5.03558564e-10,\n",
+       "         5.05475312e-10, 5.05927601e-10, 5.06089201e-10, 5.07429969e-10,\n",
+       "         5.09211306e-10, 5.10353537e-10, 5.10911317e-10, 5.10455866e-10,\n",
+       "         5.10424912e-10, 5.11079398e-10, 5.11598773e-10, 5.12281624e-10,\n",
+       "         5.12967620e-10, 5.13720703e-10, 5.14324982e-10, 5.13324812e-10,\n",
+       "         5.10903923e-10, 5.09776614e-10, 5.11376126e-10, 5.14272560e-10,\n",
+       "         5.16469059e-10, 5.15746086e-10, 5.13202545e-10, 5.11299361e-10,\n",
+       "         5.10869160e-10, 5.12528870e-10, 5.13733334e-10, 5.13497909e-10,\n",
+       "         5.14154899e-10, 5.16206643e-10, 5.17232941e-10, 5.16787457e-10,\n",
+       "         5.16844173e-10, 5.16715069e-10, 5.42116141e-10, 8.13120414e-10,\n",
+       "         5.17923654e-10, 5.15423202e-10, 5.12886177e-10, 5.13041052e-10,\n",
+       "         5.12979744e-10, 5.07429814e-10, 5.02228195e-10, 5.13711015e-10,\n",
+       "         4.95422193e-10, 4.95839583e-10, 4.97441801e-10, 4.99510234e-10,\n",
+       "         5.01098065e-10, 5.03162149e-10, 5.05921323e-10, 5.08102531e-10,\n",
+       "         5.09487939e-10, 5.10541740e-10, 5.11229769e-10, 5.11297955e-10,\n",
+       "         5.11262659e-10, 5.11985205e-10, 5.13228363e-10, 5.14319026e-10,\n",
+       "         5.14954686e-10, 5.15303216e-10, 5.16510509e-10, 5.18380183e-10,\n",
+       "         5.18888069e-10, 5.17795591e-10, 5.17292707e-10, 5.18762705e-10,\n",
+       "         5.19739590e-10, 5.19435171e-10, 5.19526610e-10, 5.19997669e-10,\n",
+       "         5.20447464e-10, 5.21060385e-10, 5.21139899e-10, 5.20248035e-10,\n",
+       "         5.19709581e-10, 5.20524214e-10, 5.22217972e-10, 5.24170990e-10,\n",
+       "         5.26504043e-10, 5.28575760e-10, 5.29317567e-10, 5.29295036e-10,\n",
+       "         5.29998324e-10, 5.31376184e-10, 5.32832303e-10, 5.34337015e-10,\n",
+       "         5.35366583e-10, 5.34993904e-10, 5.32411193e-10, 5.28698377e-10,\n",
+       "         5.26997701e-10, 5.28418014e-10, 5.30836537e-10, 5.33098804e-10,\n",
+       "         5.34972736e-10, 5.35391216e-10, 5.35422885e-10, 5.37112977e-10,\n",
+       "         5.39817524e-10, 5.41320323e-10, 5.41007703e-10, 5.39405665e-10,\n",
+       "         5.37765605e-10, 5.37664823e-10, 5.39232566e-10, 5.39746898e-10,\n",
+       "         5.38216298e-10, 5.38427865e-10, 5.41404584e-10, 5.42036704e-10,\n",
+       "         5.39463661e-10, 5.38678197e-10, 5.42260003e-10, 5.46531640e-10,\n",
+       "         5.48137557e-10, 5.46822347e-10, 5.43525772e-10, 5.39723569e-10,\n",
+       "         5.38774138e-10, 5.41879316e-10, 5.45387037e-10, 5.46400193e-10,\n",
+       "         5.47002416e-10, 5.48940747e-10, 5.49802412e-10, 5.48954521e-10,\n",
+       "         5.48290051e-10, 5.49236767e-10, 5.51634860e-10, 5.54317492e-10,\n",
+       "         5.56206880e-10, 5.56920247e-10, 5.56780155e-10, 5.56609499e-10,\n",
+       "         5.56930869e-10, 5.57547078e-10, 5.58180806e-10, 5.58605864e-10,\n",
+       "         5.58372435e-10, 5.57886138e-10, 5.58460223e-10, 5.59970833e-10,\n",
+       "         5.61020542e-10, 5.61247944e-10, 5.61183035e-10, 5.61520752e-10,\n",
+       "         5.62243663e-10, 5.62597169e-10, 5.62340528e-10, 5.61958059e-10,\n",
+       "         5.61582395e-10, 5.61809785e-10, 5.63484250e-10, 5.65487868e-10,\n",
+       "         5.66669990e-10, 5.67031363e-10, 5.66625527e-10, 5.65696886e-10,\n",
+       "         5.65327923e-10, 5.65952664e-10, 5.66738862e-10, 5.96539614e-10,\n",
+       "         5.69693194e-10, 5.68999997e-10, 5.69397777e-10, 5.69506888e-10,\n",
+       "         5.69498280e-10, 5.69805726e-10, 5.70472379e-10, 5.71236899e-10,\n",
+       "         5.72346029e-10, 5.73671780e-10, 5.74474990e-10, 5.74609896e-10,\n",
+       "         5.74767574e-10, 5.75297793e-10, 5.75251875e-10, 5.73073403e-10,\n",
+       "         5.67751327e-10, 6.39867374e-10, 2.23480801e-09, 5.63605907e-10,\n",
+       "         5.68965627e-10, 5.73745583e-10, 5.74816957e-10, 5.73793142e-10,\n",
+       "         5.73322389e-10, 5.74584276e-10, 5.76775423e-10, 5.78998846e-10,\n",
+       "         5.80538715e-10, 5.81068554e-10, 5.81348371e-10, 5.81816300e-10,\n",
+       "         5.82195932e-10, 5.82594241e-10, 5.83387802e-10, 5.84497674e-10,\n",
+       "         5.85294911e-10, 5.85312923e-10, 5.84563205e-10, 5.83100937e-10,\n",
+       "         5.81457952e-10, 5.80710429e-10, 5.81380258e-10, 5.83478559e-10,\n",
+       "         5.86101693e-10, 5.88003157e-10, 5.89026355e-10, 5.89825155e-10,\n",
+       "         5.90666226e-10, 5.90826028e-10, 5.89434382e-10, 5.86378789e-10,\n",
+       "         5.82758030e-10, 5.80547624e-10, 5.80369251e-10, 5.81235785e-10,\n",
+       "         5.82104004e-10, 5.82064326e-10, 5.81121523e-10, 5.80166186e-10,\n",
+       "         5.79886281e-10, 5.80262233e-10, 5.80908271e-10, 5.81821708e-10,\n",
+       "         5.82929926e-10, 5.83638700e-10, 5.83566019e-10, 5.82969825e-10,\n",
+       "         5.82698215e-10, 5.83342285e-10, 5.84170527e-10, 5.84119057e-10,\n",
+       "         5.83375848e-10, 5.82832207e-10, 5.82746479e-10, 5.82876150e-10,\n",
+       "         5.83049088e-10, 5.83126090e-10, 5.83325279e-10, 5.84049096e-10,\n",
+       "         5.84923717e-10, 5.85352186e-10, 5.85639304e-10, 5.86420757e-10,\n",
+       "         5.87717330e-10, 5.89136967e-10, 5.90354180e-10, 5.91229913e-10,\n",
+       "         5.91883637e-10, 5.92563837e-10, 5.93254882e-10, 5.93526321e-10,\n",
+       "         5.93017855e-10, 5.91965446e-10, 5.91114554e-10, 5.91149650e-10,\n",
+       "         5.91637584e-10, 5.91166144e-10, 5.89670321e-10, 5.89148349e-10,\n",
+       "         5.90391374e-10, 5.92037598e-10, 5.92957013e-10, 5.92943582e-10,\n",
+       "         5.92262026e-10, 5.91966852e-10, 5.93043379e-10, 5.94763953e-10,\n",
+       "         5.95527072e-10, 5.94761450e-10, 5.93349028e-10, 5.92407527e-10,\n",
+       "         5.91853173e-10, 5.90846110e-10, 5.89539386e-10, 5.89164574e-10,\n",
+       "         5.90140617e-10, 5.91355279e-10, 5.91761182e-10, 5.91493687e-10,\n",
+       "         5.91060039e-10, 5.90464568e-10, 5.89829516e-10, 5.89951111e-10,\n",
+       "         5.91237532e-10, 5.92731875e-10, 5.93704855e-10, 5.94690706e-10,\n",
+       "         5.96190469e-10, 5.97834263e-10, 5.99187849e-10, 6.00272621e-10,\n",
+       "         6.01072912e-10, 6.01102705e-10, 6.00158862e-10, 5.99111458e-10,\n",
+       "         5.99005770e-10, 5.99769668e-10, 6.01274579e-10, 6.03969123e-10,\n",
+       "         6.06724990e-10, 6.07777125e-10, 6.07214604e-10, 6.05956132e-10,\n",
+       "         6.04384833e-10, 6.02525297e-10, 6.01303206e-10, 6.01127560e-10,\n",
+       "         6.00191496e-10, 5.96476974e-10, 5.91194375e-10, 5.88104763e-10,\n",
+       "         5.88473102e-10, 5.89775876e-10, 5.90517750e-10, 5.90788818e-10,\n",
+       "         5.91017818e-10, 5.92380341e-10, 5.94946779e-10, 5.97239577e-10,\n",
+       "         5.98393666e-10, 5.99124320e-10, 6.00380080e-10, 6.02016735e-10,\n",
+       "         6.03430709e-10, 6.04914893e-10, 6.06971264e-10, 6.08882123e-10,\n",
+       "         6.09488730e-10, 6.08443681e-10, 6.07341071e-10, 6.08165757e-10,\n",
+       "         6.11053568e-10, 6.14526760e-10, 6.17163933e-10, 6.18767201e-10,\n",
+       "         6.20028092e-10, 6.21112750e-10, 6.20653701e-10, 6.17315046e-10]),\n",
+       "  array([4.58456835e-11, 5.54156286e-11, 8.76676321e-11, 1.71227199e-10,\n",
+       "         2.28355852e-10])],\n",
+       " 0.6242218508975912)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.predict(model.theta, obslist, sps)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "11eaf731",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-13T13:23:26.863387Z",
+     "start_time": "2025-06-13T13:23:26.583159Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 840x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot the predicted spectrum\n",
+    "plt.figure(figsize=(7,4), dpi=120)\n",
+    "plt.scatter(obslist[1].wavelength/(1+model.params['zred']), \n",
+    "            model.predict(model.theta, obslist, sps)[0][1], color='dodgerblue', alpha=0.6)\n",
+    "plt.plot(obslist[0].wavelength/(1+model.params['zred']), \n",
+    "         model.predict(model.theta, obslist, sps)[0][0], color='C1', alpha=0.6)\n",
+    "plt.yscale('log')\n",
+    "plt.xlabel(r'rest-frame wavelength [$\\mathrm{\\AA}$]')\n",
+    "plt.ylabel(r'F$_\\nu$ [L$_\\odot$/Hz]');"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fad8e1f5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3.9-tensorflow",
+   "language": "python",
+   "name": "tensorflow"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/prospect/sources/nebssp_basis.py b/prospect/sources/nebssp_basis.py
index 431b27ba..650d69ae 100644
--- a/prospect/sources/nebssp_basis.py
+++ b/prospect/sources/nebssp_basis.py
@@ -435,8 +435,8 @@ def get_spectrum(ssp, params, emul, ewave, tage=0):
     :param use_stellar_ionizing:
         If true, fit CSPs and to get the ionizing spectrum parameters, else read from ssp
     """
-    add_neb = params["add_neb_emission"]
-    use_stars = params["use_stellar_ionizing"]
+    add_neb = params.get("add_neb_emission", False)
+    use_stars =  params.get("use_stellar_ionizing", False)
     #params = {k: v.item() if isinstance(v, np.ndarray) else v for k, v in params.items()}
     wave, tspec = ssp.get_spectrum(tage=tage, peraa=False)
     young, old = ssp._csp_young_old