synthesizer.sed¶

Functionality related to spectra storage and manipulation.

When a spectra is computed from a Galaxy or a Galaxy component the resulting calculated spectra are stored in Sed objects. These provide helper functions for quick manipulation of the spectra. Seds can contain a single spectra or arbitrarily many, with all methods capable of acting on both consistently.

Example usage:

sed = Sed(lams, lnu) sed.get_fnu(redshift) sed.apply_attenutation(tau_v=0.7) sed.get_photo_fluxes(filters)

Functions

synthesizer.sed.combine_list_of_seds(sed_list)[source]¶

Combine a list of Sed objects (length Ngal) into a single Sed object, with dimensions Ngal x Nlam. Each Sed object in the list should have an identical wavelength range.

Parameters:: sed_list (list) – list of Sed objects

synthesizer.sed.get_attenuation(intrinsic_sed, attenuated_sed)[source]¶

Calculate attenuation as a function of wavelength

Parameters:

intrinsic_sed (Sed) – The intrinsic spectra object.
attenuated_sed (Sed) – The attenuated spectra object.

Returns:

array-like, float: The attenuation array in magnitudes.

synthesizer.sed.get_attenuation_at_1500(intrinsic_sed, attenuated_sed)[source]¶

Calculate rest-frame FUV attenuation at 1500 angstrom.

Parameters:

intrinsic_sed (Sed) – The intrinsic spectra object.
attenuated_sed (Sed) – The attenuated spectra object.

Returns:

float: The attenuation at rest-frame 1500 angstrom in magnitudes.

synthesizer.sed.get_attenuation_at_5500(intrinsic_sed, attenuated_sed)[source]¶

Calculate rest-frame FUV attenuation at 5500 angstrom.

Parameters:

intrinsic_sed (Sed) – The intrinsic spectra object.
attenuated_sed (Sed) – The attenuated spectra object.

Returns:

float: The attenuation at rest-frame 5500 angstrom in magnitudes.

synthesizer.sed.get_attenuation_at_lam(lam, intrinsic_sed, attenuated_sed)[source]¶

Calculate attenuation at a given wavelength

Parameters:

lam (float/array-like, float) – The wavelength/s at which to evaluate the attenuation in the same units as sed.lam (by default angstrom).
intrinsic_sed (Sed) – The intrinsic spectra object.
attenuated_sed (Sed) – The attenuated spectra object.

Returns:

float/array-like, float: The attenuation at the passed wavelength/s in magnitudes.

synthesizer.sed.get_transmission(intrinsic_sed, attenuated_sed)[source]¶

Calculate transmission as a function of wavelength from an attenuated and an intrinsic sed.

Parameters:

intrinsic_sed (Sed) – The intrinsic spectra object.
attenuated_sed (Sed) – The attenuated spectra object.

Returns:

array-like, float: The transmission array.

synthesizer.sed.plot_observed_spectra(spectra, redshift, fig=None, ax=None, show=False, ylimits=(), xlimits=(), figsize=(3.5, 5), label=None, draw_legend=True, x_units=None, y_units=None, filters=None, quantity_to_plot='fnu')[source]¶

Plots either a specific observed spectra or all observed spectra provided in a dictionary.

This function is a wrapper around plot_spectra.

This is a generic plotting function to be used either directly or to be wrapped by helper methods through Synthesizer.

Parameters:

spectra (dict/Sed) – The Sed objects from which to plot. This can either be a dictionary of Sed objects to plot multiple or a single Sed object to only plot one.
redshift (float) – The redshift of the observation.
fig (matplotlib.pyplot.figure) – The figure containing the axis. By default one is created in this function.
ax (matplotlib.axes) – The axis to plot the data on. By default one is created in this function.
show (bool) – Flag for whether to show the plot or just return the figure and axes.
ylimits (tuple) – The limits to apply to the y axis. If not provided the limits will be calculated with the lower limit set to 1000 (100) times less than the peak of the spectrum for rest_frame (observed) spectra.
xlimits (tuple) – The limits to apply to the x axis. If not provided the optimal limits are found based on the ylimits.
figsize (tuple) – Tuple with size 2 defining the figure size.
label (string) – The label to give the spectra. Only applicable when Sed is a single spectra.
draw_legend (bool) – Whether to draw the legend.
x_units (unyt.unit_object.Unit) – The units of the x axis. This will be converted to a string and included in the axis label. By default the internal unit system is assumed unless this is passed.
y_units (unyt.unit_object.Unit) – The units of the y axis. This will be converted to a string and included in the axis label. By default the internal unit system is assumed unless this is passed.
filters (FilterCollection) – If given then the photometry is computed and both the photometry and filter curves are plotted
quantity_to_plot (string) – The sed property to plot. Can be “fnu”, “flam”, or “flux”. Defaults to “fnu”.

