redback 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

redback/transient_models/magnetar_driven_ejecta_models.py

@@ -58,8 +58,8 @@ def _ejecta_dynamics_and_interaction(time, mej, beta, ejecta_radius, kappa, n_is
     
     ni56_lum = 6.45e43
     co56_lum = 1.45e43
-    ni56_life = 8.8  # days
-    co56_life = 111.3  # days    
+    ni56_life = 8.8*86400  # days
+    co56_life = 111.3*86400  # days    
 
     for i in range(len(time)):
         beta = np.sqrt(1 - 1 / gamma ** 2)

redback/transient_models/magnetar_models.py

@@ -4,7 +4,7 @@ from astropy.cosmology import Planck18 as cosmo  # noqa
 import scipy.special as ss
 from collections import namedtuple
 from scipy.interpolate import interp1d
-from scipy.integrate import quad, cumtrapz
+from scipy.integrate import quad, cumulative_trapezoid as cumtrapz
 from inspect import isfunction
 from redback.utils import logger, citation_wrapper
 

redback/transient_models/phenomenological_models.py

@@ -1,6 +1,74 @@
 import numpy as np
+from redback.utils import citation_wrapper
 
-def gaussian_rise(time, a_1, peak_time, sigma_t):
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2009A%26A...499..653B/abstract')
+def bazin_sne(time, aa, bb, t0, tau_rise, tau_fall, **kwargs):
+    """
+    Bazin function for CCSN light curves
+
+    :param time: time array in arbitrary units
+    :param aa: Normalisation on the Bazin function
+    :param bb: Additive constant
+    :param t0: start time
+    :param tau_rise: exponential rise time
+    :param tau_fall: exponential fall time
+    :return: flux in units set by AA
+    """
+    flux = aa * np.exp(-((time - t0) / tau_fall) / (1 + np.exp(-(time - t0) / tau_rise))) + bb
+    return flux
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2019ApJ...884...83V/abstract, https://ui.adsabs.harvard.edu/abs/1982ApJ...253..785A/abstract')
+def villar_sne(time, aa, cc, t0, tau_rise, tau_fall, gamma, nu, **kwargs):
+    """
+    Villar function for SN light curves
+
+    :param time: time array in arbitrary units
+    :param aa: normalisation on the Villar function, amplotude
+    :param cc: additive constant, baseline flux
+    :param t0: start time
+    :param tau_rise: exponential rise time
+    :param tau_fall: exponential fall time
+    :param gamma: plateau duration
+    :param nu: related to beta and between 0 an 1; nu = -beta/gamma / A
+    :param kwargs:
+    :return: flux in units set by AA
+    """
+    mask1 = time < t0 + gamma
+    mask2 = (time >= t0 + gamma)
+    flux = np.zeros_like(time)
+    norm = cc + (aa / (1 + np.exp(-(time - t0)/tau_rise)))
+    flux[mask1] = norm[mask1] * (1 - (nu * ((time[mask1] - t0)/gamma)))
+    flux[mask2] = norm[mask2] * ((1 - nu) * np.exp(-((time[mask2] - t0 - gamma)/tau_fall)))
+    return np.concatenate((flux[mask1], flux[mask2]))
+
+def fallback_lbol(time, logl1, tr, **kwargs):
+    """
+    :param time: time in seconds
+    :param logl1: luminosity scale in log 10 ergs
+    :param tr: transition time for flat luminosity to power-law decay
+    :return: lbol
+    """
+    l1 = 10**logl1
+    time = time * 86400
+    tr = tr * 86400
+    lbol = l1 * time**(-5./3.)
+    lbol[time < tr] = l1 * tr**(-5./3.)
+    return lbol
+
+def line_spectrum(wavelength, line_amp, cont_amp, x0, **kwargs):
+    """
+    A gaussian to add or subtract from a continuum spectrum to mimic absorption or emission lines
+
+    :param wavelength: wavelength array in whatever units
+    :param line_amp: line amplitude scale
+    :param cont_amp: Continuum amplitude scale
+    :param x0: Position of emission line
+    :return: spectrum in whatever units set by line_amp
+    """
+    spectrum = line_amp / cont_amp * np.exp(-(wavelength - x0) ** 2. / (2 * cont_amp ** 2) )
+    return spectrum
+
+def gaussian_rise(time, a_1, peak_time, sigma_t, **kwargs):
     """
     :param time: time array in whatver time units
     :param a_1: gaussian rise amplitude scale

redback/transient_models/shock_powered_models.py

@@ -1,11 +1,157 @@
 import numpy as np
 from collections import namedtuple
 from scipy import special
+from scipy.interpolate import interp1d
 from redback.constants import *
 import redback.sed as sed
 from astropy.cosmology import Planck18 as cosmo  # noqa
 from redback.utils import calc_kcorrected_properties, citation_wrapper, lambda_to_nu
 
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022ApJ...933..238M/abstract')
+def _csm_shock_breakout(time, csm_mass, v_min, beta, kappa, shell_radius, shell_width_ratio, **kwargs):
+    """
+    Dense CSM shock breakout and cooling model From Margalit 2022
+
+    :param time: time in days
+    :param csm_mass: mass of CSM shell in g
+    :param v_min: minimum velocity in km/s
+    :param beta: velocity ratio in c (beta < 1)
+    :param kappa: opacity in cm^2/g
+    :param shell_radius: radius of shell in 10^14 cm
+    :param shell_width_ratio: shell width ratio (deltaR/R0)
+    :return: namedtuple with lbol, r_photosphere, and temperature
+    """
+    v0 = v_min * 1e5
+    e0 = 0.5 * csm_mass * v0**2
+    shell_radius *= 1e14
+    shell_width = shell_width_ratio * shell_radius
+    tdyn = shell_radius / v0
+    tshell = shell_width / v0
+    time = time * day_to_s
+
+    velocity = v0/beta
+
+    tda = (3 * kappa * csm_mass / (4 * np.pi * speed_of_light * velocity)) ** 0.5
+
+    term1 = ((tdyn + tshell + time) ** 3 - (tdyn + beta * time) ** 3) ** (2 / 3)
+    term2 = ((tdyn + tshell) ** 3 - tdyn ** 3) ** (1 / 3)
+    term3 = (1 + (1 - beta) * time / tshell) ** (
+                -3 * (tdyn / tda) ** 2 * ((1 - beta - beta * tshell / tdyn) ** 2) / (1 - beta) ** 3)
+    term4 = np.exp(-time * ((1 - beta ** 3) * time + (2 - 4 * beta * (beta + 1)) * tshell + 6 * (1 - beta ** 2) * tdyn) / (
+                2 * (1 - beta) ** 2 * tda ** 2))
+
+    lbol = e0 * term1 / (tda ** 2 * (tshell + (1 - beta) * time) ** 2) * term2 * term3 * term4
+
+    volume = 4./3. * np.pi * velocity**3 * ((tdyn + tshell + time)**3 - (tdyn + beta*time)**3)
+    radius = velocity * (tdyn + tshell + time)
+    rphotosphere = radius - 2*volume/(3 * kappa * csm_mass)
+    teff = (lbol / (4 * np.pi * rphotosphere ** 2 * sigma_sb)) ** 0.25
+    output = namedtuple('output', ['lbol', 'r_photosphere', 'temperature', 'time_temp',
+                                   'tdyn', 'tshell', 'e0', 'tda', 'velocity'])
+    output.lbol = lbol
+    output.r_photosphere = rphotosphere
+    output.temperature = teff
+    output.tdyn = tdyn
+    output.tshell = tshell
+    output.e0 = e0
+    output.tda = tda
+    output.velocity = velocity
+    output.time_temp = time
+    return output
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022ApJ...933..238M/abstract')
+def csm_shock_breakout_bolometric(time, csm_mass, v_min, beta, kappa, shell_radius, shell_width_ratio, **kwargs):
+    """
+    Dense CSM shock breakout and cooling model From Margalit 2022
+
+    :param time: time in days in source frame
+    :param csm_mass: mass of CSM shell in solar masses
+    :param v_min: minimum velocity in km/s
+    :param beta: velocity ratio in c (beta < 1)
+    :param kappa: opacity in cm^2/g
+    :param shell_radius: radius of shell in 10^14 cm
+    :param shell_width_ratio: shell width ratio (deltaR/R0)
+    :param kwargs: Additional parameters required by model
+    :param cosmology: Cosmology to use for luminosity distance calculation. Defaults to Planck18. Must be a astropy.cosmology object.
+    :return: bolometric luminosity
+    """
+    csm_mass = csm_mass * solar_mass
+    time_temp = np.geomspace(1e-2, 200, 300)  # days
+    outputs = _csm_shock_breakout(time_temp, v_min=v_min, beta=beta,
+                                  kappa=kappa, csm_mass=csm_mass, shell_radius=shell_radius,
+                                  shell_width_ratio=shell_width_ratio, **kwargs)
+    func = interp1d(time_temp, outputs.lbol, fill_value='extrapolate')
+    return func(time)
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022ApJ...933..238M/abstract')
+def csm_shock_breakout(time, redshift, csm_mass, v_min, beta, kappa, shell_radius, shell_width_ratio, **kwargs):
+    """
+    Dense CSM shock breakout and cooling model From Margalit 2022
+
+    :param time: time in days in observer frame
+    :param redshift: redshift
+    :param csm_mass: mass of CSM shell in solar masses
+    :param v_min: minimum velocity in km/s
+    :param beta: velocity ratio in c (beta < 1)
+    :param kappa: opacity in cm^2/g
+    :param shell_radius: radius of shell in 10^14 cm
+    :param shell_width_ratio: shell width ratio (deltaR/R0)
+    :param kwargs: Additional parameters required by model
+    :param frequency: Required if output_format is 'flux_density'.
+        frequency to calculate - Must be same length as time array or a single number).
+    :param bands: Required if output_format is 'magnitude' or 'flux'.
+    :param output_format: 'flux_density', 'magnitude', 'spectra', 'flux', 'sncosmo_source'
+    :param lambda_array: Optional argument to set your desired wavelength array (in Angstroms) to evaluate the SED on.
+    :param cosmology: Cosmology to use for luminosity distance calculation. Defaults to Planck18. Must be a astropy.cosmology object.
+    :return: set by output format - 'flux_density', 'magnitude', 'spectra', 'flux', 'sncosmo_source'
+    :return:
+    """
+    csm_mass = csm_mass * solar_mass
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+    time_temp = np.geomspace(1e-2, 40, 300) #days
+    time_obs = time
+    outputs = _csm_shock_breakout(time_temp, v_min=v_min, beta=beta,
+                                  kappa=kappa, csm_mass=csm_mass, shell_radius=shell_radius,
+                                  shell_width_ratio=shell_width_ratio, **kwargs)
+    if kwargs['output_format'] == 'namedtuple':
+        return outputs
+    elif kwargs['output_format'] == 'flux_density':
+        time = time_obs
+        frequency = kwargs['frequency']
+        # interpolate properties onto observation times
+        temp_func = interp1d(time_temp, y=outputs.temperature)
+        rad_func = interp1d(time_temp, y=outputs.r_photosphere)
+        # convert to source frame time and frequency
+        frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)
+
+        temp = temp_func(time)
+        photosphere = rad_func(time)
+
+        flux_density = sed.blackbody_to_flux_density(temperature=temp, r_photosphere=photosphere,
+                                                 dl=dl, frequency=frequency)
+
+        return flux_density.to(uu.mJy).value
+    else:
+        lambda_observer_frame = kwargs.get('lambda_array', np.geomspace(100, 60000, 200))
+        time_observer_frame = time_temp * (1. + redshift)
+        frequency, time = calc_kcorrected_properties(frequency=lambda_to_nu(lambda_observer_frame),
+                                                     redshift=redshift, time=time_observer_frame)
+        fmjy = sed.blackbody_to_flux_density(temperature=outputs.temperature,
+                                         r_photosphere=outputs.r_photosphere, frequency=frequency[:, None], dl=dl)
+        fmjy = fmjy.T
+        spectra = fmjy.to(uu.mJy).to(uu.erg / uu.cm ** 2 / uu.s / uu.Angstrom,
+                                     equivalencies=uu.spectral_density(wav=lambda_observer_frame * uu.Angstrom))
+        if kwargs['output_format'] == 'spectra':
+            return namedtuple('output', ['time', 'lambdas', 'spectra'])(time=time_observer_frame,
+                                                                           lambdas=lambda_observer_frame,
+                                                                           spectra=spectra)
+        else:
+            return sed.get_correct_output_format_from_spectra(time=time_obs, time_eval=time_observer_frame,
+                                                          spectra=spectra, lambda_array=lambda_observer_frame,
+                                                          **kwargs)
+
+
 @citation_wrapper('https://ui.adsabs.harvard.edu/abs/2021ApJ...909..209P/abstract')
 def _shock_cooling(time, mass, radius, energy, **kwargs):
     """
