SpectrumTemplate

class grizli.utils.SpectrumTemplate(wave=None, flux=None, central_wave=None, fwhm=None, velocity=False, fluxunits=Unit("erg / (Angstrom cm2 s)"), waveunits=Unit("Angstrom"), name='template', lorentz=False, err=None)[source]

Bases: object

Container for template spectra.

Parameters:
wave : array-like

Wavelength In astropy.units.Angstrom.

flux : float array-like

If float, then the integrated flux of a Gaussian line. If array, then f-lambda flux density.

central_wave, fwhm : float

Initialize the template with a Gaussian at this wavelength (in astropy.units.Angstrom.) that has an integrated flux of flux and fwhm in astropy.units.Angstrom or km/s for velocity=True.

velocity : bool

fwhm is a velocity in km/s.

Examples

import matplotlib.pyplot as plt
from grizli.utils import SpectrumTemplate

ha = SpectrumTemplate(central_wave=6563., fwhm=10)
plt.plot(ha.wave, ha.flux)

ha_z = ha.zscale(0.1)
plt.plot(ha_z.wave, ha_z.flux, label='z=0.1')

plt.legend()
plt.xlabel(r'$\lambda$')
plt.xlim(6000, 7500)

plt.show()

(Source code, png, hires.png, pdf)

../_images/grizli-utils-SpectrumTemplate-1.png
Attributes:
wave, flux : array-like

Passed from the input parameters or generated/modified later.

Methods

__add__, __mul__ (Addition and multiplication of templates.)

Methods Summary

integrate_filter(filter[, abmag, use_wave]) Integrate the template through an FilterDefinition filter object.
make_gaussian(central_wave, fwhm[, …]) Make Gaussian template
to_fnu([fnu_units]) Make fnu version of the template.
zscale(z[, scalar, apply_igm]) Redshift the template and multiply by a scalar.

Methods Documentation

integrate_filter(filter, abmag=False, use_wave='filter')[source]

Integrate the template through an FilterDefinition filter object.

Parameters:
filter : ObsBandpass

Or any object that has wave and throughput attributes, with the former in the same units as the input spectrum.

abmag : bool

Return AB magnitude rather than fnu flux

Returns:
temp_flux : float

Examples

Compute the WFC3/IR F140W AB magnitude of a pure emission line at the 5-sigma 3D-HST line detection limit (5e-17 erg/s/cm2):

>>> import numpy as np
>>> from grizli.utils import SpectrumTemplate
>>> from eazy.filters import FilterDefinition
>>> import pysynphot as S
>>> line = SpectrumTemplate(central_wave=1.4e4, fwhm=150.,
                            velocity=True)*5.e-17
>>> filter = FilterDefinition(bp=S.ObsBandpass('wfc3,ir,f140w'))
>>> fnu = line.integrate_filter(filter)
>>> print('AB mag = {0:.3f}'.format(-2.5*np.log10(fnu)-48.6))
AB mag = 26.619
static make_gaussian(central_wave, fwhm, max_sigma=5, step=0.1, wave_grid=None, velocity=False, clip=1e-06, lorentz=False)[source]

Make Gaussian template

Parameters:
central_wave, fwhm : None or float or array-like

Central wavelength and FWHM of the desired Gaussian

velocity : bool

fwhm is a velocity.

max_sigma, step : float

Generated wavelength array is

>>> rms = fwhm/2.35
>>> xgauss = np.arange(-max_sigma, max_sigma, step)*rms+central_wave
clip : float

Clip values where the value of the gaussian function is less than clip times its maximum (i.e., 1/sqrt(2*pi*sigma**2)).

lorentz : bool

Make a Lorentzian line instead of a Gaussian.

Returns:
wave, flux : array-like

Wavelength and flux of a Gaussian line

to_fnu(fnu_units=Unit("erg / (cm2 Hz s)"))[source]

Make fnu version of the template.

Sets the flux_fnu attribute, assuming that the wavelength is given in Angstrom and the flux is given in flambda:

>>> flux_fnu = self.flux * self.wave**2 / 3.e18
zscale(z, scalar=1, apply_igm=True)[source]

Redshift the template and multiply by a scalar.

Parameters:
z : float

Redshift to use.

scalar : float

Multiplicative factor. Additional factor of 1./(1+z) is implicit.

Returns:
new_spectrum : SpectrumTemplate

Redshifted and scaled spectrum.