Returns:

fig (matplotlib.pyplot.figure): The matplotlib figure object for the plot.
ax (matplotlib.axes): The matplotlib axes object containing the plotted data.

synthesizer.sed.plot_spectra(spectra, fig=None, ax=None, show=False, ylimits=(), xlimits=(), figsize=(3.5, 5), label=None, draw_legend=True, x_units=None, y_units=None, quantity_to_plot='lnu')[source]¶

Plots either a specific spectra or all spectra provided in a dictionary. The plotted “type” of spectra is defined by the quantity_to_plot keyword arrgument which defaults to “lnu”.

This is a generic plotting function to be used either directly or to be wrapped by helper methods through Synthesizer.

Parameters:

spectra (dict/Sed) – The Sed objects from which to plot. This can either be a dictionary of Sed objects to plot multiple or a single Sed object to only plot one.
fig (matplotlib.pyplot.figure) – The figure containing the axis. By default one is created in this function.
ax (matplotlib.axes) – The axis to plot the data on. By default one is created in this function.
show (bool) – Flag for whether to show the plot or just return the figure and axes.
ylimits (tuple) – The limits to apply to the y axis. If not provided the limits will be calculated with the lower limit set to 1000 (100) times less than the peak of the spectrum for rest_frame (observed) spectra.
xlimits (tuple) – The limits to apply to the x axis. If not provided the optimal limits are found based on the ylimits.
figsize (tuple) – Tuple with size 2 defining the figure size.
label (string) – The label to give the spectra. Only applicable when Sed is a single spectra.
draw_legend (bool) – Whether to draw the legend.
x_units (unyt.unit_object.Unit) – The units of the x axis. This will be converted to a string and included in the axis label. By default the internal unit system is assumed unless this is passed.
y_units (unyt.unit_object.Unit) – The units of the y axis. This will be converted to a string and included in the axis label. By default the internal unit system is assumed unless this is passed.
quantity_to_plot (string) – The sed property to plot. Can be “lnu”, “luminosity” or “llam” for rest frame spectra or “fnu”, “flam” or “flux” for observed spectra. Defaults to “lnu”.

Returns:

fig (matplotlib.pyplot.figure): The matplotlib figure object for the plot.
ax (matplotlib.axes): The matplotlib axes object containing the plotted data.

synthesizer.sed.plot_spectra_as_rainbow(sed, figsize=(5, 0.5), lam_min=3000, lam_max=8000, include_xaxis=True, logged=False, min_log_lnu=-2.0, use_fnu=False)[source]¶

Create a plot of the spectrum as a rainbow.

Parameters:

sed (synthesizer.sed.Sed) – A synthesizer Sed object.
figsize (tuple) – Fig-size tuple (width, height).
lam_min (float) – The min wavelength to plot in Angstroms.
lam_max (float) – The max wavelength to plot in Angstroms.
include_xaxis (bool) – Flag whther to include x-axis ticks and label.
logged (bool) – Flag whether to use logged luminosity.
min_log_lnu (float) – Minium luminosity to plot relative to the maximum.
use_fnu (bool) – Whether to plot fluxes or luminosities. If True fluxes are plotted, otherwise luminosities.

Returns:

fig (matplotlib.pyplot.figure): The matplotlib figure object for the plot.
ax (matplotlib.axes): The matplotlib axes object containing the plotted data.

Classes

class synthesizer.sed.Sed(lam, lnu=None, description=None)[source]¶

A class representing a spectral energy distribution (SED).

lam¶

The rest frame wavelength array.

Type:: Quantity, array-like, float

nu¶

The rest frame frequency array.

Type:: Quantity, array-like, float

lnu¶

The spectral luminosity density.

Type:: Quantity, array-like, float

bolometric_luminosity¶

The bolometric luminosity.

Type:: Quantity, float

fnu¶

The spectral flux density.

Type:: Quantity, array-like, float

obslam¶

The observed wavelength array.

Type:: Quantity, array-like, float

obsnu¶

The observed frequency array.

Type:: Quantity, array-like, float

description¶

An optional descriptive string defining the Sed.

Type:: string

redshift¶

The redshift of the Sed.

Type:: float

photo_luminosities¶

The rest frame broadband photometry in arbitrary filters (filter_code: photometry).

Type:: dict, float

photo_fluxes¶

The observed broadband photometry in arbitrary filters (filter_code: photometry).

Type:: dict, float

apply_attenuation(tau_v, dust_curve=<synthesizer.dust.attenuation.PowerLaw object>, mask=None)[source]¶

Apply attenuation to spectra.

Parameters:

tau_v (float/array-like, float) – The V-band optical depth for every star particle.
dust_curve (synthesizer.dust.attenuation.*) – An instance of one of the dust attenuation models. (defined in synthesizer/dust/attenuation.py)
mask (array-like, bool) – A mask array with an entry for each spectra. Masked out spectra will be ignored when applying the attenuation. Only applicable for Sed’s holding an (N, Nlam) array.

Returns:

Sed: A new Sed containing the rest frame spectra of self attenuated by the transmission defined from tau_v and the dust curve.

calculate_ionising_photon_production_rate(ionisation_energy=unyt_quantity(13.6, 'eV'), limit=100, nthreads=1)[source]¶

A function to calculate the ionising photon production rate.

Parameters:

ionisation_energy (unyt_array) – The ionisation energy.
limit (float/int) – An upper bound on the number of subintervals used in the integration adaptive algorithm.
nthreads (int) – The number of threads to use for the integration. If -1 then all available threads are used.

Returns

float: Ionising photon luminosity (s^-1).

concat(*other_seds)[source]¶

Concatenate the spectra arrays of multiple Sed objects.

This will combine the arrays along the first axis. For example concatenating two Seds with Sed.lnu.shape = (10, 1000) and Sed.lnu.shape = (20, 1000) will result in a new Sed with Sed.lnu.shape = (30, 1000). The wavelength array of the resulting Sed will be the array on self.

Incompatible spectra shapes will raise an error.

Parameters:

other_seds (object, Sed) – Any number of Sed objects to concatenate with self. These must have the same wavelength array.

Returns:

Sed: A new instance of Sed with the concatenated lnu arrays.

Raises:

InconsistentAddition – If wavelength arrays are incompatible an error is raised.

property flux¶

Get the spectra in terms fo flux.

Returns:

flux (unyt_array): The flux array.

get_fnu(cosmo, z, igm=None)[source]¶

Calculate the observed frame spectral energy distribution.

NOTE: if a redshift of 0 is passed the flux return will be calculated assuming a distance of 10 pc omitting IGM since at this distance IGM contribution makes no sense.

Parameters:

cosmo (astropy.cosmology) – astropy cosmology instance.
z (float) – The redshift of the spectra.
igm (igm) – The IGM class. e.g. synthesizer.igm.Inoue14. Defaults to None.

Returns:

fnu (ndarray): Spectral flux density calcualted at d=10 pc

get_fnu0()[source]¶

Calculate a dummy observed frame spectral energy distribution. Useful when you want rest-frame quantities.

Uses a standard distance of 10 pcs.

Returns:

fnu (ndarray): Spectral flux density calcualted at d=10 pc.

get_lnu_at_lam(lam, kind=False)[source]¶

Return lnu at a provided wavelength.

Parameters:

lam (float/array-like, float) – The wavelength(s) of interest.
kind (str) – Interpolation kind, see scipy.interp1d docs for more information. Possible values are ‘linear’, ‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’, ‘previous’, and ‘next’.

Returns:

luminosity (unyt-array): The luminosity (lnu) at the provided wavelength.

get_lnu_at_nu(nu, kind=False)[source]¶

Return lnu with units at a provided frequency using 1d interpolation.

Parameters:

wavelength (float/array-like, float) – The wavelength(s) of interest.
kind (str) – Interpolation kind, see scipy.interp1d docs for more information. Possible values are ‘linear’, ‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’, ‘previous’, and ‘next’.

Returns:

luminosity (unyt_array): The luminosity (lnu) at the provided wavelength.

get_photo_fluxes(filters, verbose=True)[source]¶

Calculate broadband fluxes using a FilterCollection object

Parameters:

filters (object) – A FilterCollection object.
verbose (bool) – Are we talking?

Returns:

(dict): A dictionary of fluxes in each filter in filters.

get_photo_luminosities(filters, verbose=True)[source]¶

Calculate broadband luminosities using a FilterCollection object

Parameters:

filters (filters.FilterCollection) – A FilterCollection object.
verbose (bool) – Are we talking?

Returns:

photo_luminosities (dict): A dictionary of rest frame broadband luminosities.

get_resampled_sed(resample_factor=None, new_lam=None)[source]¶

Resample the spectra onto a new set of wavelength points.

This resampling can either be done by an integer number of wavelength elements per original wavelength element (i.e. up sampling), or by providing a new wavelength grid to resample on to.

Parameters:

resample_factor (int) – The number of additional wavelength elements to resample to.
new_lam (array-like, float) – The wavelength array to resample onto.

Returns:

Sed: A new Sed with the rebinned rest frame spectra.

Raises:

InconsistentArgument – Either resample factor or new_lam must be supplied. If neither or both are passed an error is raised.

property llam¶

Get the spectral luminosity density per Angstrom.

Returns

luminosity (unyt_array): The spectral luminosity density per Angstrom array.

