redback 1.12.0__py3-none-any.whl → 1.12.1__py3-none-any.whl

redback/transient_models/stellar_interaction_models.py

@@ -0,0 +1,254 @@
+import numpy as np
+from collections import namedtuple
+import redback.interaction_processes as ip
+import redback.sed as sed
+import redback.photosphere as photosphere
+from astropy.cosmology import Planck18 as cosmo
+from redback.utils import calc_kcorrected_properties, citation_wrapper, lambda_to_nu
+from redback.constants import *
+from scipy.interpolate import interp1d
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022ApJ...932...84M')
+def _wr_bh_merger(time, M_star, M_bh, M_fast, M_pre, v_fast, v_slow, alpha, eta, theta, phi_0, kappa_s, kappa_f, kappa_x, N, **kwargs): 
+    """
+    Parameters:
+    :param time: time in source frame in seconds
+    :param M_star: Mass of the Wolf-Rayet star in solar masses
+    :param M_bh: Mass of the black hole in solar masses
+    :param M_fast: Mass of the fast component in solar masses
+    :param M_pre: Mass of the pre-merger CSM in solar masses
+    :param v_fast: Velocity of the fast component in units of c
+    :param v_slow: Velocity of the slow component in km/s
+    :param alpha: Viscosity parameter
+    :param eta: Efficiency of conversion of accretion energy to radiation
+    :param theta: Disk aspect ratio
+    :param phi_0: Solid angle of the slow component
+    :param kappa_s: Opacity of the slow component
+    :param kappa_f: Opacity of the fast component
+    :param kappa_x: Opacity of the x-ray component
+    :param N: Number of pre-merger orbits
+    :param kwargs: Additional parameters
+    """
+    # Calculate constants
+    M_acc = M_acc = 0.05 * (M_bh/10.0)**0.6 * (M_star/10.0)**0.65
+    M_slow = M_star - M_fast - M_acc 
+
+    t_visc = 0.55 * day_to_s * (alpha / 0.1)**-1 * (M_star / 10.0)**0.87 * (M_bh / 10.0)**-0.5 * (theta / 0.33)**-2.0
+    L_acc0 = 1.6e44 * (M_bh / 10.0)**0.03 * (M_star / 10.0)**1.63 * (eta / 1e-2) * (alpha / 0.1)**-1.1 * (theta / 0.33)**-2.3
+    L_acc_tvisc = L_acc0 * (t_visc / (3.0 * day_to_s))**-2.1 * np.exp(-1)
+    vesc_trun = 9e13 * (N / 100) * (M_star / 10.0)**0.58
+
+    # Time-dependent properties
+    mask = time < t_visc
+    e_slow = 0.5 * (M_slow * solar_mass) * (v_slow * km_cgs)**2
+    e_fast = ((1.0 - v_fast**2)**-0.5 - 1.0) * (M_fast * solar_mass) * speed_of_light**2.0
+
+    rad_slow = v_slow * km_cgs * time
+    t_diff_slow = (M_slow * solar_mass) * kappa_s / (4.0 * np.pi * rad_slow * speed_of_light)
+    t_lc_slow = rad_slow / speed_of_light
+
+    rad_fast = v_fast * speed_of_light * time
+    t_diff_fast = (M_fast * solar_mass) * kappa_f / (4.0 * np.pi * rad_fast * speed_of_light)
+    t_lc_fast = rad_fast / speed_of_light
+    tau_x = kappa_x * (M_fast * solar_mass) / (4.0 * np.pi * rad_fast**2)
+
+    L_sh = 0.5 * (M_pre * solar_mass) * (v_slow * km_cgs)**3 / (vesc_trun) * np.exp(-v_slow * km_cgs * time / vesc_trun)
+    L_acc = L_acc0 * (time / (3.0 * day_to_s))**-2.1 * np.exp(-(time / t_visc)**0.28)
+    L_acc[mask] = L_acc_tvisc
+    L_acc_th = phi_0 * (1 - np.exp(-tau_x)) * L_acc + phi_0 * L_acc
+    L_x = phi_0 * np.exp(-tau_x) * L_acc
+
+    # Initialize arrays
+    energy_fast = [e_fast]
+    energy_slow = [e_slow]
+    L_opt_sh = []
+    L_opt_rep = []
+
+    for i in range(len(time)):
+        if i > 0:
+            dt = time[i] - time[i - 1]
+            de_slow_dt = -e_slow / time[i] - lum_opt_sh + L_sh[i]
+            de_fast_dt = -e_fast / time[i] - lum_opt_rep + L_acc_th[i]
+            e_slow += de_slow_dt * dt
+            if e_slow < 0:
+                e_slow = 0
+            e_fast += de_fast_dt * dt    
+            if e_fast < 0:
+                e_fast = 0
+            
+
+        lum_opt_sh = e_slow / (t_lc_slow[i] + t_diff_slow[i])
+        lum_opt_rep = e_fast / (t_lc_fast[i] + t_diff_fast[i])
+        L_opt_sh.append(lum_opt_sh)
+        L_opt_rep.append(lum_opt_rep)
+        energy_fast.append(e_fast)
+        energy_slow.append(e_slow)
+
+    dynamics_output = namedtuple('dynamics_output', ['time', 'energy_fast', 'energy_slow', 'rad_fast', 'rad_slow', 
+                                                     'reprocessed_luminosity', 'shock_powered_luminosity', 'optical_luminosity', 
+                                                     'x_ray_luminosity', 'accretion_luminosity', 'erad_opt_total'])
+
+    dynamics_output.time = time
+    dynamics_output.energy_fast = energy_fast
+    dynamics_output.energy_slow = energy_slow
+    dynamics_output.rad_fast = rad_fast
+    dynamics_output.rad_slow = rad_slow
+    dynamics_output.reprocessed_luminosity = L_opt_rep
+    dynamics_output.shock_powered_luminosity = L_opt_sh
+    dynamics_output.optical_luminosity = np.array(L_opt_rep) + np.array(L_opt_sh)
+    dynamics_output.x_ray_luminosity = L_x
+    dynamics_output.accretion_luminosity = L_acc
+    dynamics_output.erad_opt_total = np.trapz(np.array(L_opt_sh) + np.array(L_opt_sh), x=time)
+    return dynamics_output
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022ApJ...932...84M')
+def wr_bh_merger_bolometric(time, M_star, M_bh, M_fast, M_pre, v_fast, v_slow, alpha, eta, **kwargs):
+    """
+    Parameters:
+    :param time: time in source frame in days
+    :param M_star: Mass of the Wolf-Rayet star in solar masses
+    :param M_bh: Mass of the black hole in solar masses
+    :param M_fast: Mass of the fast component in solar masses
+    :param M_pre: Mass of the pre-merger CSM in solar masses
+    :param v_fast: Velocity of the fast component in units of c
+    :param v_slow: Velocity of the slow component in km/s
+    :param alpha: Viscosity parameter
+    :param eta: Efficiency of conversion of accretion energy to radiation
+    :param kwargs: Additional parameters
+    :param output_format: whether to output dynamics or bolometric luminosity
+    :param theta: Disk aspect ratio
+    :param phi_0: Solid angle of the slow component
+    :param kappa_s: Opacity of the slow component
+    :param kappa_f: Opacity of the fast component
+    :param kappa_x: Opacity of the x-ray component
+    :param N: Number of pre-merger orbits
+    :return: bolometric luminosity or dynamics output
+    """
+    theta = kwargs.get('theta', 0.33)
+    phi_0 = kwargs.get('phi_0', 0.5)
+    kappa_s = kwargs.get('kappa_s', 0.03)
+    kappa_f = kwargs.get('kappa_f', 0.2)
+    kappa_x = kwargs.get('kappa_x', 0.4)
+    N = kwargs.get('N', 30)
+
+    time_temp = np.geomspace(1e0, 1e8, 2000)
+    dynamics_output = _wr_bh_merger(time_temp, M_star, M_bh, M_fast, M_pre, v_fast, v_slow, alpha, eta, theta, phi_0, kappa_s, kappa_f, kappa_x, N, **kwargs)
+    lbol_func = interp1d(time_temp, y=dynamics_output.optical_luminosity)
+    time = time * day_to_s    
+    lbol = lbol_func(time)
+    if kwargs['output_format'] == 'dynamics_output':
+        return dynamics_output
+    else:
+        return lbol
+    
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022ApJ...932...84M')
+def wr_bh_merger(time, redshift, M_star, M_bh, M_fast, M_pre, v_fast, v_slow, alpha, eta, **kwargs):
+    """
+    Parameters:
+    :param time: time in source frame in days
+    :param redshift: redshift 
+    :param M_star: Mass of the Wolf-Rayet star in solar masses
+    :param M_bh: Mass of the black hole in solar masses
+    :param M_fast: Mass of the fast component in solar masses
+    :param M_pre: Mass of the pre-merger CSM in solar masses
+    :param v_fast: Velocity of the fast component in units of c
+    :param v_slow: Velocity of the slow component in km/s
+    :param alpha: Viscosity parameter
+    :param eta: Efficiency of conversion of accretion energy to radiation
+    :param kwargs: Additional parameters - Must be all the kwargs required by the specific photosphere, sed methods used
+             e.g., for TemperatureFloor: vej (km/s) and temperature_floor
+    :param theta: Disk aspect ratio
+    :param phi_0: Solid angle of the slow component
+    :param kappa_s: Opacity of the slow component
+    :param kappa_f: Opacity of the fast component
+    :param kappa_x: Opacity of the x-ray component
+    :param N: Number of pre-merger orbits
+    :param photosphere: Default is TemperatureFloor.
+            kwargs must have vej or relevant parameters if using different photosphere 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', 'dynamics_output', 'spectra', 'flux', 'sncosmo_source'
+    """
+
+    theta = kwargs.get('theta', 0.33)
+    phi_0 = kwargs.get('phi_0', 0.5)
+    kappa_s = kwargs.get('kappa_s', 0.03)
+    kappa_f = kwargs.get('kappa_f', 0.2)
+    kappa_x = kwargs.get('kappa_x', 0.4)
+    N = kwargs.get('N', 30)
+    kwargs['photosphere'] = kwargs.get("photosphere", photosphere.TemperatureFloor)
+    kwargs['sed'] = kwargs.get("sed", sed.Blackbody)
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+
+    time_temp = np.geomspace(1e0, 1e8, 2000)
+    if kwargs['output_format'] == 'flux_density':
+        frequency = kwargs['frequency']
+        frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)
+        output = _wr_bh_merger(time_temp, M_star, M_bh, M_fast, M_pre, v_fast, v_slow, alpha, eta, theta, phi_0, kappa_s, kappa_f, kappa_x, N, **kwargs)
+        photo_fast = kwargs['photosphere'](time=time_temp/day_to_s, luminosity=np.array(output.reprocessed_luminosity), vej = v_fast * speed_of_light / km_cgs, **kwargs) 
+        photo_slow = kwargs['photosphere'](time=time_temp/day_to_s, luminosity=np.array(output.shock_powered_luminosity), vej = v_slow, **kwargs)
+        temp_func_fast = interp1d(time_temp/day_to_s, y=photo_fast.photosphere_temperature)
+        temp_func_slow = interp1d(time_temp/day_to_s, y=photo_slow.photosphere_temperature)
+        rad_func_fast = interp1d(time_temp/day_to_s, y=photo_fast.r_photosphere)
+        rad_func_slow = interp1d(time_temp/day_to_s, y=photo_slow.r_photosphere)
+        temp_fast = temp_func_fast(time)
+        temp_slow = temp_func_slow(time)
+        rad_fast = rad_func_fast(time)
+        rad_slow = rad_func_slow(time)
+        sed_fast = kwargs['sed'](temperature=temp_fast, r_photosphere=rad_fast, 
+                                            frequency=frequency, luminosity_distance=dl) 
+        sed_slow = kwargs['sed'](temperature=temp_slow, r_photosphere=rad_slow, 
+                                            frequency=frequency, luminosity_distance=dl)
+        flux_density = sed_fast.flux_density + sed_slow.flux_density
+        return flux_density.to(uu.mJy).value
+    
+    else:
+        time_obs = time
+        lambda_observer_frame = kwargs.get('lambda_array', np.geomspace(500, 60000, 200))
+        time_temp = np.geomspace(1e0, 1e8, 2000)
+        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)
+        output = _wr_bh_merger(time_temp, M_star, M_bh, M_fast, M_pre, v_fast, v_slow, alpha, eta, theta, phi_0, kappa_s, kappa_f, kappa_x, N, **kwargs)
+        photo_fast = kwargs['photosphere'](time=time_temp/day_to_s, luminosity=np.array(output.reprocessed_luminosity), vej = v_fast * speed_of_light / km_cgs, **kwargs) 
+        photo_slow = kwargs['photosphere'](time=time_temp/day_to_s, luminosity=np.array(output.shock_powered_luminosity), vej = v_slow, **kwargs)
+        if kwargs['output_format'] == 'dynamics_output':                                               
+            dynamics_output = namedtuple('dynamics_output', ['time', 'temperature_fast', 'temperature_slow','r_photosphere_fast',
+                                                     'r_photosphere_slow','energy_fast','energy_slow','optical_luminosity',
+                                                     'reprocessed_luminosity','shock_powered_luminosity','x_ray_luminosity',
+                                                     'accretion_luminosity','erad_opt_total'])
+            dynamics_output.time = output.time                                                                    
+            dynamics_output.temperature_fast = photo_fast.photosphere_temperature
+            dynamics_output.temperature_slow = photo_slow.photosphere_temperature
+            dynamics_output.r_photosphere_fast = photo_fast.r_photosphere 
+            dynamics_output.r_photosphere_slow = photo_slow.r_photosphere 
+            dynamics_output.energy_fast = output.energy_fast
+            dynamics_output.energy_slow = output.energy_slow
+            dynamics_output.optical_luminosity = output.optical_luminosity
+            dynamics_output.reprocessed_luminosity = output.reprocessed_luminosity
+            dynamics_output.shock_powered_luminosity = output.shock_powered_luminosity
+            dynamics_output.x_ray_luminosity = output.x_ray_luminosity
+            dynamics_output.accretion_luminosity = output.accretion_luminosity
+            dynamics_output.erad_opt_total = output.erad_opt_total            
+            return dynamics_output                
+        sed_fast = kwargs['sed'](temperature=photo_fast.photosphere_temperature, r_photosphere=photo_fast.r_photosphere,
+                    frequency=frequency[:,None], luminosity_distance=dl)
+        sed_slow = kwargs['sed'](temperature=photo_slow.photosphere_temperature, r_photosphere=photo_slow.r_photosphere,
+                    frequency=frequency[:,None], luminosity_distance=dl)
+        fmjy = sed_fast.flux_density + sed_slow.flux_density
+        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/day_to_s,
+                                                              spectra=spectra, lambda_array=lambda_observer_frame,
+                                                              **kwargs)

