redback 1.0.31__py3-none-any.whl → 1.1__py3-none-any.whl

redback/transient_models/__init__.py

@@ -1,4 +1,5 @@
-from redback.transient_models import afterglow_models, \
+from redback.transient_models import (afterglow_models, \
     extinction_models, kilonova_models, fireball_models, \
     gaussianprocess_models, magnetar_models, magnetar_driven_ejecta_models, phase_models, prompt_models, \
-    shock_powered_models, supernova_models, tde_models, integrated_flux_afterglow_models, phenomenological_models, combined_models
+    shock_powered_models, supernova_models, tde_models, integrated_flux_afterglow_models, phenomenological_models, \
+    combined_models, spectral_models,)

redback/transient_models/extinction_models.py

@@ -23,7 +23,8 @@ extinction_integrated_flux_afterglow_models = extinction_afterglow_base_models
 extinction_supernova_base_models = ['sn_exponential_powerlaw', 'arnett', 'shock_cooling_and_arnett',
                                     'basic_magnetar_powered', 'slsn', 'magnetar_nickel',
                                     'csm_interaction', 'csm_nickel', 'type_1a', 'type_1c',
-                                    'general_magnetar_slsn','general_magnetar_driven_supernova', 'sn_fallback']
+                                    'general_magnetar_slsn','general_magnetar_driven_supernova', 'sn_fallback',
+                                    'csm_shock_and_arnett', 'shocked_cocoon_and_arnett', 'csm_shock_and_arnett_two_rphots']
 extinction_kilonova_base_models = ['nicholl_bns', 'mosfit_rprocess', 'mosfit_kilonova',
                                    'power_law_stratified_kilonova','bulla_bns_kilonova',
                                    'bulla_nsbh_kilonova', 'kasen_bns_kilonova','two_layer_stratified_kilonova',
@@ -38,7 +39,7 @@ extinction_magnetar_driven_base_models = ['basic_mergernova', 'general_mergernov
                                           'general_mergernova_evolution', 'metzger_magnetar_driven_kilonova_model',
                                           'general_metzger_magnetar_driven', 'general_metzger_magnetar_driven_thermalisation',
                                           'general_metzger_magnetar_driven_evolution']
-extinction_shock_powered_base_models = ['shocked_cocoon', 'shock_cooling']
+extinction_shock_powered_base_models = ['shocked_cocoon', 'shock_cooling', 'csm_shock_breakout']
 
 extinction_model_library = {'kilonova': extinction_kilonova_base_models,
                             'supernova': extinction_supernova_base_models,

redback/transient_models/gaussianprocess_models.py

@@ -0,0 +1,45 @@
+import george.modeling
+from redback.transient_models import phenomenological_models as pm
+
+def calculate_flux_with_labels(time, t0, tau_rise, tau_fall, labels, **kwargs):
+    """
+    Calculate flux for multiple sets of parameters using the Bazin function,
+    where parameters are indexed by the provided labels.
+
+    :param time: time array in arbitrary units
+    :param t0: start time
+    :param tau_rise: exponential rise time
+    :param tau_fall: exponential fall time
+    :param labels: list of strings to generate parameter names
+    :param kwargs: keyword arguments for parameters in the form a_{label}, b_{label}, etc.
+    :return: dictionary with labels as keys and flux arrays as values
+    """
+    a_values = []
+    b_values = []
+
+    for label in labels:
+        a_key = f'a_{label}'
+        b_key = f'b_{label}'
+        if a_key in kwargs and b_key in kwargs:
+            a_values.append(kwargs[a_key])
+            b_values.append(kwargs[b_key])
+        else:
+            raise ValueError(f"Missing parameters for label '{label}'.")
+
+    # Call bazin_sne once with all aa and bb values
+    flux_matrix = pm.bazin_sne(time, a_values, b_values, t0, tau_rise, tau_fall)
+
+    # Construct the result dictionary with labels
+    flux_results = {f'{label}': flux_matrix[i] for i, label in enumerate(labels)}
+
+    return flux_results
+
+class BazinGPModel(george.modeling.Model):
+    def __init__(self, band_labels):
+        self.parameter_names = ['t0', 'tau_rise', 'tau_fall']
+        self.band_labels = band_labels
+        for label in band_labels:
+            self.parameter_names.extend([f'a_{label}', f'b_{label}'])
+
+        def get_flux(self, t):
+            return calculate_flux_with_labels(t, **self.get_parameter_vector())

redback/transient_models/general_synchrotron_models.py

@@ -1,7 +1,7 @@
 import numpy as np
 from redback.transient_models.magnetar_models import magnetar_only, basic_magnetar
 from redback.transient_models.magnetar_driven_ejecta_models import _ejecta_dynamics_and_interaction
-from redback.transient_models.shock_powered_models import _emissivity_pl, _emissivity_thermal, _tau_nu
+from redback.transient_models.shock_powered_models import _emissivity_pl, _emissivity_thermal, _tau_nu, _c_j, _c_alpha, _g_theta, _low_freq_apl_correction, _low_freq_jpl_correction
 from redback.transient_models.afterglow_models import _get_kn_dynamics, _pnu_synchrotron
 from astropy.cosmology import Planck18 as cosmo
 from redback.utils import calc_kcorrected_properties, citation_wrapper, logger, get_csm_properties, nu_to_lambda, lambda_to_nu, velocity_from_lorentz_factor, calc_ABmag_from_flux_density
@@ -10,6 +10,7 @@ from scipy import integrate
 from scipy.interpolate import interp1d
 import astropy.units as uu
 from collections import namedtuple
+from scipy import special
 
 def _calc_free_free_abs(frequency, Y_fe, Zbar, mej, radius_2darray, F_nu_2darray):
     """
@@ -97,7 +98,7 @@ def pwn(time, redshift, mej, l0, tau_sd, nn, eps_b, gamma_b, **kwargs):
     :param eps_b: magnetization of the PWN
     :param gamma_b: Lorentz factor of electrons at synchrotron break
     :param kwargs: Additional parameters - 
-    :param E_sn: supernova explosion energy
+    :param E_k: initial ejecta kinetic energy
     :param kappa: opacity (used only in dynamics and optical absorption)
     :param kappa_gamma: gamma-ray opacity used to calculate magnetar thermalisation efficiency (used only in dynamics)
     :param q1: low energy spectral index (must be < 2)
@@ -114,7 +115,7 @@ def pwn(time, redshift, mej, l0, tau_sd, nn, eps_b, gamma_b, **kwargs):
     :return: flux density or AB magnitude or dynamics output
     """
     #get parameter values or use defaults
-    E_sn = kwargs.get('E_sn', 1.0e51)
+    E_sn = kwargs.get('E_k', 1.0e51)
     kappa = kwargs.get('kappa', 0.1)
     if 'kappa' in kwargs:
         del kwargs['kappa']
@@ -129,7 +130,8 @@ def pwn(time, redshift, mej, l0, tau_sd, nn, eps_b, gamma_b, **kwargs):
     ejecta_radius = 1.0e11
     epse=1.0-eps_b
     n_ism = 1.0e-5
-    dl = cosmo.luminosity_distance(redshift).cgs.value
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
     pair_cascade_switch = kwargs.get('pair_cascade_switch', False)
     use_r_process = kwargs.get('use_r_process', False)
     nu_M=3.8e22*np.ones(2500)
@@ -421,7 +423,7 @@ def thermal_synchrotron_fluxdensity(time, redshift, logn0, v0, logr0, eta, logep
     :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
+    :return: flux density in mJy
     """
     frequency = kwargs['frequency']
     frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)
@@ -432,7 +434,7 @@ def thermal_synchrotron_fluxdensity(time, redshift, logn0, v0, logr0, eta, logep
     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
+    return flux_density*1.0e26
     
 @citation_wrapper('https://ui.adsabs.harvard.edu/abs/2022MNRAS.511.5328G/abstract')
 def tde_synchrotron(time, redshift, Mej, vej, logepse, logepsb, p, **kwargs):
@@ -516,3 +518,291 @@ def tde_synchrotron(time, redshift, Mej, vej, logepse, logepsb, p, **kwargs):
     else:        
         flux_density = Fvb * ((frequency / vb) ** (-beta1 * s) + (frequency / vb) ** (-beta2 * s)) ** (-1.0 / s)
         return flux_density    
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2007ihea.book.....R/abstract, https://ui.adsabs.harvard.edu/abs/2017hsn..book..875C/abstract')
+def synchrotron_massloss(time, redshift, v_s, log_Mdot_vwind, logepsb, logepse, p, **kwargs):
+    """
+    :param time: time in observer frame in days
+    :param redshift: redshift
+    :param v_s: velocity of the shock (km/s)
+    :param log Mdot_vwind: log10 of the mass loss rate over wind velocity ((solar mass / year)/(km / s))
+    :param logepse: log10 epsilon_e; electron thermalisation efficiency
+    :param logepsb: log10 epsilon_b; magnetic field amplification efficiency
+    :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 cosmology: Cosmology to use for luminosity distance calculation. Defaults to Planck18. Must be a astropy.cosmology object.
+    :return: flux density
+    """
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+    frequency = kwargs['frequency']
+    if isinstance(frequency, float):
+        frequency = np.ones(len(time)) * frequency
+    frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)   
+
+    eps_e = 10.0 ** logepse
+    eps_b = 10.0 ** logepsb
+    v_cgs = v_s * km_cgs
+    t_cgs = time * day_to_s
+    r_s = v_cgs * t_cgs
+    Mdot_vwind = 10.0 ** log_Mdot_vwind    
+    Md_vw_cgs = Mdot_vwind * solar_mass / (day_to_s * 365.24) / km_cgs #g/cm
+    nu_0 = 1.253e19
+   
+    rho_csm = Md_vw_cgs / (4.0 * np.pi * r_s ** 2.0)
+    u_b = eps_b * rho_csm * v_cgs ** 2.0
+    B = np.sqrt(8 * np.pi * u_b)
+    N_0 = 4.0 / 3.0 * np.pi * r_s ** 3.0 * eps_e * rho_csm / proton_mass
+    C_0 = 4.0 / 3.0 * N_0 * sigma_T * speed_of_light * u_b 
+    nu_L = qe * B / (2 * np.pi * electron_mass * speed_of_light)
+
+    L_nu = C_0 / (2.0 * nu_L) * (frequency / nu_L) ** ((1.0 - p) / 2.0) 
+    flux_density = L_nu / (4.0 * np.pi * dl**2) / 1.0e-26
+
+    Fv0 = C_0 / (2.0 * nu_L) / (4.0 * np.pi * dl**2)
+    beta = 1.0 - (1.0 - p) / 2.0
+    nu_ssa = (dl**2 * 3.0**1.5 * qe**0.5 * B**0.5 * Fv0 * nu_L**(beta - 1.0) / (4.0 * np.pi**1.5 * r_s**2 * speed_of_light**0.5 * electron_mass**1.5))**(2.0 / (2.0 * beta + 3.0))
+    Fv_ssa = Fv0 * (nu_ssa / nu_L) ** (1-beta)
+
+    if (np.min(frequency) < np.max(nu_ssa)):
+        msk = (frequency < nu_ssa)
+        flux_density[msk] = Fv_ssa[msk] * (frequency[msk] / nu_ssa[msk]) ** 2.5 / 1.0e-26 
+        
+    return flux_density    
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2007ihea.book.....R/abstract, https://ui.adsabs.harvard.edu/abs/2017hsn..book..875C/abstract')    
+def synchrotron_ism(time, redshift, v_s, logn0, logepsb, logepse, p, **kwargs):  
+    """
+    :param time: time in observer frame in days
+    :param redshift: redshift
+    :param v_s: velocity of the shock (km/s)
+    :param logn0: log10 of the circumburst density (cm^-3)
+    :param logepse: log10 epsilon_e; electron thermalisation efficiency
+    :param logepsb: log10 epsilon_b; magnetic field amplification efficiency
+    :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 cosmology: Cosmology to use for luminosity distance calculation. Defaults to Planck18. Must be a astropy.cosmology object.
+    :return: flux density
+    """
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+    frequency = kwargs['frequency']
+    if isinstance(frequency, float):
+        frequency = np.ones(len(time)) * frequency
+    frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)
+
+    n_ism = 10.0 ** logn0
+    eps_e = 10.0 ** logepse
+    eps_b = 10.0 ** logepsb
+    v_cgs = v_s * km_cgs
+    t_cgs = time * day_to_s
+    r_s = v_cgs * t_cgs
+    nu_0 = 1.253e19
+
+    rho_csm = proton_mass * n_ism
+    u_b = eps_b * rho_csm * v_cgs ** 2.0 
+    B = np.sqrt(8 * np.pi * u_b) 
+    N_0 = 4.0 / 3.0 * np.pi * r_s ** 3.0 * eps_e * n_ism 
+    C_0 = 4.0 / 3.0 * N_0 * sigma_T * speed_of_light * u_b 
+    nu_L = qe * B / (2 * np.pi * electron_mass * speed_of_light)
+
+    L_nu = C_0 / (2.0 * nu_L) * (frequency / nu_L) ** ((1.0 - p) / 2.0)
+    flux_density = L_nu / (4.0 * np.pi * dl**2) / 1.0e-26
+
+    Fv0 = C_0 / (2.0 * nu_L) / (4.0 * np.pi * dl**2)
+    beta = 1.0 - (1.0 - p) / 2.0
+    nu_ssa = (dl**2 * 3.0**1.5 * qe**0.5 * B**0.5 * Fv0 * nu_L**(beta - 1.0) / (4.0 * np.pi**1.5 * r_s**2 * speed_of_light**0.5 * electron_mass**1.5))**(2.0 / (2.0 * beta + 3.0))
+    Fv_ssa = Fv0 * (nu_ssa / nu_L) ** (1-beta)
+
+    if (np.min(frequency) < np.max(nu_ssa)):
+        msk = (frequency < nu_ssa)
+        flux_density[msk] = Fv_ssa[msk] * (frequency[msk] / nu_ssa[msk]) ** 2.5 / 1.0e-26 
+        
+    return flux_density   
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2007ihea.book.....R/abstract, https://ui.adsabs.harvard.edu/abs/2017hsn..book..875C/abstract')    
+def synchrotron_pldensity(time, redshift, v_s, logA, s, logepsb, logepse, p, **kwargs):    
+    """
+    :param time: time in observer frame in days
+    :param redshift: redshift
+    :param v_s: velocity of the shock (km/s)
+    :param logA: log10 of the circumstellar material density at R=1e15 cm (cm^-3)
+    :param s: power law index of the circumstellar material density profile
+    :param logepse: log10 epsilon_e; electron thermalisation efficiency
+    :param logepsb: log10 epsilon_b; magnetic field amplification efficiency
+    :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 cosmology: Cosmology to use for luminosity distance calculation. Defaults to Planck18. Must be a astropy.cosmology object.
+    :return: flux density
+    """
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+    frequency = kwargs['frequency']
+    if isinstance(frequency, float):
+        frequency = np.ones(len(time)) * frequency
+    frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)
+
+    A = 10.0 ** logA
+    eps_e = 10.0 ** logepse
+    eps_b = 10.0 ** logepsb
+    v_cgs = v_s * km_cgs
+    t_cgs = time * day_to_s
+    r_s = v_cgs * t_cgs
+    nu_0 = 1.253e19    
+
+    n_csm = A * (r_s / 1e15) **(-s)
+    rho_csm = n_csm * proton_mass
+    u_b = eps_b * rho_csm * v_cgs ** 2.0
+    B = np.sqrt(8 * np.pi * u_b) 
+    N_0 = 4.0 / 3.0 * np.pi * r_s ** 3.0 * eps_e * n_csm
+    C_0 = 4.0 / 3.0 * N_0 * sigma_T * speed_of_light * u_b
+    nu_L = qe * B / (2 * np.pi * electron_mass * speed_of_light)
+
+    L_nu = C_0 / (2.0 * nu_L) * (frequency / nu_L) ** ((1.0 - p) / 2.0)
+    flux_density = L_nu / (4.0 * np.pi * dl**2) / 1.0e-26
+
+    Fv0 = C_0 / (2.0 * nu_L) / (4.0 * np.pi * dl**2)
+    beta = 1.0 - (1.0 - p) / 2.0
+    nu_ssa = (dl**2 * 3.0**1.5 * qe**0.5 * B**0.5 * Fv0 * nu_L**(beta - 1.0) / (4.0 * np.pi**1.5 * r_s**2 * speed_of_light**0.5 * electron_mass**1.5))**(2.0 / (2.0 * beta + 3.0))
+    Fv_ssa = Fv0 * (nu_ssa / nu_L) ** (1-beta)
+
+    if (np.min(frequency) < np.max(nu_ssa)):
+        msk = (frequency < nu_ssa)
+        flux_density[msk] = Fv_ssa[msk] * (frequency[msk] / nu_ssa[msk]) ** 2.5 / 1.0e-26 
+        
+    return flux_density
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2024ApJ...977..134M/abstract, https://ui.adsabs.harvard.edu/abs/2021ApJ...923L..14M/abstract')     
+def thermal_synchrotron_v2_lnu(time, bG_sh, log_Mdot_vwind, n_ism, logepse, logepsb, xi, p, **kwargs):
+    """
+    :param time: time in source frame in days
+    :param bG_sh: Proper-velocity of the shock (bG_sh = Gamma_sh*beta_sh)
+    :param log Mdot_vwind: log10 of the mass loss rate over wind velocity ((solar mass / year)/(km / s))
+    :param n_ism: the circumburst density of the ISM (cm^-3)
+    :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 mu: mean molecular weight, default is 0.62
+    :param mu_e: mean molecular weight per electron, default is 1.18
+    :param ell_dec: Deceleration parameter defined in eq. (1) of MQ24, default is 1.0
+    :param f: Volume-filling factor defined in eq. (3) of MQ24, default is 3.0/16.0
+    :return: lnu
+    """
+    mu = kwargs.get('mu', 0.62)
+    mu_e = kwargs.get('mu_e', 1.18)
+    ell_dec = kwargs.get('ell_dec', 1.0)
+    f = kwargs.get('f', 3.0/16.0)
+    epsilon_T = 10**logepse
+    epsilon_B = 10**logepsb
+    frequency = kwargs['frequency']  
+    t = time * day_to_s
+    
+    Mdot_vwind = 10.0 ** log_Mdot_vwind    
+    Md_vw_cgs = Mdot_vwind * solar_mass / (day_to_s * 365.24) / km_cgs #g/cm   
+    
+    R = (1.0 + bG_sh**2)**0.5 * bG_sh * speed_of_light * ell_dec * t
+    bG = 0.5 * (bG_sh**2 - 2.0 + (bG_sh**4 + 5.0 * bG_sh**2 + 4.0)**0.5)**0.5
+    Gamma = (1.0 + bG**2)**0.5
+    
+    #total ISM number density is sum of wind and flat density component
+    Mdot_over_vw = 4.0 * np.pi * mu * proton_mass * R**2 * n_ism + Md_vw_cgs
+    n = Md_vw_cgs / (4.0 * np.pi * mu * proton_mass * R**2) + n_ism
+    
+    if Gamma==1:
+        # fix bG << 1 case where numerical accuracy fails
+        Theta = (2.0 / 3.0) * epsilon_T * (9.0 * mu * proton_mass / (32.0 * mu_e * electron_mass)) * ((16.0 / 9.0) * bG**2)
+        Gamma_minus_one = 0.5 * bG**2
+    else:
+        g = (4.0 + Gamma**(-1.0)) / 3.0
+        Theta0 = epsilon_T * ((Gamma - 1.0) * ((g * Gamma + 1.0) / (g - 1.0)) * mu * proton_mass)/(4.0 * Gamma * mu_e * electron_mass)
+        Theta = (5.0 * Theta0 - 6.0 + (25.0 * Theta0**2 + 180.0 * Theta0 + 36.0)**0.5) / 30.0
+        Gamma_minus_one = Gamma - 1.0
+    
+    # prefactor for the luminosity, eq. (B13); Note---with respect to eq. (B13), this definition omits f(Theta), which we instead absorb into I`(x) below.
+    L_tilde = ((4.0 * 2.0**0.5 * qe**3 * mu_e * epsilon_B**0.5 * f / (3.0**0.5 * mu * proton_mass * electron_mass * speed_of_light)) 
+                               * Mdot_over_vw**1.5 * Gamma**1.5 * Gamma_minus_one**0.5)
+                               
+    # prefactor for the optical-depth, eq. (B14); Note---with respect to eq. (B13), this definition omits f(Theta), which we instead absorb into I`(x) below.                           
+    tau_Theta = ((2.0**0.5 * qe * mu_e * f / (3.0**2.5 * mu * proton_mass * speed_of_light * epsilon_B**0.5))
+                               * Mdot_over_vw**0.5 * Theta**(-5.0) * Gamma**(-0.5) * Gamma_minus_one**(-0.5))                           
+                               
+    # post-shock magnetic field
+    B = (8.0 * epsilon_B * Mdot_over_vw * Gamma * Gamma_minus_one )**0.5 / ((1.0 + bG_sh**2)**0.5 *bG_sh * t)
+    # thermal synchrotron frequeny (in observer frame)
+    nu_T = 3.0 * Gamma * Theta**2 * qe * B / (4.0 * np.pi * electron_mass * speed_of_light)
+    x = frequency / nu_T
+    
+    aa = (6.0 + 15.0 * Theta) / (4.0 + 5.0 * Theta)
+    gamma_m = 1.0 + aa * Theta
+    
+    # the relative fraction of power-law to thermal electron energy densities
+    delta = xi/epsilon_T
+    # coefficient that multiplies power-law term in square-brackets in eq. (B10)
+    a = (8.0 * np.pi / 3.0**0.5) *_c_j(p) * delta * _g_theta(Theta, p=p)
+    # coefficient that multiplies power-law term in square-brackets in eq. (B11)
+    b = (3.0**1.5 / np.pi) *_c_alpha(p) * delta * _g_theta(Theta, p=p)    
+    
+    # include low-frequeny corrections to the coefficients `a` and `b` defied above (see e.g. low_freq_jpl_correction function for more information)
+    a_corr = _low_freq_jpl_correction(x, Theta, p)
+    b_corr = _low_freq_apl_correction(x, Theta, p) 
+      
+    # an estimate of the Lorentz factor above which electrons cool quickly
+    gamma_cool = 6.0 * np.pi * electron_mass * speed_of_light / (sigma_T * B**2 * Gamma * t)
+    # the Lorentz factor of thermal electrons contributing most to emission at frequency x
+    gamma_th = Theta * np.maximum(1.0, (2.0 * x)**(1.0 / 3.0))
+    # the Lorentz factor of power-law electrons contributing most to emission at frequency x
+    gamma_pl = np.maximum(gamma_m, Theta * x**0.5)
+    # correction terms for fast-cooling regime
+    cooling_correction_th = np.minimum(1.0, gamma_cool / gamma_th)
+    cooling_correction_pl = np.minimum(1.0, gamma_cool / gamma_pl)
+    
+    I_of_x = 4.0505 * x**(-1.0 / 6.0) * (1.0 + 0.40 * x**(-0.25) + 0.5316 * x**(-0.5)) * np.exp(-1.8899 * x**(1.0 / 3.0))
+    f_fun = 2.0 * Theta**2 / special.kn(2 , 1.0 / Theta)
+    I = I_of_x*f_fun
+    I[np.isnan(I)+np.isinf(I)] = 0.0
+    
+    # calculate the optical depth (eq. B11)
+    tau = tau_Theta *((I / x) * cooling_correction_th + b * x**(-0.5 * (p + 4.0)) * b_corr * cooling_correction_pl)
+    tau_fun = np.ones_like(tau)
+    tau_fun[tau > 1e-9] = (1.0 - np.exp(-tau[tau > 1e-9]) )/tau[tau > 1e-9]
+    
+    # calculate the specific luminosity (eq. B10)
+    L_nu = L_tilde * (x * I * cooling_correction_th + a * x**(-0.5*(p - 1.0)) * a_corr * cooling_correction_pl) * tau_fun    
+    return L_nu
+
+@citation_wrapper('https://ui.adsabs.harvard.edu/abs/2024ApJ...977..134M/abstract, https://ui.adsabs.harvard.edu/abs/2021ApJ...923L..14M/abstract')     
+def thermal_synchrotron_v2_fluxdensity(time, redshift, bG_sh, log_Mdot_vwind, n_ism, logepse, logepsb, xi, p, **kwargs):
+    """
+    :param time: time in source frame in days
+    :param redshift: redshift
+    :param bG_sh: Proper-velocity of the shock (bG_sh = Gamma_sh*beta_sh)
+    :param log Mdot_vwind: log10 of the mass loss rate over wind velocity ((solar mass / year)/(km / s))
+    :param n_ism: the circumburst density of the ISM (cm^-3)
+    :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 mu: mean molecular weight, default is 0.62
+    :param mu_e: mean molecular weight per electron, default is 1.18
+    :param ell_dec: Deceleration parameter defined in eq. (1) of MQ24, default is 1.0
+    :param f: Volume-filling factor defined in eq. (3) of MQ24, default is 3.0/16.0
+    :param cosmology: Cosmology to use for luminosity distance calculation. Defaults to Planck18. Must be a astropy.cosmology object.
+    :return: flux density in mJy
+    """
+    frequency = kwargs['frequency']
+    frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)
+    new_kwargs = kwargs.copy()
+    new_kwargs['frequency'] = frequency
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+    lnu = thermal_synchrotron_v2_lnu(time, bG_sh, log_Mdot_vwind, n_ism, logepse, logepsb, xi, p, **new_kwargs)
+    flux_density = lnu / (4.0 * np.pi * dl**2)/1.0e-26
+    return flux_density           

redback/transient_models/phenomenological_models.py

@@ -1,21 +1,153 @@
 import numpy as np
 from redback.utils import citation_wrapper
+from redback.constants import speed_of_light_si
+
+
+def exp_rise_powerlaw_decline(t, t0, m_peak, tau_rise, alpha, t_peak, **kwargs):
+    """
+    Compute a smooth light-curve model (in magnitudes) with an exponential rise
+    transitioning into a power-law decline, with a smooth (blended) peak.
+    In all filters the shape is determined by the same t0, tau_rise, alpha, and t_peak;
+    only m_peak differs from filter to filter.
+
+    For t < t0, the function returns np.nan.
+    For t >= t0, the model is constructed as a blend of:
+
+      Rising phase:
+          m_rise(t)  = m_peak + 1.086 * ((t_peak - t) / tau_rise)
+      Declining phase:
+          m_decline(t) = m_peak + 2.5 * alpha * log10((t - t0)/(t_peak - t0))
+
+    A smooth transition is achieved by the switching (weight) function:
+
+          weight(t) = 0.5 * [1 + tanh((t - t_peak)/delta)]
+
+    so that the final magnitude is:
+
+          m(t) = (1 - weight(t)) * m_rise(t) + weight(t) * m_decline(t)
+
+    At t = t_peak, weight = 0.5 and both m_rise and m_decline equal m_peak,
+    ensuring a smooth peak.
+
+    Parameters
+    ----------
+    t : array_like
+        1D array of times (e.g., in modified Julian days) at which to evaluate the model.
+    t0 : float
+        Start time of the transient event (e.g., explosion), in MJD.
+    m_peak : float or array_like
+        Peak magnitude(s) at t = t_peak. If an array is provided, each element is taken
+        to correspond to a different filter.
+    tau_rise : float
+        Characteristic timescale (in days) for the exponential rise.
+    alpha : float
+        Power-law decay index governing the decline.
+    t_peak : float
+        Time (in MJD) at peak brightness (must satisfy t_peak > t0).
+    delta : float, optional
+        Smoothing parameter (in days) controlling the width of the transition around t_peak.
+        If not provided, defaults to 50% of (t_peak - t0).
+
+    Returns
+    -------
+    m_model : ndarray
+        If m_peak is an array (multiple filters), returns a 2D array of shape (n_times, n_filters);
+        if m_peak is a scalar, returns a 1D array (with NaN for t < t0).
+
+    Examples
+    --------
+    Single filter:
+
+    >>> t = np.linspace(58990, 59050, 300)
+    >>> model1 = exp_rise_powerlaw_decline(t, t0=59000, m_peak=17.0, tau_rise=3.0,
+    ...                                     alpha=1.5, t_peak=59010)
+
+    Multiple filters (e.g., g, r, i bands):
+
+    >>> t = np.linspace(58990, 59050, 300)
+    >>> m_peaks = np.array([17.0, 17.5, 18.0])
+    >>> model_multi = exp_rise_powerlaw_decline(t, t0=59000, m_peak=m_peaks, tau_rise=3.0,
+    ...                                          alpha=1.5, t_peak=59010)
+    >>> print(model_multi.shape)  # Expected shape: (300, 3)
+    """
+    # Convert t to a numpy array and force 1D.
+    t = np.asarray(t).flatten()
+    delta = kwargs.get('delta', 0.5)
+
+    # Define default smoothing parameter delta if not provided.
+    #     if delta is None:
+    delta = (t_peak - t0) * delta  # default: 50% of the interval [t0, t_peak]
+
+    # Ensure m_peak is at least 1D (so a scalar becomes an array of length 1).
+    m_peak = np.atleast_1d(m_peak)
+    n_filters = m_peak.shape[0]
+    n_times = t.shape[0]
+
+    # Preallocate model magnitude array with shape (n_times, n_filters)
+    m_model = np.full((n_times, n_filters), np.nan, dtype=float)
+
+    # Create a mask for times t >= t0.
+    valid = t >= t0
+    # Reshape t into a column vector for broadcasting: shape (n_times, 1)
+    t_col = t.reshape(-1, 1)
+
+    # Compute the switching (weight) function: weight = 0 when t << t_peak, 1 when t >> t_peak.
+    weight = 0.5 * (1 + np.tanh((t_col - t_peak) / delta))
+
+    # Rising phase model: for t < t_peak the flux is rising toward peak.
+    # m_rise = m_peak + 1.086 * ((t_peak - t) / tau_rise)
+    m_rise = m_peak[None, :] + 1.086 * ((t_peak - t_col) / tau_rise)
+
+    # Declining phase model: power-law decline in flux gives a logarithmic increase in magnitude.
+    # m_decline = m_peak + 2.5 * alpha * log10((t - t0)/(t_peak - t0))
+    ratio = (t_col - t0) / (t_peak - t0)
+    m_decline = m_peak[None, :] + 2.5 * alpha * np.log10(ratio)
+
+    # Blend the two components using the switching weight.
+    # For t << t_peak, tanh term ≈ -1 so weight ~ 0 and m ~ m_rise.
+    # For t >> t_peak, tanh term ≈ +1 so weight ~ 1 and m ~ m_decline.
+    m_blend = (1 - weight) * m_rise + weight * m_decline
+
+    # Update m_model for valid times (t >= t0). For t < t0, m_model remains NaN.
+    m_model[valid, :] = m_blend[valid, :]
+
+    # If m_peak was given as a scalar, return a 1D array.
+    if n_filters == 1:
+        return m_model.flatten()
+    return m_model
 
 @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
+    Bazin function for CCSN light curves with vectorized inputs.
 
     :param time: time array in arbitrary units
-    :param aa: Normalisation on the Bazin function
-    :param bb: Additive constant
+    :param aa: array (or float) of normalisations, if array this is unique to each 'band'
+    :param bb: array (or float) of additive constants, if array this is unique to each 'band'
     :param t0: start time
     :param tau_rise: exponential rise time
     :param tau_fall: exponential fall time
-    :return: flux in units set by AA
+    :return: matrix of flux values in units set by AA
     """
-    flux = aa * np.exp(-((time - t0) / tau_fall) / (1 + np.exp(-(time - t0) / tau_rise))) + bb
-    return flux
+    if isinstance(aa, float):
+        aa_values = [aa]
+        bb_values = [bb]
+    else:
+        aa_values = aa
+        bb_values = bb
+
+    if len(aa_values) != len(bb_values):
+        raise ValueError("Length of aa_values and bb_values must be the same.")
+
+    # Compute flux for all aa and bb values
+    flux_matrix = np.array([
+        aa * (np.exp(-((time - t0) / tau_fall)) / (1 + np.exp(-(time - t0) / tau_rise))) + bb
+        for aa, bb in zip(aa_values, bb_values)
+    ])
+    if isinstance(aa, float):
+        return flux_matrix[0]
+    else:
+        return flux_matrix
 
 @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):
@@ -25,7 +157,7 @@ def villar_sne(time, aa, cc, t0, tau_rise, tau_fall, gamma, nu, **kwargs):
     :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 t0: "start" time
     :param tau_rise: exponential rise time
     :param tau_fall: exponential fall time
     :param gamma: plateau duration
@@ -68,6 +200,21 @@ def line_spectrum(wavelength, line_amp, cont_amp, x0, **kwargs):
     spectrum = line_amp / cont_amp * np.exp(-(wavelength - x0) ** 2. / (2 * cont_amp ** 2) )
     return spectrum
 
+def line_spectrum_with_velocity_dispersion(angstroms, wavelength_center, line_strength, velocity_dispersion):
+    """
+    A Gaussian line profile with velocity dispersion
+
+    :param angstroms: wavelength array in angstroms or arbitrary units
+    :param wavelength_center: center of the line in angstroms
+    :param line_strength: line amplitude scale
+    :param velocity_dispersion: velocity in m/s
+    :return: spectrum in whatever units set by line_strength
+    """
+
+    # Calculate the Doppler shift for each wavelength using Gaussian profile
+    intensity = line_strength * np.exp(-0.5 * ((angstroms - wavelength_center) / wavelength_center * speed_of_light_si / velocity_dispersion) ** 2)
+    return intensity
+
 def gaussian_rise(time, a_1, peak_time, sigma_t, **kwargs):
     """
     :param time: time array in whatver time units