property luminosity¶

Get the spectra in terms of luminosity.

Returns

luminosity (unyt_array): The luminosity array.

property luminosity_lambda¶

Alias to llam.

Returns

luminosity (unyt_array): The spectral luminosity density per Angstrom array.

property luminosity_nu¶

Alias to lnu.

Returns

luminosity (unyt_array): The spectral luminosity density per Hz array.

measure_balmer_break(nthreads=1, integration_method='trapz')[source]¶

Measure the Balmer break.

This will use two windows at (3400,3600) and (4150,4250).

Parameters:

nthreads (int) – The number of threads to use for the integration. If -1 then all available threads are used.
integration_method (str) – The integration method used. Options include ‘trapz’ and ‘simps’.

Returns:

float: The Balmer break strength

Raises:

UnrecognisedOption – If integration_method is an incompatible option an error is raised.

measure_beta(window=(1250.0, 3000.0), nthreads=1, integration_method='trapz')[source]¶

Measure the UV continuum slope (beta).

If the provided window is len(2) a full fit to the spectra is performed otherwise the luminosity in two windows is calculated and used to determine the slope, similar to observations.

Parameters:

window (tuple, float) – The window in which to measure in terms of wavelength.
nthreads (int) – The number of threads to use for the integration. If -1 then all available threads are used.
integration_method (str) – The integration method used to calculate the window luminosity. Options include ‘trapz’ and ‘simps’.

Returns:

float: The UV continuum slope (beta)

Raises:

UnrecognisedOption – If integration_method is an incompatible option an error is raised.

measure_bolometric_luminosity(integration_method='trapz', nthreads=1)[source]¶

Calculate the bolometric luminosity of the SED.

This will integrate the SED over the final axis (which is always the wavelength axis) for an arbitrary number of dimensions.

Parameters:

integration_method (str) – The integration method used to calculate the bolometric luminosity. Options include ‘trapz’ and ‘simps’.
nthreads (int) – The number of threads to use for the integration. If -1 then all available threads are used.

Returns:

bolometric_luminosity (float): The bolometric luminosity.

Raises:

InconsistentArguments – If integration_method is an incompatible option an error is raised.

measure_break(blue, red, nthreads=1, integration_method='trapz')[source]¶

Measure a spectral break (e.g. the Balmer break) using two windows.

Parameters:

blue (tuple, float) – The wavelength limits of the blue window.
red (tuple, float) – The wavelength limits of the red window.
nthreads (int) – The number of threads to use for the integration. If -1 then all available threads are used.
integration_method (str) – The integration method used. Options include ‘trapz’ and ‘simps’.

Returns:

break: The ratio of the luminosity in the two windows.

Raises:

UnrecognisedOption – If integration_method is an incompatible option an error is raised.

measure_colour(f1, f2)[source]¶

Measure a broadband colour.

Parameters:

f1 (str) – The blue filter code.
f2 (str) – The red filter code.

Returns:

(float): The broadband colour.

measure_d4000(definition='Bruzual83', nthreads=1, integration_method='trapz')[source]¶

Measure the D4000 index.

This can optionally use either the Bruzual83 or Balogh definitions.

Parameters:

definition – The choice of definition: ‘Bruzual83’ or ‘Balogh’.
nthreads (int) – The number of threads to use for the integration. If -1 then all available threads are used.
integration_method (str) – The integration method used. Options include ‘trapz’ and ‘simps’.

Returns:

float
The Balmer break strength.

Raises:

UnrecognisedOption: If definition or integration_method is an incompatible option an error is raised.

measure_index(feature, blue, red)[source]¶

Measure an absorption feature index.

Parameters:

feature (tuple) – Absorption feature window.
blue (tuple) – Blue continuum window for fitting.
red (tuple) – Red continuum window for fitting.

Returns:

index (float): Absorption feature index in units of wavelength

measure_window_lnu(window, integration_method='trapz', nthreads=1)[source]¶

Measure lnu in a spectral window.

Parameters:

window (tuple, float) – The window in wavelength.
integration_method (str) – The integration method to use on the window. Options include ‘average’, or for integration ‘trapz’, and ‘simps’.
nthreads (int) – The number of threads to use for the integration. If -1 then all available threads are used.

Returns:

luminosity (float)
The luminosity in the window.

Raises:

UnrecognisedOption: If integration_method is an incompatible option an error is raised.

measure_window_luminosity(window, integration_method='trapz', nthreads=1)[source]¶

Measure the luminosity in a spectral window.

Parameters:

window (tuple, float) – The window in wavelength.
integration_method (str) – The integration method used to calculate the window luminosity. Options include ‘trapz’ and ‘simps’.
nthreads (int) – The number of threads to use for the integration. If -1 then all available threads are used.

Returns: