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

redback/transient_models/phase_models.py

@@ -53,15 +53,20 @@ def t0_base_model(time, t0, **kwargs):
     return output
 
 
-def _t0_with_extinction(time, t0, av, model_type='supernova', **kwargs):
+def _t0_with_extinction(time, t0, av_host, model_type='supernova', **kwargs):
     """
     :param time: time in mjd
     :param t0: start time in mjd
-    :param av: absolute mag extinction
-    :param model_type: what type of transient extinction function to use
-    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model']
-        and r_v, default is 3.1
-    :return: flux_density or magnitude depending on kwargs['output_format']
+    :param av_host: V-band extinction from host galaxy in magnitudes
+    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model'] plus:
+        - redshift: source redshift (required)
+        - av_mw: MW V-band extinction in magnitudes (default 0.0)
+        - rv_host: host R_V parameter (default 3.1)
+        - rv_mw: MW R_V parameter (default 3.1)
+        - host_law: host extinction law (default 'fitzpatrick99')
+        - mw_law: MW extinction law (default 'fitzpatrick99')
+        Available extinction laws: 'fitzpatrick99', 'fm07', 'calzetti00', 'odonnell94', 'ccm89'
+    :return: flux_density or magnitude depending on kwargs['output_format'] with extinction applied
     """
     output = namedtuple('output', ['time', 'observable'])
     function = extinction_model_functions[model_type]
@@ -70,7 +75,7 @@ def _t0_with_extinction(time, t0, av, model_type='supernova', **kwargs):
     time = (time - t0).to(uu.day).value
     transient_time = time[time >= 0.0]
     bad_time = time[time < 0.0]
-    output_real = function(transient_time, av=av, **kwargs)
+    output_real = function(transient_time, av_host=av_host, **kwargs)
     if kwargs['output_format'] == 'magnitude':
         output_fake = np.zeros(len(bad_time)) + 5000
     else:
@@ -80,83 +85,132 @@ def _t0_with_extinction(time, t0, av, model_type='supernova', **kwargs):
     return output
 
 @citation_wrapper('redback')
-def t0_afterglow_extinction(time, t0, av, **kwargs):
+def t0_afterglow_extinction(time, t0, av_host, **kwargs):
     """
+    Afterglow model with t0 parameter and host/MW extinction
+
     :param time: time in mjd
     :param t0: start time in mjd
-    :param av: absolute mag extinction
-    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model']
-        and r_v, default is 3.1
-    :return: flux_density or magnitude depending on kwargs['output_format']
+    :param av_host: V-band extinction from host galaxy in magnitudes
+    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model'] plus:
+        - redshift: source redshift (required)
+        - av_mw: MW V-band extinction in magnitudes (default 0.0)
+        - rv_host: host R_V parameter (default 3.1)
+        - rv_mw: MW R_V parameter (default 3.1)
+        - host_law: host extinction law (default 'fitzpatrick99')
+        - mw_law: MW extinction law (default 'fitzpatrick99')
+        Available extinction laws: 'fitzpatrick99', 'fm07', 'calzetti00', 'odonnell94', 'ccm89'
+    :return: flux_density or magnitude depending on kwargs['output_format'] with extinction applied
     """
-    summary = _t0_with_extinction(time=time, t0=t0, av=av, model_type='afterglow', **kwargs)
+    summary = _t0_with_extinction(time=time, t0=t0, av_host=av_host, model_type='afterglow', **kwargs)
     return summary.observable
 
 @citation_wrapper('redback')
-def t0_supernova_extinction(time, t0, av, **kwargs):
+def t0_supernova_extinction(time, t0, av_host, **kwargs):
     """
+    Supernova model with t0 parameter and host/MW extinction
+
     :param time: time in mjd
     :param t0: start time in mjd
-    :param av: absolute mag extinction
-    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model']
-        and r_v, default is 3.1
-    :return: flux_density or magnitude depending on kwargs['output_format']
+    :param av_host: V-band extinction from host galaxy in magnitudes
+    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model'] plus:
+        - redshift: source redshift (required)
+        - av_mw: MW V-band extinction in magnitudes (default 0.0)
+        - rv_host: host R_V parameter (default 3.1)
+        - rv_mw: MW R_V parameter (default 3.1)
+        - host_law: host extinction law (default 'fitzpatrick99')
+        - mw_law: MW extinction law (default 'fitzpatrick99')
+        Available extinction laws: 'fitzpatrick99', 'fm07', 'calzetti00', 'odonnell94', 'ccm89'
+    :return: flux_density or magnitude depending on kwargs['output_format'] with extinction applied
     """
