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
wavearray-like

Wavelength In astropy.units.Angstrom.

fluxfloat array-like

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

central_wave, fwhmfloat

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.

velocitybool

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, fluxarray-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
filterObsBandpass

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

abmagbool

Return AB magnitude rather than fnu flux

Returns
temp_fluxfloat

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, fwhmNone or float or array-like

Central wavelength and FWHM of the desired Gaussian

velocitybool

fwhm is a velocity.

max_sigma, stepfloat

Generated wavelength array is

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

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

lorentzbool

Make a Lorentzian line instead of a Gaussian.

Returns
wave, fluxarray-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
zfloat

Redshift to use.

scalarfloat

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

Returns
new_spectrumSpectrumTemplate

Redshifted and scaled spectrum.