redback/transient_models/supernova_models.py

@@ -13,7 +13,7 @@ from redback.constants import day_to_s, solar_mass, km_cgs, au_cgs, speed_of_lig
 from inspect import isfunction
 import astropy.units as uu
 from collections import namedtuple
-from scipy.interpolate import interp1d
+from scipy.interpolate import interp1d, RegularGridInterpolator
 
 homologous_expansion_models = ['exponential_powerlaw_bolometric', 'arnett_bolometric',
                                'basic_magnetar_powered_bolometric','slsn_bolometric',
@@ -228,6 +228,66 @@ def sn_fallback(time, redshift, logl1, tr, **kwargs):
             return sed.get_correct_output_format_from_spectra(time=time_obs, time_eval=time_observer_frame,
                                                               spectra=spectra, lambda_array=lambda_observer_frame,
                                                               **kwargs)
+                                                              
+def sn_nickel_fallback(time, redshift, mej, f_nickel, logl1, tr, **kwargs):
+    """
+    :param time: observer frame time in days
+    :param redshift: source redshift
+    :param mej: total ejecta mass in solar masses
+    :param f_nickel: fraction of nickel mass
+    :param logl1: bolometric luminosity scale in log10 (cgs)
+    :param tr: transition time for luminosity
+    :param kwargs: Must be all the kwargs required by the specific interaction_process, photosphere, sed methods used
+        e.g., for Diffusion and TemperatureFloor: kappa, kappa_gamma, mej (solar masses), vej (km/s), floor temperature
+    :param interaction_process: Default is Diffusion.
+            Can also be None in which case the output is just the raw engine luminosity, or another interaction process.
+    :param photosphere: Default is TemperatureFloor.
+            kwargs must vej or relevant parameters if using different photosphere model
+    :param sed: Default is blackbody.
+    :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’
+    """
+    kwargs["interaction_process"] = kwargs.get("interaction_process", ip.Diffusion)
+    kwargs["photosphere"] = kwargs.get("photosphere", photosphere.TemperatureFloor)
+    kwargs["sed"] = kwargs.get("sed", sed.Blackbody)
+    cosmology = kwargs.get("cosmology", cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+    if kwargs['output_format'] == 'flux_density':
+        frequency = kwargs['frequency']
+        frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)       
+        lbol = fallback_lbol(time=time, logl1=logl1, tr=tr) + _nickelcobalt_engine(time=time, f_nickel=f_nickel, mej=mej)
+        photo = kwargs['photosphere'](time=time, luminosity=lbol, **kwargs)
+        sed_1 = kwargs['sed'](temperature=photo.photosphere_temperature, r_photosphere=photo.r_photosphere,
+              frequency=frequency, luminosity_distance=dl)
+        flux_density = sed_1.flux_density
+        return flux_density.to(uu.mJy).value
+    else:
+        time_obs = time
+        lambda_observer_frame = kwargs.get('lambda_array', np.geomspace(100, 60000, 100))
+        time_temp = np.geomspace(0.1, 3000, 300) # in days
+        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)
+        lbol = fallback_lbol(time=time, logl1=logl1, tr=tr) + _nickelcobalt_engine(time=time, f_nickel=f_nickel, mej=mej)
+        photo = kwargs['photosphere'](time=time, luminosity=lbol, **kwargs)
+        sed_1 = kwargs['sed'](temperature=photo.photosphere_temperature, r_photosphere=photo.r_photosphere,
+                              frequency=frequency[:,None], luminosity_distance=dl)
+        fmjy = sed_1.flux_density.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/2018ApJS..236....6G/abstract')
 def sn_exponential_powerlaw(time, redshift, lbol_0, alpha_1, alpha_2, tpeak_d, **kwargs):
@@ -833,13 +893,12 @@ def slsn(time, redshift, p0, bp, mass_ns, theta_pb,**kwargs):
         lbol = slsn_bolometric(time=time, p0=p0, bp=bp, mass_ns=mass_ns, theta_pb=theta_pb, **kwargs)
         photo = kwargs['photosphere'](time=time, luminosity=lbol, **kwargs)
         full_sed = np.zeros((len(time), len(frequency)))
-        for ii in range(len(frequency)):
-            ss = kwargs['sed'](time=time, temperature=photo.photosphere_temperature,
-                               r_photosphere=photo.r_photosphere, frequency=frequency[ii],
-                               luminosity_distance=dl, cutoff_wavelength=cutoff_wavelength, luminosity=lbol)
-            full_sed[:, ii] = ss.flux_density.to(uu.mJy).value            
+        ss = kwargs['sed'](time=time, temperature=photo.photosphere_temperature,
+                        r_photosphere=photo.r_photosphere, frequency=frequency[:, None],
+                        luminosity_distance=dl, cutoff_wavelength=cutoff_wavelength, luminosity=lbol)
+        full_sed = ss.flux_density.to(uu.mJy).value.T    
         spectra = (full_sed * uu.mJy).to(uu.erg / uu.cm ** 2 / uu.s / uu.Angstrom,
-                                         equivalencies=uu.spectral_density(wav=lambda_observer_frame * 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,
@@ -1423,17 +1482,17 @@ def type_1a(time, redshift, f_nickel, mej, **kwargs):
     :param line_duration: line duration, default is 25
     :param line_amplitude: line amplitude, default is 0.3
     :param frequency: Required if output_format is 'flux_density'.
-        frequency to calculate - Must be same length as time array or a single number).
+        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.
+    :param cosmology: cosmology to use for luminosity distance calculation. Defaults to Planck18. Must be an astropy.cosmology object.
     :return: set by output format - 'flux_density', 'magnitude', 'spectra', 'flux', 'sncosmo_source'
     """
     cosmology = kwargs.get('cosmology', cosmo)
     dl = cosmology.luminosity_distance(redshift).cgs.value
     cutoff_wavelength = kwargs.get('cutoff_wavelength', 3000)
-    line_wavelength = kwargs.get('line_wavelength',7.5e3)
+    line_wavelength = kwargs.get('line_wavelength', 7.5e3)
     line_width = kwargs.get('line_width', 500)
     line_time = kwargs.get('line_time', 50)
     line_duration = kwargs.get('line_duration', 25)
@@ -1447,13 +1506,13 @@ def type_1a(time, redshift, f_nickel, mej, **kwargs):
 
         photo = photosphere.TemperatureFloor(time=time, luminosity=lbol, **kwargs)
         sed_1 = sed.CutoffBlackbody(time=time, luminosity=lbol, temperature=photo.photosphere_temperature,
-                                    r_photosphere=photo.r_photosphere,frequency=frequency, luminosity_distance=dl,
+                                    r_photosphere=photo.r_photosphere, frequency=frequency, luminosity_distance=dl,
                                     cutoff_wavelength=cutoff_wavelength)
         sed_2 = sed.Line(time=time, luminosity=lbol, frequency=frequency, luminosity_distance=dl,
                          sed=sed_1, line_wavelength=line_wavelength,
                          line_width=line_width, line_time=line_time,
                          line_duration=line_duration, line_amplitude=line_amplitude)
-        flux_density = sed_2.flux_density
+        flux_density = sed_2.flux_density.flatten()
         return flux_density.to(uu.mJy).value
     else:
         time_obs = time
@@ -1465,18 +1524,23 @@ def type_1a(time, redshift, f_nickel, mej, **kwargs):
         lbol = arnett_bolometric(time=time, f_nickel=f_nickel, mej=mej,
                                  interaction_process=ip.Diffusion, **kwargs)
         photo = photosphere.TemperatureFloor(time=time, luminosity=lbol, **kwargs)
-        full_sed = np.zeros((len(time), len(frequency)))
-        for ii in range(len(frequency)):
-            ss = sed.CutoffBlackbody(time=time, temperature=photo.photosphere_temperature,
-                               r_photosphere=photo.r_photosphere, frequency=frequency[ii],
-                               luminosity_distance=dl, cutoff_wavelength=cutoff_wavelength, luminosity=lbol)
-            sed_2 = sed.Line(time=time, luminosity=lbol, frequency=frequency[ii], luminosity_distance=dl,
-                             sed=ss, line_wavelength=line_wavelength,
-                             line_width=line_width, line_time=line_time,
-                             line_duration=line_duration, line_amplitude=line_amplitude)
-            full_sed[:,ii] = sed_2.flux_density.to(uu.mJy).value
+        # Here we construct the CutoffBlackbody SED with frequency reshaped to (n_freq, 1)
+        ss = sed.CutoffBlackbody(time=time, temperature=photo.photosphere_temperature,
+                                 r_photosphere=photo.r_photosphere, frequency=frequency[:, None],
+                                 luminosity_distance=dl, cutoff_wavelength=cutoff_wavelength, luminosity=lbol)
+        line_sed = sed.Line(time=time, luminosity=lbol, frequency=frequency[:, None],
+                            luminosity_distance=dl, sed=ss,
+                            line_wavelength=line_wavelength,
+                            line_width=line_width,
+                            line_time=line_time,
+                            line_duration=line_duration,
+                            line_amplitude=line_amplitude)
+        full_sed = line_sed.flux_density.to(uu.mJy).value
+        # The following line converts the full SED (in mJy) to erg/s/cm^2/Angstrom.
         spectra = (full_sed * uu.mJy).to(uu.erg / uu.cm ** 2 / uu.s / uu.Angstrom,
-                                         equivalencies=uu.spectral_density(wav=lambdas_observer_frame * uu.Angstrom))
+                                         equivalencies=uu.spectral_density(
+                                             wav=(lambdas_observer_frame.reshape(-1, 1) * uu.Angstrom))).T
+        print(spectra.shape)
         if kwargs['output_format'] == 'spectra':
             return namedtuple('output', ['time', 'lambdas', 'spectra'])(time=time_observer_frame,
                                                                           lambdas=lambdas_observer_frame,
@@ -1487,6 +1551,7 @@ def type_1a(time, redshift, f_nickel, mej, **kwargs):
                                                               **kwargs)
 
 
+
 @citation_wrapper('https://ui.adsabs.harvard.edu/abs/2018ApJS..236....6G/abstract')
 def type_1c(time, redshift, f_nickel, mej, pp, **kwargs):
     """
@@ -1636,7 +1701,7 @@ def general_magnetar_slsn(time, redshift, l0, tsd, nn, ** kwargs):
                                                               spectra=spectra, lambda_array=lambda_observer_frame,
                                                               **kwargs)
 