-    summary = _t0_with_extinction(time=time, t0=t0, av=av, model_type='supernova', **kwargs)
+    summary = _t0_with_extinction(time=time, t0=t0, av_host=av_host, model_type='supernova', **kwargs)
     return summary.observable
 
 @citation_wrapper('redback')
-def t0_kilonova_extinction(time, t0, av, **kwargs):
+def t0_kilonova_extinction(time, t0, av_host, **kwargs):
     """
+    Kilonova model with t0 parameter and host/MW extinction
+
     :param time: time in mjd
     :param t0: start time in mjd
-    :param av: absolute mag extinction
-    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model']
-        and r_v, default is 3.1
-    :return: flux_density or magnitude depending on kwargs['output_format']
+    :param av_host: V-band extinction from host galaxy in magnitudes
+    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model'] plus:
+        - redshift: source redshift (required)
+        - av_mw: MW V-band extinction in magnitudes (default 0.0)
+        - rv_host: host R_V parameter (default 3.1)
+        - rv_mw: MW R_V parameter (default 3.1)
+        - host_law: host extinction law (default 'fitzpatrick99')
+        - mw_law: MW extinction law (default 'fitzpatrick99')
+        Available extinction laws: 'fitzpatrick99', 'fm07', 'calzetti00', 'odonnell94', 'ccm89'
+    :return: flux_density or magnitude depending on kwargs['output_format'] with extinction applied
     """
-    summary = _t0_with_extinction(time=time, t0=t0, av=av, model_type='kilonova', **kwargs)
+    summary = _t0_with_extinction(time=time, t0=t0, av_host=av_host, model_type='kilonova', **kwargs)
     return summary.observable
 
 @citation_wrapper('redback')
-def t0_tde_extinction(time, t0, av, **kwargs):
+def t0_tde_extinction(time, t0, av_host, **kwargs):
     """
+    TDE model with t0 parameter and host/MW extinction
+
     :param time: time in mjd
     :param t0: start time in mjd
-    :param av: absolute mag extinction
-    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model']
-        and r_v, default is 3.1
-    :return: flux_density or magnitude depending on kwargs['output_format']
+    :param av_host: V-band extinction from host galaxy in magnitudes
+    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model'] plus:
+        - redshift: source redshift (required)
+        - av_mw: MW V-band extinction in magnitudes (default 0.0)
+        - rv_host: host R_V parameter (default 3.1)
+        - rv_mw: MW R_V parameter (default 3.1)
+        - host_law: host extinction law (default 'fitzpatrick99')
+        - mw_law: MW extinction law (default 'fitzpatrick99')
+        - peak_time_mjd: peak time in mjd (if provided, will be converted to peak_time relative to t0)
+        Available extinction laws: 'fitzpatrick99', 'fm07', 'calzetti00', 'odonnell94', 'ccm89'
+    :return: flux_density or magnitude depending on kwargs['output_format'] with extinction applied
     """
     if 'peak_time_mjd' in kwargs:
         kwargs['peak_time'] = kwargs['peak_time_mjd'] - t0
-    summary = _t0_with_extinction(time=time, t0=t0, av=av, model_type='tde', **kwargs)
+    summary = _t0_with_extinction(time=time, t0=t0, av_host=av_host, model_type='tde', **kwargs)
     return summary.observable
 
 @citation_wrapper('redback')
-def t0_magnetar_driven_extinction(time, t0, av, **kwargs):
+def t0_magnetar_driven_extinction(time, t0, av_host, **kwargs):
     """
+    Magnetar-driven model with t0 parameter and host/MW extinction
+
     :param time: time in mjd
     :param t0: start time in mjd
-    :param av: absolute mag extinction
-    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model']
-        and r_v, default is 3.1
-    :return: flux_density or magnitude depending on kwargs['output_format']
+    :param av_host: V-band extinction from host galaxy in magnitudes
+    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model'] plus:
+        - redshift: source redshift (required)
+        - av_mw: MW V-band extinction in magnitudes (default 0.0)
+        - rv_host: host R_V parameter (default 3.1)
+        - rv_mw: MW R_V parameter (default 3.1)
+        - host_law: host extinction law (default 'fitzpatrick99')
+        - mw_law: MW extinction law (default 'fitzpatrick99')
+        Available extinction laws: 'fitzpatrick99', 'fm07', 'calzetti00', 'odonnell94', 'ccm89'
+    :return: flux_density or magnitude depending on kwargs['output_format'] with extinction applied
     """
-    summary = _t0_with_extinction(time=time, t0=t0, av=av, model_type='magnetar_driven', **kwargs)
+    summary = _t0_with_extinction(time=time, t0=t0, av_host=av_host, model_type='magnetar_driven', **kwargs)
     return summary.observable
 
 @citation_wrapper('redback')
-def t0_shock_powered_extinction(time, t0, av, **kwargs):
+def t0_shock_powered_extinction(time, t0, av_host, **kwargs):
     """
+    Shock-powered model with t0 parameter and host/MW extinction
+
     :param time: time in mjd
     :param t0: start time in mjd
-    :param av: absolute mag extinction
-    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model']
-        and r_v, default is 3.1
-    :return: flux or magnitude depending on kwargs['output_format']
+    :param av_host: V-band extinction from host galaxy in magnitudes
+    :param kwargs: Must be all the parameters required by the base_model specified using kwargs['base_model'] plus:
+        - redshift: source redshift (required)
+        - av_mw: MW V-band extinction in magnitudes (default 0.0)
+        - rv_host: host R_V parameter (default 3.1)
+        - rv_mw: MW R_V parameter (default 3.1)
+        - host_law: host extinction law (default 'fitzpatrick99')
+        - mw_law: MW extinction law (default 'fitzpatrick99')
+        Available extinction laws: 'fitzpatrick99', 'fm07', 'calzetti00', 'odonnell94', 'ccm89'
+    :return: flux_density or magnitude depending on kwargs['output_format'] with extinction applied
     """
-    summary = _t0_with_extinction(time=time, t0=t0, av=av, model_type='shock_powered', **kwargs)
+    summary = _t0_with_extinction(time=time, t0=t0, av_host=av_host, model_type='shock_powered', **kwargs)
     return summary.observable
 
 @citation_wrapper('https://ui.adsabs.harvard.edu/abs/2021arXiv210601556S/abstract')

redback/transient_models/phenomenological_models.py

@@ -3,6 +3,33 @@ from redback.utils import citation_wrapper
 from redback.constants import speed_of_light_si
 
 
+def smooth_exponential_powerlaw(time, a_1, tpeak, alpha_1, alpha_2, smoothing_factor, **kwargs):
+    """
+    Smoothed version of exponential power law
+
+    :param time: time array in seconds
+    :param a_1: exponential amplitude scale
+    :param alpha_1: first exponent
+    :param alpha_2: second exponent
+    :param tpeak: peak time in seconds
+    :param smoothing_factor: controls transition smoothness (higher = smoother)
+    :param kwargs: Additional parameters
+    :return: In whatever units set by a_1
+    """
+    t_norm = time / tpeak
+
+    # Smooth transition function using tanh or similar
+    transition = 0.5 * (1 + np.tanh(smoothing_factor * np.log(t_norm)))
+
+    # Pre-peak behavior
+    pre_peak = a_1 * (t_norm ** alpha_1)
+
+    # Post-peak behavior
+    post_peak = a_1 * (t_norm ** alpha_2)
+
+    # Smooth combination
+    return pre_peak * (1 - transition) + post_peak * transition
+
 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
@@ -173,6 +200,151 @@ def villar_sne(time, aa, cc, t0, tau_rise, tau_fall, gamma, nu, **kwargs):
     flux[mask2] = norm[mask2] * ((1 - nu) * np.exp(-((time[mask2] - t0 - gamma)/tau_fall)))
     return np.concatenate((flux[mask1], flux[mask2]))
 