@@ -22,6 +168,7 @@ def _shock_cooling(time, mass, radius, energy, **kwargs):
     delta = kwargs.get('delta',1.1)
     kk_pow = (nn - 3) * (3 - delta) / (4 * np.pi * (nn - delta))
     kappa = 0.2
+    mass = mass * solar_mass
     vt = (((nn - 5) * (5 - delta) / ((nn - 3) * (3 - delta))) * (2 * energy / mass))**0.5
     td = ((3 * kappa * kk_pow * mass) / ((nn - 1) * vt * speed_of_light))**0.5
 
@@ -34,18 +181,17 @@ def _shock_cooling(time, mass, radius, energy, **kwargs):
 
     tph = np.sqrt(3 * kappa * kk_pow * mass / (2 * (nn - 1) * vt * vt))
     r_photosphere_pre_td = np.power(tph / time, 2 / (nn - 1)) * vt * time
-    r_photosphere_post_td = (np.power((delta - 1) / (nn - 1) * ((time / td) ** 2 - 1) + 1, -1 / (delta + 1))* vt * time)
-    r_photosphere = np.zeros(len(time))
-    r_photosphere[time < td] = r_photosphere_pre_td[time < td]
-    r_photosphere[time >= td] = r_photosphere_post_td[time >= td]
+    r_photosphere_post_td = (np.power((delta - 1) / (nn - 1) * ((time / td) ** 2 - 1) + 1, -1 / (delta + 1)) * vt * time)
+    r_photosphere = r_photosphere_pre_td + r_photosphere_post_td
 
     sigmaT4 = lbol / (4 * np.pi * r_photosphere**2)
     temperature = np.power(sigmaT4 / sigma_sb, 0.25)
 