-@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2024MNRAS.527.6455O/abstract')
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022MNRAS.516.4949S/abstract, https://ui.adsabs.harvard.edu/abs/2024MNRAS.527.6455O/abstract')
 def general_magnetar_driven_supernova_bolometric(time, mej, E_sn, kappa, l0, tau_sd, nn, kappa_gamma, **kwargs):   
     """
     :param time: time in observer frame in days
@@ -1675,8 +1740,6 @@ def general_magnetar_driven_supernova_bolometric(time, mej, E_sn, kappa, l0, tau
     time = time * day_to_s    
     lbol = lbol_func(time)
     v_ej = vej_func(time)
-    erot_total = np.trapz(magnetar_luminosity, x=time_temp)
-    erad_total = np.trapz(output.bolometric_luminosity, x=time_temp) 
     
     dynamics_output = namedtuple('dynamics_output', ['v_ej', 'tau', 'time', 'bolometric_luminosity', 'kinetic_energy', 'erad_total',
                                                      'thermalisation_efficiency', 'magnetar_luminosity', 'erot_total'])
@@ -1696,7 +1759,7 @@ def general_magnetar_driven_supernova_bolometric(time, mej, E_sn, kappa, l0, tau
     else:
         return lbol
 
-@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2024MNRAS.527.6455O/abstract')
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022MNRAS.516.4949S/abstract, https://ui.adsabs.harvard.edu/abs/2024MNRAS.527.6455O/abstract')
 def general_magnetar_driven_supernova(time, redshift, mej, E_sn, kappa, l0, tau_sd, nn, kappa_gamma, **kwargs):
     """
     :param time: time in observer frame in days
@@ -1796,11 +1859,10 @@ def general_magnetar_driven_supernova(time, redshift, mej, E_sn, kappa, l0, tau_
             return dynamics_output
         else: 
             full_sed = np.zeros((len(time), len(frequency)))
-            for ii in range(len(frequency)):
-                ss = kwargs['sed'](time=time_temp/day_to_s, temperature=photo.photosphere_temperature,
-                               r_photosphere=photo.r_photosphere, frequency=frequency[ii],
-                               luminosity_distance=dl, cutoff_wavelength=cutoff_wavelength, luminosity=output.bolometric_luminosity)
-                full_sed[:, ii] = ss.flux_density.to(uu.mJy).value
+            ss = kwargs['sed'](time=time_temp/day_to_s, temperature=photo.photosphere_temperature,
+                            r_photosphere=photo.r_photosphere, frequency=frequency[:, None],
+                            luminosity_distance=dl, cutoff_wavelength=cutoff_wavelength, luminosity=output.bolometric_luminosity)
+            full_sed = ss.flux_density.to(uu.mJy).value.T    
             spectra = (full_sed * 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':
@@ -2057,4 +2119,181 @@ def shocked_cocoon_and_arnett(time, redshift, mej_c, vej_c, eta, tshock, shocked
         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)
+                                                              **kwargs)
+
+@citation_wrapper("https://ui.adsabs.harvard.edu/abs/2025arXiv250602107S/abstract, https://ui.adsabs.harvard.edu/abs/2023PASJ...75..634M/abstract")
+def typeII_bolometric(time, progenitor, ni_mass, log10_mdot, beta, rcsm, esn, **kwargs):
+    """
+    Bolometric luminosity for a Type II supernova based on Sarin et al. 2025 surrogate model
+    to stella grid in Moriya et al. 2023
+
+    :param time: Time in days in source frame
+    :param progenitor: in solar masses
+    :param ni_mass: in solar masses
+    :param log10_mdot: in solar masses per year
+    :param beta: dimensionless
+    :param rcsm: in 10^14 cm
+    :param esn: in 10^51
+    :param kwargs: None
+    :return: bolometric luminosity in erg/s
+    """
+    from redback_surrogates.supernovamodels import typeII_lbol
+    tt, lbol = typeII_lbol(time=time, progenitor=progenitor, ni_mass=ni_mass,
+                      log10_mdot=log10_mdot, beta=beta, rcsm=rcsm, esn=esn, **kwargs)
+    lbol_func = interp1d(tt, y=lbol, bounds_error=False, fill_value='extrapolate')
+    return lbol_func(time)
+
+@citation_wrapper("https://ui.adsabs.harvard.edu/abs/2025arXiv250602107S/abstract, https://ui.adsabs.harvard.edu/abs/2023PASJ...75..634M/abstract")
+def typeII_photosphere_properties(time, progenitor, ni_mass, log10_mdot, beta, rcsm, esn, **kwargs):
+    """
+    Photosphere properties for a Type II supernova based on Sarin et al. 2025 surrogate model
+    to stella grid in Moriya et al. 2023
+
+    :param time: Time in days in source frame
+    :param progenitor: in solar masses
+    :param ni_mass: in solar masses
+    :param log10_mdot: in solar masses per year
+    :param beta: dimensionless
+    :param rcsm: in 10^14 cm
+    :param esn: in 10^51
+    :param kwargs: None
+    :return: photosphere properties (temperature in K, radius in cm)
+    """
+    from redback_surrogates.supernovamodels import typeII_photosphere
+    tt, temp, rad = typeII_photosphere(time=time, progenitor=progenitor, ni_mass=ni_mass,
+                      log10_mdot=log10_mdot, beta=beta, rcsm=rcsm, esn=esn, **kwargs)
+    temp_func = interp1d(tt, y=temp, bounds_error=False, fill_value='extrapolate')
+    rad_func = interp1d(tt, y=rad, bounds_error=False, fill_value='extrapolate')
+    return temp_func(time), rad_func(time)
+
+@citation_wrapper("https://ui.adsabs.harvard.edu/abs/2025arXiv250602107S/abstract, https://ui.adsabs.harvard.edu/abs/2023PASJ...75..634M/abstract")
+def typeII_surrogate_sarin25(time, redshift, progenitor, ni_mass, log10_mdot, beta, rcsm, esn, **kwargs):
+    """
+    Type II supernova model based on Sarin et al. 2025 surrogate model
+    to stella grid in Moriya et al. 2023
+
+    :param time: Time in days in observer frame
+    :param redshift: redshift
+    :param progenitor: in solar masses
+    :param ni_mass: in solar masses
+    :param log10_mdot: in solar masses per year
+    :param beta: dimensionless
+    :param rcsm: in 10^14 cm
+    :param esn: in 10^51
+    :param kwargs: Additional parameters for the model, such as:
+    :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'
+    """
+    from redback_surrogates.supernovamodels import typeII_spectra
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs
+
+    # Get the rest-frame spectrum using typeII_spectra
+    spectra_output = typeII_spectra(
+        progenitor=progenitor,
+        ni_mass=ni_mass,
+        log10_mdot=log10_mdot,
+        beta=beta,
+        rcsm=rcsm,
+        esn=esn,
+        **kwargs
+    )
+
+    # Extract components from the output
+    rest_spectrum = spectra_output.spectrum  # erg/s/Hz in rest frame
+    standard_freqs = spectra_output.frequency.value  # Angstrom in rest frame
+    standard_times = spectra_output.time.value  # days in rest frame
+
+    # Apply cosmological dimming
+    observed_spectrum = rest_spectrum / (4 * np.pi * dl ** 2)
+
+    # Handle different output formats
+    if kwargs.get('output_format') == 'flux_density':
+        # Use redback's K-correction utilities
+        frequency = kwargs['frequency']
+        frequency, time = calc_kcorrected_properties(frequency=frequency, time=time, redshift=redshift)
+
+        # Convert wavelengths to frequencies for interpolation
+        nu_array = lambda_to_nu(standard_freqs)
+
+        # Convert spectrum from erg/s/Hz to erg/s/cm²/Hz (already done above)
+        # Convert to wavelength density for astropy conversion
+        spectra_lambda = spectra_lambda.to(uu.erg / uu.cm ** 2 / uu.s / uu.Angstrom)
+
+        # Convert to mJy using astropy
+        fmjy = spectra_lambda.to(uu.mJy,
+                                 equivalencies=uu.spectral_density(wav=standard_freqs * uu.Angstrom)).value
+
+        # Create interpolator
+        flux_interpolator = RegularGridInterpolator(
+            (standard_times, nu_array),
+            fmjy,
+            bounds_error=False,
+            fill_value=0.0
+        )
+
+        # Prepare points for interpolation
+        if isinstance(frequency, (int, float)):
+            frequency = np.ones_like(time) * frequency
+
+        # Create points for evaluation
+        points = np.column_stack((time, frequency))
+
+        # Return interpolated flux
+        return flux_interpolator(points)
+
+    else:
+        # Create denser grid for output (in rest frame)
+        new_rest_times = np.geomspace(np.min(standard_times), np.max(standard_times), 200)
+        new_rest_freqs = np.geomspace(np.min(standard_freqs), np.max(standard_freqs), 200)
+
+        # Create interpolator for the spectrum in rest frame
+        spectra_func = RegularGridInterpolator(
+            (standard_times, standard_freqs),
+            observed_spectrum.value,
+            bounds_error=False,
+            fill_value=0.0
+        )
+
+        # Create meshgrid for new grid points
+        tt_mesh, ff_mesh = np.meshgrid(new_rest_times, new_rest_freqs, indexing='ij')
+        points_to_evaluate = np.column_stack((tt_mesh.ravel(), ff_mesh.ravel()))
+
+        # Interpolate spectrum onto new grid
+        interpolated_values = spectra_func(points_to_evaluate)
+        interpolated_spectrum = interpolated_values.reshape(tt_mesh.shape) * observed_spectrum.unit
+
+        # Convert times to observer frame
+        time_observer_frame = new_rest_times * (1 + redshift)
+
+        # Convert wavelengths to observer frame
+        lambda_observer_frame = new_rest_freqs * (1 + redshift)
+
+        # Convert spectrum units using astropy
+        interpolated_spectrum = interpolated_spectrum.to(
+            uu.erg / uu.cm ** 2 / uu.s / uu.Angstrom,
+            equivalencies=uu.spectral_density(wav=lambda_observer_frame * uu.Angstrom)
+        )
+
+        # Create output structure
+        if kwargs.get('output_format') == 'spectra':
+            return namedtuple('output', ['time', 'lambdas', 'spectra'])(
+                time=time_observer_frame,
+                lambdas=lambda_observer_frame,
+                spectra=interpolated_spectrum
+            )
+        else:
+            # Get correct output format using redback utility
+            return sed.get_correct_output_format_from_spectra(
+                time=time,  # Original observer frame time for evaluation
+                time_eval=time_observer_frame,
+                spectra=interpolated_spectrum,
+                lambda_array=lambda_observer_frame,
+                time_spline_degree=1,
+                **kwargs
+            )