+
+def powerlaw_plus_blackbody(time, redshift, pl_amplitude, pl_slope, pl_evolution_index, temperature_0, radius_0,
+                            temp_rise_index, temp_decline_index, temp_peak_time,
+                            radius_rise_index, radius_decline_index, radius_peak_time,
+                            reference_time=1.0, **kwargs):
+    """
+    Power law + blackbody spectrum with piecewise evolving temperature and radius
+
+    :param time: time in observer frame in days
+    :param redshift: source redshift
+    :param pl_amplitude: power law amplitude at reference wavelength at reference_time (erg/s/cm^2/Angstrom)
+    :param pl_slope: power law slope (F_lambda ∝ lambda^slope)
+    :param pl_evolution_index: power law time evolution F_pl(t) ∝ t^(-pl_evolution_index)
+    :param temperature_0: initial blackbody temperature in Kelvin at reference_time
+    :param radius_0: initial blackbody radius in cm at reference_time
+    :param temp_rise_index: temperature rise T(t) ∝ t^temp_rise_index for t < temp_peak_time
+    :param temp_decline_index: temperature decline T(t) ∝ t^(-temp_decline_index) for t > temp_peak_time
+    :param temp_peak_time: time in days when temperature peaks
+    :param radius_rise_index: radius rise R(t) ∝ t^radius_rise_index for t < radius_peak_time
+    :param radius_decline_index: radius decline R(t) ∝ t^(-radius_decline_index) for t > radius_peak_time
+    :param radius_peak_time: time in days when radius peaks
+    :param reference_time: reference time for temperature_0, radius_0, and pl_amplitude in days (defaults to 1.0)
+    :param kwargs: Additional parameters
+    :param reference_wavelength: wavelength for power law amplitude normalization in Angstroms (default 5000)
+    :param frequency: Required if output_format is 'flux_density'
+    :param bands: Required if output_format is 'magnitude' or 'flux'
+    :param output_format: 'flux_density', 'magnitude', 'spectra', 'flux', 'sncosmo_source'
+    :param lambda_array: Optional wavelength array in Angstroms to evaluate SED
+    :param cosmology: Cosmology object for luminosity distance calculation
+    :return: set by output format - 'flux_density', 'magnitude', 'spectra', 'flux', 'sncosmo_source'
+    """
+    from astropy.cosmology import Planck18 as cosmo
+    from astropy import units as uu
+    from redback.utils import lambda_to_nu, calc_kcorrected_properties
+    import redback.sed as sed
+    from collections import namedtuple
+
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+    reference_wavelength = kwargs.get('reference_wavelength', 5000.0)  # Angstroms
+
+    if kwargs['output_format'] == 'flux_density':
+        frequency = kwargs['frequency']
+        frequency, time = calc_kcorrected_properties(frequency=frequency, redshift=redshift, time=time)
+
+        # Calculate evolving temperature and radius
+        temperature, radius = _powerlaw_blackbody_evolution(time=time, temperature_0=temperature_0, radius_0=radius_0,
+                                                            temp_rise_index=temp_rise_index,
+                                                            temp_decline_index=temp_decline_index,
+                                                            temp_peak_time=temp_peak_time,
+                                                            radius_rise_index=radius_rise_index,
+                                                            radius_decline_index=radius_decline_index,
+                                                            radius_peak_time=radius_peak_time,
+                                                            reference_time=reference_time)
+
+        # Create combined SED with time-evolving power law
+        sed_combined = sed.PowerlawPlusBlackbody(temperature=temperature, r_photosphere=radius,
+                                                 pl_amplitude=pl_amplitude, pl_slope=pl_slope,
+                                                 pl_evolution_index=pl_evolution_index, time=time,
+                                                 reference_wavelength=reference_wavelength,
+                                                 frequency=frequency, luminosity_distance=dl)
+        flux_density = sed_combined.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)
+
+        # Calculate evolving temperature and radius
+        temperature, radius = _powerlaw_blackbody_evolution(time=time, temperature_0=temperature_0, radius_0=radius_0,
+                                                            temp_rise_index=temp_rise_index,
+                                                            temp_decline_index=temp_decline_index,
+                                                            temp_peak_time=temp_peak_time,
+                                                            radius_rise_index=radius_rise_index,
+                                                            radius_decline_index=radius_decline_index,
+                                                            radius_peak_time=radius_peak_time,
+                                                            reference_time=reference_time)
+
+        # Create combined SED with time-evolving power law
+        sed_combined = sed.PowerlawPlusBlackbody(temperature=temperature, r_photosphere=radius,
+                                                 pl_amplitude=pl_amplitude, pl_slope=pl_slope,
+                                                 pl_evolution_index=pl_evolution_index, time=time,
+                                                 reference_wavelength=reference_wavelength,
+                                                 frequency=frequency[:, None], luminosity_distance=dl)
+        fmjy = sed_combined.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)
+
+
+def _powerlaw_blackbody_evolution(time, temperature_0, radius_0, temp_rise_index, temp_decline_index,
+                                  temp_peak_time, radius_rise_index, radius_decline_index, radius_peak_time,
+                                  reference_time=1.0, **kwargs):
+    """
+    Calculate evolving temperature and radius with piecewise power-law evolution
+
+    :param time: time array in days
+    :param temperature_0: initial temperature at reference_time
+    :param radius_0: initial radius at reference_time
+    :param temp_rise_index: temperature rise index
+    :param temp_decline_index: temperature decline index
+    :param temp_peak_time: time when temperature peaks
+    :param radius_rise_index: radius rise index
+    :param radius_decline_index: radius decline index
+    :param radius_peak_time: time when radius peaks
+    :param reference_time: reference time for temperature_0 and radius_0 (defaults to 1.0 day)
+    :return: temperature and radius values (scalars if time is scalar)
+    """
+    time = np.atleast_1d(time)
+
+    # Temperature evolution
+    temp_peak = temperature_0 * (temp_peak_time / reference_time) ** temp_rise_index
+    rise_mask_temp = time <= temp_peak_time
+    decline_mask_temp = ~rise_mask_temp
+
+    temperature = np.zeros_like(time)
+    temperature[rise_mask_temp] = temperature_0 * (time[rise_mask_temp] / reference_time) ** temp_rise_index
+    temperature[decline_mask_temp] = temp_peak * (time[decline_mask_temp] / temp_peak_time) ** (-temp_decline_index)
+
+    # Radius evolution
+    radius_peak = radius_0 * (radius_peak_time / reference_time) ** radius_rise_index
+    rise_mask_radius = time <= radius_peak_time
+    decline_mask_radius = ~rise_mask_radius
+
+    radius = np.zeros_like(time)
+    radius[rise_mask_radius] = radius_0 * (time[rise_mask_radius] / reference_time) ** radius_rise_index
+    radius[decline_mask_radius] = radius_peak * (time[decline_mask_radius] / radius_peak_time) ** (
+        -radius_decline_index)
+
+    # Return scalars if input was scalar
+    if len(time) == 1:
+        return temperature[0], radius[0]
+    else:
+        return temperature, radius
+
 def fallback_lbol(time, logl1, tr, **kwargs):
     """
     :param time: time in seconds

redback/transient_models/spectral_models.py

@@ -80,3 +80,104 @@ def blackbody_spectrum_with_absorption_and_emission_lines(angstroms, redshift,
     fp1 = pm.line_spectrum_with_velocity_dispersion(angstroms, lc1, ls1, v1)
     fp2 = pm.line_spectrum_with_velocity_dispersion(angstroms, lc2, ls2, v2)
     return flux + fp1 - fp2
+
+def blackbody_spectrum_at_z(angstroms, redshift, rph, temp, **kwargs):
+    """
+    A blackbody spectrum at a given redshift, properly accounting for redshift effects.
+
+    :param angstroms: wavelength array in angstroms in obs frame
+    :param redshift: redshift
+    :param rph: photosphere radius in cm (rest frame)
+    :param temp: photosphere temperature in Kelvin (rest frame)
+    :return: flux in ergs/s/cm^2/angstrom in obs frame
+    """
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+
+    # Convert observed wavelengths to rest frame
+    angstroms_rest = angstroms / (1 + redshift)
+
+    # Calculate blackbody in rest frame
+    flux_rest = _get_blackbody_spectrum(angstrom=angstroms_rest, distance=dl,
+                                        r_photosphere=rph, temperature=temp)
+
+    # Apply redshift corrections:
+    # - Surface brightness dimming: factor of (1+z)
+    # - Wavelength interval stretching: dλ_obs = dλ_rest × (1+z)
+    # Combined effect: divide by (1+z)
+    flux_obs = flux_rest / (1 + redshift)
+
+    return flux_obs
+
+def powerlaw_plus_blackbody_spectrum_at_z(angstroms, redshift, pl_amplitude, pl_slope, pl_evolution_index,
+                                          temperature_0, radius_0, temp_rise_index, temp_decline_index,
+                                          temp_peak_time, radius_rise_index, radius_decline_index,
+                                          radius_peak_time, time, **kwargs):
+    """
+    A powerlaw + blackbody spectrum at a given redshift and time, properly accounting for redshift effects.
+
+    :param angstroms: wavelength array in angstroms in obs frame
+    :param redshift: source redshift
+    :param pl_amplitude: power law amplitude at reference wavelength at t=1 day (erg/s/cm^2/Angstrom)
+    :param pl_slope: power law slope (F_lambda ∝ lambda^slope)
+    :param pl_evolution_index: power law time evolution F_pl(t) ∝ t^(-pl_evolution_index)
+    :param temperature_0: initial blackbody temperature in Kelvin at t=1 day (rest frame)
+    :param radius_0: initial blackbody radius in cm at t=1 day (rest frame)
+    :param temp_rise_index: temperature rise T(t) ∝ t^temp_rise_index for t < temp_peak_time
+    :param temp_decline_index: temperature decline T(t) ∝ t^(-temp_decline_index) for t > temp_peak_time
+    :param temp_peak_time: time in days when temperature peaks
+    :param radius_rise_index: radius rise R(t) ∝ t^radius_rise_index for t < radius_peak_time
+    :param radius_decline_index: radius decline R(t) ∝ t^(-radius_decline_index) for t > radius_peak_time
+    :param radius_peak_time: time in days when radius peaks
+    :param time: time in observer frame in days
+    :param kwargs: Additional parameters
+    :param reference_wavelength: wavelength for power law amplitude normalization in Angstroms (default 5000)
+    :param cosmology: Cosmology object for luminosity distance calculation
+    :return: flux in ergs/s/cm^2/angstrom in obs frame
+    """
+    cosmology = kwargs.get('cosmology', cosmo)
+    dl = cosmology.luminosity_distance(redshift).cgs.value
+    reference_wavelength = kwargs.get('reference_wavelength', 5000.0)  # Angstroms
+
+    # Convert observed wavelengths to rest frame
+    angstroms_rest = angstroms / (1 + redshift)
+
+    # Convert observed time to rest frame
+    time_rest = time / (1 + redshift)
+
+    # Convert wavelengths to frequencies for the SED calculation
+    frequency_rest = lambda_to_nu(wavelength=angstroms_rest)
+
+    # Calculate evolving temperature and radius at this time
+    temperature, radius = pm._powerlaw_blackbody_evolution(time=time_rest, temperature_0=temperature_0, radius_0=radius_0,
+                                                           temp_rise_index=temp_rise_index,
+                                                           temp_decline_index=temp_decline_index,
+                                                           temp_peak_time=temp_peak_time,
+                                                           radius_rise_index=radius_rise_index,
+                                                           radius_decline_index=radius_decline_index,
+                                                           radius_peak_time=radius_peak_time)
+
+    # Create combined SED in rest frame
+    sed_combined = sed.PowerlawPlusBlackbody(temperature=temperature, r_photosphere=radius,
+                                         pl_amplitude=pl_amplitude, pl_slope=pl_slope,
+                                         pl_evolution_index=pl_evolution_index, time=time_rest,
+                                         reference_wavelength=reference_wavelength,
+                                         frequency=frequency_rest, luminosity_distance=dl)
+
+    # Get flux density in rest frame (F_nu)
+    flux_density_rest = sed_combined.flux_density  # erg/s/cm^2/Hz
+
+    # Convert from F_nu to F_lambda in rest frame
+    flux_lambda_rest = fnu_to_flambda(f_nu=flux_density_rest, wavelength_A=angstroms_rest)
+
+    # Apply redshift corrections to get observed frame flux:
+    # - Surface brightness dimming: factor of (1+z)
+    # - Wavelength interval stretching: dλ_obs = dλ_rest × (1+z)
+    # Combined effect: divide by (1+z)
+    flux_lambda_obs = flux_lambda_rest / (1 + redshift)
+
+    # Convert to plain values if needed
+    if hasattr(flux_lambda_obs, 'value'):
+        return flux_lambda_obs.value
+    else:
+        return flux_lambda_obs