-    output = namedtuple('output', ['lbol', 'r_photosphere', 'temperature'])
+    output = namedtuple('output', ['lbol', 'r_photosphere', 'temperature', 'td'])
     output.lbol = lbol
     output.r_photosphere = r_photosphere
     output.temperature = temperature
+    output.td = td
     return output
 
 @citation_wrapper('https://ui.adsabs.harvard.edu/abs/2021MNRAS.505.3016N/abstract')
@@ -138,7 +284,7 @@ def shock_cooling(time, redshift, log10_mass, log10_radius, log10_energy, **kwar
                                              dl=dl, frequency=frequency)
         return flux_density.to(uu.mJy).value
     else:
-        time_temp = np.linspace(1e-4, 50, 50)
+        time_temp = np.linspace(1e-2, 10, 100)
         lambda_observer_frame = kwargs.get('lambda_array', np.geomspace(100, 60000, 100))
 
         time_observer_frame = time_temp
@@ -155,7 +301,7 @@ def shock_cooling(time, redshift, log10_mass, log10_radius, log10_energy, **kwar
                                                                           lambdas=lambda_observer_frame,
                                                                           spectra=spectra)
         else:
-            return sed.get_correct_output_format_from_spectra(time=time_obs, time_eval=time_observer_frame / day_to_s,
+            return sed.get_correct_output_format_from_spectra(time=time_obs, time_eval=time_observer_frame,
                                                               spectra=spectra, lambda_array=lambda_observer_frame,
                                                               **kwargs)
 
@@ -320,110 +466,12 @@ def _tau_nu(x, nism, radius, bfield, theta, xi, p, z_cool):
     val = radius*(alphanu_thermal + alphanu_pl)
     return val
 
-@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2021ApJ...923L..14M/abstract')
-def thermal_synchrotron_lnu(time, logn0, v0, logr0, eta, logepse, logepsb, xi, p, **kwargs):
-    """
-    :param time: time in source frame in seconds
-    :param logn0: log10 initial ambient ism density
-    :param v0: initial velocity in c
-    :param logr0: log10 initial radius
-    :param eta: deceleration slope (r = r0 * (time/t0)**eta; v = v0*(time/t0)**(eta-1))
-    :param logepse: log10 epsilon_e; electron thermalisation efficiency
-    :param logepsb: log10 epsilon_b; magnetic field amplification efficiency
-    :param xi: fraction of energy carried by power law electrons
-    :param p: electron power law slope
-    :param kwargs: extra parameters to change physics/settings
-    :param frequency: frequency to calculate model on - Must be same length as time array or a single number)
-    :param wind_slope: slope for ism density scaling (nism = n0 * (r/r0)**(-wind_slope)). Default is 2
-    :param mu: mean molecular weight, default is 0.62
-    :param mu_e: mean molecular weight per electron, default is 1.18
-    :return: lnu
-    """
-    v0 = v0 * speed_of_light
-    r0 = 10**logr0
-    t0 = eta * r0 / v0
-    radius = r0 * (time / t0) ** eta
-    velocity = v0 * (time/t0)**(eta - 1)
-    wind_slope = kwargs.get('wind_slope',2)
-    mu = kwargs.get('mu', 0.62)
-    mu_e = kwargs.get('mu_e', 1.18)
-    n0 = 10 ** logn0
-    nism = n0 * (radius / r0) ** (-wind_slope)
-
-    epsilon_T = 10**logepse
-    epsilon_B = 10**logepsb
-
-    frequency = kwargs['frequency']
-
-    ne = 4.0*mu_e*nism
-    beta = velocity/speed_of_light
-
-    theta0 = epsilon_T * (9.0 * mu * proton_mass / (32.0 * mu_e * electron_mass)) * beta ** 2
-    theta = (5.0*theta0-6.0+(25.0*theta0**2+180.0*theta0+36.0)**0.5)/30.0
-
-    bfield = (9.0*np.pi*epsilon_B*nism*mu*proton_mass)**0.5*velocity
-    # mean dynamical time:
-    td = radius/velocity
-
-    z_cool = (6.0 * np.pi * electron_mass * speed_of_light / (sigma_T * bfield ** 2 * td)) / theta
-    normalised_frequency_denom = 3.0*theta**2*qe*bfield/(4.0*np.pi*electron_mass*speed_of_light)
-    x = frequency / normalised_frequency_denom
-
-    emissivity_pl = _emissivity_pl(x=x, nism=ne, bfield=bfield, theta=theta, xi=xi, p=p, z_cool=z_cool)
-
-    emissivity_thermal = _emissivity_thermal(x=x, nism=ne, bfield=bfield, theta=theta, z_cool=z_cool)
-
-    emissivity = emissivity_thermal + emissivity_pl
-
-    tau = _tau_nu(x=x, nism=ne, radius=radius, bfield=bfield, theta=theta, xi=xi, p=p, z_cool=z_cool)
-
-    lnu = 4.0 * np.pi ** 2 * radius ** 3 * emissivity * (1e0 - np.exp(-tau)) / tau
-    if np.size(x) > 1:
-        lnu[tau < 1e-10] = (4.0 * np.pi ** 2 * radius ** 3 * emissivity)[tau < 1e-10]
-    elif tau < 1e-10:
-        lnu = 4.0 * np.pi ** 2 * radius ** 3 * emissivity
-    return lnu
-
-@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2021ApJ...923L..14M/abstract')
-def thermal_synchrotron_fluxdensity(time, redshift, logn0, v0, logr0, eta, logepse, logepsb,
-                                    xi, p, **kwargs):
-    """
-    :param time: time in observer frame in days
-    :param redshift: redshift
-    :param logn0: log10 initial ambient ism density
-    :param v0: initial velocity in c
-    :param logr0: log10 initial radius
-    :param eta: deceleration slope (r = r0 * (time/t0)**eta; v = v0*(time/t0)**(eta-1))
-    :param logepse: log10 epsilon_e; electron thermalisation efficiency
-    :param logepsb: log10 epsilon_b; magnetic field amplification efficiency
-    :param xi: fraction of energy carried by power law electrons
-    :param p: electron power law slope
-    :param kwargs: extra parameters to change physics/settings
-    :param frequency: frequency to calculate model on - Must be same length as time array or a single number)
-    :param wind_slope: slope for ism density scaling (nism = n0 * (r/r0)**(-wind_slope)). Default is 2
-    :param mu: mean molecular weight, default is 0.62
-    :param mu_e: mean molecular weight per electron, default is 1.18
-    :param kwargs: extra parameters to change physics and other settings
-    :param cosmology: Cosmology to use for luminosity distance calculation. Defaults to Planck18. Must be a astropy.cosmology object.
-    :return: flux density
-    """
-    frequency = kwargs['frequency']
-    frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)
-    new_kwargs = kwargs.copy()
-    new_kwargs['frequency'] = frequency
-    time = time * day_to_s
-    cosmology = kwargs.get('cosmology', cosmo)
-    dl = cosmology.luminosity_distance(redshift).cgs.value
-    lnu = thermal_synchrotron_lnu(time,logn0, v0, logr0, eta, logepse, logepsb, xi, p,**new_kwargs)
-    flux_density = lnu / (4.0 * np.pi * dl**2)
-    return flux_density
-
 @citation_wrapper('https://ui.adsabs.harvard.edu/abs/2018ApJ...855..103P/abstract')
 def _shocked_cocoon(time, mej, vej, eta, tshock, shocked_fraction, cos_theta_cocoon, kappa):
     """
     :param time: source frame time in days
     :param mej: ejecta mass in solar masses
-    :param vej: ejecta mass in km/s
+    :param vej: ejecta velocity in c
     :param eta: slope for ejecta density profile
     :param tshock: shock time in seconds
     :param shocked_fraction: fraction of ejecta mass shocked
@@ -431,8 +479,9 @@ def _shocked_cocoon(time, mej, vej, eta, tshock, shocked_fraction, cos_theta_coc
     :param kappa: opacity
     :return: namedtuple with lbol, r_photosphere, and temperature
     """
-    diff_const = solar_mass / (4*np.pi * speed_of_light * km_cgs)
     c_kms = speed_of_light / km_cgs
+    vej = vej * c_kms
+    diff_const = solar_mass / (4*np.pi * speed_of_light * km_cgs)
     rshock = tshock * speed_of_light
     shocked_mass = mej * shocked_fraction
     theta = np.arccos(cos_theta_cocoon)
@@ -479,7 +528,7 @@ def shocked_cocoon(time, redshift, mej, vej, eta, tshock, shocked_fraction, cos_
     :param time: observer frame time in days
     :param redshift: redshift
     :param mej: ejecta mass in solar masses
-    :param vej: ejecta mass in km/s
+    :param vej: ejecta velocity in c
     :param eta: slope for ejecta density profile
     :param tshock: shock time in seconds
     :param shocked_fraction: fraction of ejecta mass shocked
@@ -509,7 +558,7 @@ def shocked_cocoon(time, redshift, mej, vej, eta, tshock, shocked_fraction, cos_
         return flux_density.to(uu.mJy).value
     else:
         lambda_observer_frame = kwargs.get('frequency_array', np.geomspace(100, 60000, 100))
-        time_temp = np.linspace(1e-4, 50, 30)
+        time_temp = np.linspace(1e-2, 10, 100)
         time_observer_frame = time_temp
         frequency, time = calc_kcorrected_properties(frequency=lambda_to_nu(lambda_observer_frame),
                                                      redshift=redshift, time=time_observer_frame)
@@ -526,7 +575,7 @@ def shocked_cocoon(time, redshift, mej, vej, eta, tshock, shocked_fraction, cos_
                                                                           lambdas=lambda_observer_frame,
                                                                           spectra=spectra)
         else:
-            return sed.get_correct_output_format_from_spectra(time=time_obs, time_eval=time_observer_frame / day_to_s,
+            return sed.get_correct_output_format_from_spectra(time=time_obs, time_eval=time_observer_frame,
                                                               spectra=spectra, lambda_array=lambda_observer_frame,
                                                               **kwargs)