def test_todict_withjson():
radec = SkyCoord(ra=123.1143 * u.deg, dec=-12.4321 * u.deg)
# HI Lya, Lyb
lya = AbsLine(1215.670 * u.AA)
lya.limits.set([-300., 300.] * u.km / u.s)
lya.attrib['z'] = 2.92939
lya.attrib['coord'] = radec
lyb = AbsLine(1025.7222 * u.AA)
lyb.limits.set([-300., 300.] * u.km / u.s)
lyb.attrib['z'] = lya.attrib['z']
lyb.attrib['coord'] = radec
abscomp = AbsComponent.from_abslines([lya, lyb])
# Instantiate
HIsys = LymanAbsSystem.from_components([abscomp])
# Dict
adict = HIsys.to_dict()
assert isinstance(adict, dict)
# Verify it is JSON compatible (failing in Python 3)
import io, json
with io.open('tmp.json', 'w', encoding='utf-8') as f:
f.write(
unicode(
json.dumps(adict,
sort_keys=True,
indent=4,
separators=(',', ': '))))
def test_coincident_line():
# Init AbsLines
line1 = AbsLine(1215.6700*u.AA)
line2 = AbsLine('CII 1334')
# expected errors
# no limits set
try:
answer = line1.coincident_line(line2)
except ValueError:
pass
# limit only for l1
line1.limits.set((1500,1510)*u.AA)
try:
answer = line1.coincident_line(line2)
except ValueError:
pass
# now limit for l2
line2.limits.set((1509,1520)*u.AA)
# expected overlap
assert line1.coincident_line(line2)
assert line2.coincident_line(line1)
# not expected overlap
line2.limits.set((1510.1,1520)*u.AA)
assert not line1.coincident_line(line2)
assert not line2.coincident_line(line1)
def test_add_component():
radec = SkyCoord(ra=123.1143 * u.deg, dec=-12.4321 * u.deg)
# HI Lya, Lyb
lya = AbsLine(1215.670 * u.AA)
lya.analy['vlim'] = [-300., 300.] * u.km / u.s
lya.attrib['z'] = 2.92939
lya.attrib['N'] = 1e17 / u.cm**2
lyb = AbsLine(1025.7222 * u.AA)
lyb.analy['vlim'] = [-300., 300.] * u.km / u.s
lyb.attrib['z'] = lya.attrib['z']
abscomp = AbsComponent.from_abslines([lya, lyb])
abscomp.coord = radec
# Instantiate
abssys = GenericAbsSystem.from_components([abscomp])
# New component
oi = AbsLine('OI 1302')
oi.analy['vlim'] = [-300., 300.] * u.km / u.s
oi.attrib['z'] = lya.attrib['z']
abscomp2 = AbsComponent.from_abslines([oi])
abscomp2.coord = radec
# Standard
assert abssys.add_component(abscomp2)
# Fail
abssys = GenericAbsSystem.from_components([abscomp])
abscomp2.vlim = [-400., 300.] * u.km / u.s
assert not abssys.add_component(abscomp2)
# Overlap
assert abssys.add_component(abscomp2, overlap_only=True)
def test_init_multi_absline():
# AbsLine(s)
lya = AbsLine(1215.670 * u.AA, z=2.92939)
lya.limits.set([-300., 300.] * u.km / u.s)
lyb = AbsLine(1025.7222 * u.AA)
lyb.setz(lya.z)
lyb.limits.set([-300., 300.] * u.km / u.s)
# Instantiate
abscomp = AbsComponent.from_abslines([lya, lyb])
# Test
assert len(abscomp._abslines) == 2
np.testing.assert_allclose(abscomp.zcomp, 2.92939)
# With column densities
lya.attrib['N'] = 1e12 / u.cm**2
lya.attrib['sig_N'] = [1e11] * 2 / u.cm**2
lya.attrib['flag_N'] = 1
lya.attrib['b'] = 30 * u.km / u.s
lyb.attrib['N'] = 3e12 / u.cm**2
lyb.attrib['sig_N'] = [2e11] * 2 / u.cm**2
lyb.attrib['flag_N'] = 1
lyb.attrib['b'] = 30 * u.km / u.s
abscomp = AbsComponent.from_abslines([lya, lyb])
# Test
assert abscomp.flag_N == 1
assert abscomp.attrib['sig_logN'].size == 2
assert np.isclose(abscomp.logN, 12.146128035678238)
def test_molecules():
h2 = LineList('H2')
#
for kk, name in enumerate(h2.name):
lyi = AbsLine(name, linelist=h2)
# gamma values
h2_B3_0R0 = AbsLine('B3-0R(0)', linelist=h2)
assert h2_B3_0R0.data['gamma'].value > 0.
def test_transtabl():
# Init AbsLines
abslines = [AbsLine(1215.6700*u.AA), AbsLine('CII 1334')]
#
tbl = ltlu.transtable_from_speclines(abslines)
assert len(tbl) == 2
assert 'logN' in tbl.keys()
# add keys
tbl = ltlu.transtable_from_speclines(abslines, add_keys=['A', 'log(w*f)'])
assert 'A' in tbl.keys()
def test_ismatch():
# Test Simple kinematics
abslin1 = AbsLine('NiII 1741', z=1.)
abslin2 = AbsLine('NiII 1741', z=1.)
# Run
answer = abslin1.ismatch(abslin2)
assert answer
# Tuple too
answer2 = abslin1.ismatch((1., abslin1.wrest))
assert answer2
def test_add_absline():
abscomp, _ = mk_comp('HI', zcomp=0.)
abscomp.add_absline(AbsLine('HI 972'), chk_sep=False, chk_vel=False)
with pytest.raises(ValueError):
abscomp.add_absline(AbsLine('HI 949'), vtoler=-10)
# failed addition
bad_absline = AbsLine('CIV 1550')
bad_absline.limits.set([500, 1000] * u.km / u.s)
bad_absline.attrib['coord'] = SkyCoord(20, 20, unit='deg')
abscomp.add_absline(bad_absline)
def test_cgmsurvey_from_fields_sightlines():
# Instantiate fields and add galaxies
field1 = ('PG1407+265', 212.349634 * u.deg, 26.3058650 * u.deg)
fieldobj1 = IgmGalaxyField((field1[1], field1[2]),
name=field1[0],
verbose=False)
field2 = ('PG1148+549', 177.83526042 * u.deg, 54.625855 * u.deg)
fieldobj2 = IgmGalaxyField((field2[1], field2[2]),
name=field2[0],
verbose=False)
f1ras = [212.33310891, 212.329875] * u.deg
f1decs = [26.3722716934, 26.3084391667] * u.deg
f1zs = [0.974413514137, 0.22016787529]
f1gals = Table([f1ras, f1decs, f1zs], names=['RA', 'DEC', 'Z'])
f2ras = [177.835229336, 178.536958333] * u.deg
f2decs = [54.625851084, 54.6176108333] * u.deg
f2zs = [0.0595485754311, 0.00385531364009]
f2gals = Table([f2ras, f2decs, f2zs], names=['RA', 'DEC', 'Z'])
fieldobj1.galaxies = f1gals
fieldobj2.galaxies = f2gals
fields = [fieldobj1, fieldobj2]
# Instantiate sightlines
sl1coord = SkyCoord(field1[1], field1[2], unit='deg')
sl2coord = SkyCoord(field2[1], field2[2], unit='deg')
comp11 = AbsComponent(sl1coord, (8, 6), 0.9743, [-200, 200] * u.km / u.s)
comp12 = AbsComponent(sl1coord, (1, 1), 0.9743, [-200, 200] * u.km / u.s)
al11 = AbsLine('OVI 1031')
al11.attrib['coord'] = sl1coord
al11.analy['spec'] = 'files/J0042-1037.358_9.fits.gz'
al12 = AbsLine('HI 1215')
al12.attrib['coord'] = sl1coord
al12.analy['spec'] = 'files/J0042-1037.358_9.fits.gz'
comp11.add_absline(al11, chk_sep=False, chk_vel=False)
comp12.add_absline(al12, chk_sep=False, chk_vel=False)
sys1 = IGMSystem.from_components([comp11, comp12])
sl1 = IGMSightline.from_systems([sys1])
comp21 = AbsComponent(sl2coord, (6, 4), 0.0037, [-200, 200] * u.km / u.s)
comp22 = AbsComponent(sl2coord, (1, 1), 0.0037, [-200, 200] * u.km / u.s)
al21 = AbsLine('CIV 1548')
al21.attrib['coord'] = sl1coord
al21.analy['spec'] = 'files/J0042-1037.358_9.fits.gz'
al22 = AbsLine('HI 1215')
al22.attrib['coord'] = sl1coord
al22.analy['spec'] = 'files/J0042-1037.358_9.fits.gz'
comp21.add_absline(al21, chk_sep=False, chk_vel=False)
comp22.add_absline(al22, chk_sep=False, chk_vel=False)
sys2 = IGMSystem.from_components([comp21, comp22])
sl2 = IGMSightline.from_systems([sys2])
sightlines = [sl1, sl2]
# Run function
csurvey = cgmsurvey_from_sightlines_fields(fields, sightlines)
assert isinstance(csurvey, CGMAbsSurvey)
def test_failed_init():
with pytest.raises(ValueError):
abslin = AbsLine(1215.700 * u.AA)
with pytest.raises(ValueError):
abslin = AbsLine('HI Ly99')
with pytest.raises(ValueError):
sline = SpectralLine.from_dict(dict(ltype='wrong ltype'))
with pytest.raises(ValueError):
sline = SpectralLine('wrong ltype', 1215.67 * u.AA)
with pytest.raises(ValueError):
sline = SpectralLine('Abs',
dict(bad_trans='because I am dict, right?'))
def test_mk_absline():
# Init HI Lya
abslin = AbsLine(1215.6700 * u.AA)
np.testing.assert_allclose(abslin.data['f'], 0.4164)
# Init CII 1334 with LineList
abslin2 = AbsLine(1334.5323 * u.AA, linelist='Strong', use_CACHE=True)
np.testing.assert_allclose(abslin2.data['Ek'], 74932.62 / u.cm)
# Init CII 1334 by name
abslin3 = AbsLine('CII 1334')
np.testing.assert_allclose(abslin3.data['wrest'], 1334.5323 * u.AA)
def test_init_multi_absline():
# AbsLine(s)
lya = AbsLine(1215.670 * u.AA, z=2.92939)
lya.limits.set([-300., 300.] * u.km / u.s)
lyb = AbsLine(1025.7222 * u.AA)
lyb.setz(lya.z)
lyb.limits.set([-300., 300.] * u.km / u.s)
# Instantiate
abscomp = AbsComponent.from_abslines([lya, lyb])
# Test
assert len(abscomp._abslines) == 2
np.testing.assert_allclose(abscomp.zcomp, 2.92939)
def lyman_comp(radec, z=2.92939):
# HI Lya, Lyb
lya = AbsLine(1215.670 * u.AA, z=z)
lya.limits.set([-300., 300.] * u.km / u.s)
lya.attrib['flag_N'] = 1
lya.attrib['N'] = 1e17 / u.cm**2
lya.attrib['coord'] = radec
lyb = AbsLine(1025.7222 * u.AA, z=z)
lyb.limits.set([-300., 300.] * u.km / u.s)
lyb.attrib['coord'] = radec
abscomp = AbsComponent.from_abslines([lya, lyb])
abscomp.synthesize_colm()
return abscomp
def measure_sodium_EW(filename):
from linetools.lists.linelist import LineList
from astropy import units as u
from linetools.spectralline import AbsLine
from linetools.spectra.xspectrum1d import XSpectrum1D
import matplotlib.pyplot as plt
sp = XSpectrum1D.from_file('RF_' + filename)
sp.normalize(co=sp.co)
wvlim = [5880, 6030] * u.AA
strong = LineList('Strong')
transitions = strong.available_transitions(wvlim,
n_max_tuple=None,
min_strength=0.0)
line1 = transitions['wrest'][0]
line2 = transitions['wrest'][1]
avg_line = (line1 + line2) / 2.0
# Plot the spectrum to get limits for EW
fig = plt.figure()
plt.axvline(x=line1, color='k', linestyle='--')
plt.axhline(y=1.0, color='r', linestyle='--')
plt.axvline(x=line2, color='k', linestyle='--')
sp.plot(xlim=(avg_line - 30, avg_line + 30))
S1 = AbsLine(transitions['wrest'][0] * u.AA, z=0.0)
S1.analy['spec'] = sp
S2 = AbsLine(transitions['wrest'][1] * u.AA, z=0.0)
S2.analy['spec'] = sp
#x = float(input("Enter a lower lim: "))
#y = float(input("Enter a higher lim: "))
x = 5888
y = 5896
S1.limits.set([x, y] * u.AA)
S1.measure_ew(flg=1) # Measure the EW of the first line
EW1 = S1.attrib['EW'], S1.attrib['sig_EW']
#x = float(input("Enter a lower lim: "))
#y = float(input("Enter a higher lim: "))
x = 5895
y = 5905
S2.limits.set([x, y] * u.AA)
S2.measure_ew() # Measure the EW of the second line
EW2 = S2.attrib['EW'], S2.attrib['sig_EW']
return EW1, EW2
def test_voigt_multi_line():
# Wavelength array
wave = np.linspace(3644, 3650, 100) * u.AA
imn = np.argmin(np.abs(wave.value - 3646.2))
# HI line
abslin = AbsLine(1215.670 * u.AA, z=2.)
abslin.attrib['N'] = 10**17.5 / u.cm**2
abslin.attrib['b'] = 20. * u.km / u.s
# DI line
abslin2 = AbsLine('DI 1215', z=2.)
abslin2.attrib['N'] = 10**13. / u.cm**2
abslin2.attrib['b'] = 15. * u.km / u.s
# Voigt
vmodel3 = lav.voigt_from_abslines(wave, [abslin, abslin2])
np.testing.assert_allclose(vmodel3.flux[imn].value, 0.5715512949324375)
def test_parse_abslines():
# Init AbsLines
abslines = [AbsLine(1215.6700*u.AA), AbsLine('CII 1334')]
# wrest
wrest_values = ltlu.parse_speclines(abslines, 'wrest')
np.testing.assert_allclose(wrest_values[1], 1334.5323*u.AA)
# EW
EW_values = ltlu.parse_speclines(abslines, 'EW')
np.testing.assert_allclose(EW_values[1].value, 0.)
# data
A_values = ltlu.parse_speclines(abslines, 'A')
np.testing.assert_allclose(A_values[0].value, 626500000.0)
# append None
aux = ltlu.parse_speclines(abslines, 'wrong_attribute')
assert aux[0] is None
def test_stack_plot(show=False):
abslin1 = AbsLine(1548.204 * u.AA)
abslin2 = AbsLine('CIV 1550')
# no spectrum first
ltap.stack_plot([abslin1], show=show)
# Set spectrum
spec = ltsio.readspec(data_path('UM184_nF.fits')) # already normalized
abslin1.analy['spec'] = spec
abslin1.analy['wvlim'] = [6079.78, 6168.82] * u.AA
abslin1.attrib['z'] = 2.92929
ltap.stack_plot([abslin1], show=show)
# second line
abslin2.analy['spec'] = spec
abslin2.analy['wvlim'] = [6079.78, 6168.82] * u.AA
abslin2.attrib['z'] = 2.92929
ltap.stack_plot([abslin1, abslin2], show=show)
def fill_lls_lines(self, bval=20. * u.km / u.s, do_analysis=1):
"""
Generate an HI line list for an LLS.
Goes into self.lls_lines
Now generates a component too.
Should have it check for an existing HI component..
Parameters
----------
bval : float, optional
Doppler parameter in km/s
do_analysis : int, optional
flag for analysis
"""
from linetools.lists import linelist as lll
# May be replaced by component class (as NT desires)
HIlines = lll.LineList('HI')
self.lls_lines = []
Nval = 10**self.NHI / u.cm**2
for wrest in u.Quantity(HIlines._data['wrest']):
aline = AbsLine(wrest, linelist=HIlines)
# Attributes
aline.attrib['N'] = Nval
aline.attrib['b'] = bval
aline.setz(self.zabs)
aline.limits.set(self.vlim)
aline.analy['do_analysis'] = do_analysis
aline.attrib['coord'] = self.coord
self.lls_lines.append(aline)
# Generate a component (should remove any previous HI)
self.add_component(AbsComponent.from_abslines(self.lls_lines))
def test_voigt_model():
from astropy.modeling import fitting
# Wavelength array
wave = np.linspace(3644, 3650, 100) * u.AA
# HI line
abslin = AbsLine(1215.670 * u.AA, z=2.)
abslin.attrib['N'] = 10**14. / u.cm**2
abslin.attrib['b'] = 25. * u.km / u.s
# Voigt
vmodel = abslin.generate_voigt(wave=wave)
vmodel.sig = 0.1
# Voigt fit
abslin.analy['spec'] = vmodel
abslin.limits.set([-100., 100] * u.km / u.s)
abslin.measure_aodm(normalize=False) # Sets analysis pixels
fitvoigt = lav.single_voigt_model(logN=np.log10(abslin.attrib['N'].value),
b=abslin.attrib['b'].value,
z=2.,
wrest=abslin.wrest.value,
gamma=abslin.data['gamma'].value,
f=abslin.data['f'],
fwhm=3.)
# Restrict parameter space
fitvoigt.logN.min = 12.
fitvoigt.b.min = 10.
fitvoigt.z.min = 2. + -100. * (1 + 2.) / c_kms
fitvoigt.z.max = 2. + 100 * (1 + 2.) / c_kms
# Fit
fitter = fitting.LevMarLSQFitter()
parm = fitter(fitvoigt, vmodel.wavelength[abslin.analy['pix']].value,
vmodel.flux[abslin.analy['pix']].value)
assert np.abs(parm.logN.value - np.log10(abslin.attrib['N'].value)) < 0.1
def test_aodm_absline():
# Init CIV 1548
abslin = AbsLine('CIV 1548', z=2.9304)
# Set spectrum
abslin.analy['spec'] = lsio.readspec(
data_path('UM184_nF.fits')) # Fumagalli+13 MagE spectrum
abslin.limits.set([6080.78, 6087.82] * u.AA)
#abslin.analy['wvlim'] = [6080.78, 6087.82]*u.AA
#
abslin.measure_aodm()
N, sig_N, flgN = [abslin.attrib[key] for key in ['N', 'sig_N', 'flag_N']]
np.testing.assert_allclose(N.value, 76369981945649.38)
assert N.unit == 1 / u.cm**2
assert flgN == 1
# Now velocity limits
abslin.setz(2.92929)
abslin.limits.set((-150., 150.) * u.km / u.s)
#
abslin.measure_aodm()
N, sig_N, flgN = [abslin.attrib[key] for key in ['N', 'sig_N', 'flag_N']]
np.testing.assert_allclose(N.value, 80410608889125.64)
return
def fill_lls_lines(self, bval=20. * u.km / u.s):
"""
Generate an HI line list for an LLS.
Goes into self.lls_lines
Parameters
----------
bval : float (20.) Doppler parameter in km/s
"""
from linetools.lists import linelist as lll
from linetools.spectralline import AbsLine
# May be replaced by component class (as NT desires)
HIlines = lll.LineList('HI')
self.lls_lines = []
for lline in HIlines._data:
aline = AbsLine(lline['wrest'], linelist=HIlines)
# Attributes
aline.attrib['N'] = self.NHI
aline.attrib['b'] = bval
aline.attrib['z'] = self.zabs
# Could set RA and DEC too
aline.attrib['RA'] = self.coord.ra
aline.attrib['DEC'] = self.coord.dec
self.lls_lines.append(aline)
def setatomicdata(lines, precise=True, linelist=ilist):
lam = np.zeros(len(lines))
fosc = np.zeros(len(lines))
gam = np.zeros(len(lines))
for i, ll in enumerate(lines):
try:
al = AbsLine(ll * u.AA, closest=True, linelist=linelist)
lam[i] = al.data['wrest'].value
fosc[i] = al.data['f']
gam[i] = al.data['gamma'].value
except:
idx = jbg.closest(adata['wrest'], ll)
lam[i] = adata['wrest'][idx]
fosc[i] = adata['f'][idx]
gam[i] = adata['gamma'][idx]
if ((abs(lam[i] - ll) > 0.01) & (precise == True)):
idx = jbg.closest(vdata['wrest'], ll)
try:
lam[i] = vdata['wrest'][idx].value
fosc[i] = vdata['f'][idx]
gam[i] = vdata['gamma'][idx].value
except:
lam[i] = vdata['wrest'][idx]
fosc[i] = vdata['f'][idx]
gam[i] = vdata['gamma'][idx]
return lam, fosc, gam
def read_ion_file(self,ion_fil,zabs=0.,RA=0.*u.deg, Dec=0.*u.deg):
"""Read in JXP-style .ion file in an appropriate manner
NOTE: If program breaks in this function, check the all file
to see if it is properly formatted.
"""
# Read
names=('wrest', 'clm', 'sig_clm', 'flg_clm', 'flg_inst')
table = ascii.read(ion_fil, format='no_header', names=names)
if self.linelist is None:
self.linelist = LineList('ISM')
# Generate AbsLine's
for row in table:
# Generate the line
aline = AbsLine(row['wrest']*u.AA, linelist=self.linelist, closest=True)
# Set z, RA, DEC, etc.
aline.attrib['z'] = self.zabs
aline.attrib['RA'] = self.coord.ra
aline.attrib['Dec'] = self.coord.dec
# Check against existing lines
mt = [kk for kk,oline in enumerate(self.lines) if oline.ismatch(aline)]
if len(mt) > 0:
mt.reverse()
for imt in mt:
print('read_ion_file: Removing line {:g}'.format(self.lines[imt].wrest))
self.lines.pop(imt)
# Append
self.lines.append(aline)
def test_init_single_absline():
# Single AbsLine
lya = AbsLine(1215.670 * u.AA, z=2.92939)
lya.limits.set([-300., 300.] * u.km / u.s)
abscomp = AbsComponent.from_abslines([lya])
# Test
assert abscomp.Zion[0] == 1
np.testing.assert_allclose(abscomp.zcomp, 2.92939)
print(abscomp)
def test_one_component():
radec = SkyCoord(ra=123.1143 * u.deg, dec=-12.4321 * u.deg)
# HI Lya, Lyb
lya = AbsLine(1215.670 * u.AA)
lya.analy['vlim'] = [-300., 300.] * u.km / u.s
lya.attrib['z'] = 2.92939
lya.attrib['N'] = 1e17 / u.cm**2
lyb = AbsLine(1025.7222 * u.AA)
lyb.analy['vlim'] = [-300., 300.] * u.km / u.s
lyb.attrib['z'] = lya.attrib['z']
abscomp = AbsComponent.from_abslines([lya, lyb])
abscomp.coord = radec
# Instantiate
HIsys = LymanAbsSystem.from_components([abscomp])
# Test
assert HIsys.abs_type == 'HILyman'
assert len(HIsys._components) == 1
assert HIsys._components[0].Zion[0] == 1
assert HIsys._components[0].Zion[1] == 1
def test_voigt_sngl_tau():
# Wavelength array
wave = np.linspace(3644, 3650, 100) * u.AA
imn = np.argmin(np.abs(wave.value - 3647))
# HI line
abslin = AbsLine(1215.670 * u.AA, z=2.)
abslin.attrib['N'] = 10**14. / u.cm**2
abslin.attrib['b'] = 25. * u.km / u.s
# Tau
tau = lav.voigt_from_abslines(wave, abslin, ret='tau')
np.testing.assert_allclose(tau[imn], 2.9681283001576779)
def test_voigt_sngl_line():
# Wavelength array
wave = np.linspace(3644, 3650, 100) * u.AA
imn = np.argmin(np.abs(wave.value - 3647))
# HI line
abslin = AbsLine(1215.670 * u.AA, z=2.)
abslin.attrib['N'] = 10**14. / u.cm**2
abslin.attrib['b'] = 25. * u.km / u.s
# Voigt
vmodel = abslin.generate_voigt(wave=wave)
np.testing.assert_allclose(vmodel.flux[imn].value, 0.05145500775919881)
def test_lines_generic():
# Init
gensys = xabsys.GenericAbsSystem()
#
few_lines = [1215.6700, 1334.5323] * u.AA
for ilin in few_lines:
gensys.lines.append(AbsLine(ilin))
# Test
Lya = gensys[1215.670 * u.AA]
assert Lya[0].trans == 'HI 1215'
def test_init_failures():
with pytest.raises(IOError):
AbsComponent.from_abslines('blah')
with pytest.raises(IOError):
AbsComponent.from_abslines(['blah'])
with pytest.raises(IOError):
AbsComponent.from_component('blah')
# Inconsistent abslines with median
lya = AbsLine(1215.670 * u.AA, z=2.92939)
lya.attrib['N'] = 1e12 / u.cm**2
lya.attrib['sig_N'] = [1e11] * 2 / u.cm**2
lya.attrib['b'] = 30 * u.km / u.s
lyb = AbsLine('HI 1025', z=2.92939)
lyb.attrib['N'] = 3e12 / u.cm**2
lyb.attrib['sig_N'] = [3e11] * 2 / u.cm**2
lyb.attrib['b'] = 30 * u.km / u.s
with pytest.raises(ValueError):
AbsComponent.from_abslines([lya, lyb],
adopt_median=True,
chk_meas=True)
def test_measurekin_absline():
# Test Simple kinematics
abslin = AbsLine('NiII 1741',z=2.307922)
# Set spectrum
abslin.analy['spec'] = lsio.readspec(data_path('PH957_f.fits'))
abslin.limits.set([-70., 70.]*u.km/u.s)
# Measure Kin
abslin.measure_kin()
np.testing.assert_allclose(abslin.attrib['kin']['Dv'].value, 75.)
np.testing.assert_allclose(abslin.attrib['kin']['fedg'], 0.20005782376000183)
