def test_linear_write1():
spec = read_fits.read_fits_spectrum1d(data_path('UVES.fits'))
write_fits.write(spec, 'test.fits')
test_spec = read_fits.read_fits_spectrum1d('test.fits')
np.testing.assert_allclose(spec.data, test_spec.data)
np.testing.assert_allclose(spec.dispersion, test_spec.dispersion)
if hasattr(spec.dispersion, "unit") or hasattr(test_spec.dispersion, "unit"):
assert spec.dispersion.unit == test_spec.dispersion.unit
def test_multispec_combined():
spectra = read_fits.read_fits_spectrum1d(data_path('Combined.fits'))
write_fits.write(spectra, 'test.fits')
test_spectra = read_fits.read_fits_spectrum1d('test.fits')
for spec, test_spec in zip(spectra, test_spectra):
np.testing.assert_allclose(spec.data, test_spec.data)
np.testing.assert_allclose(spec.dispersion, test_spec.dispersion)
if hasattr(spec.dispersion, "unit") or hasattr(test_spec.dispersion, "unit"):
assert spec.dispersion.unit == test_spec.dispersion.unit
def test_linear_write2():
spec = read_fits.read_fits_spectrum1d(data_path('gbt_1d.fits'))
write_fits.write(spec, 'test.fits')
test_spec = read_fits.read_fits_spectrum1d('test.fits')
np.testing.assert_allclose(spec.data, test_spec.data)
np.testing.assert_allclose(spec.dispersion, test_spec.dispersion)
if hasattr(spec.dispersion, "unit") or hasattr(test_spec.dispersion,
"unit"):
assert spec.dispersion.unit == test_spec.dispersion.unit
def test_multispec_combined():
spectra = read_fits.read_fits_spectrum1d(data_path('Combined.fits'))
write_fits.write(spectra, 'test.fits')
test_spectra = read_fits.read_fits_spectrum1d('test.fits')
for spec, test_spec in zip(spectra, test_spectra):
np.testing.assert_allclose(spec.data, test_spec.data)
np.testing.assert_allclose(spec.dispersion, test_spec.dispersion)
if hasattr(spec.dispersion, "unit") or hasattr(test_spec.dispersion,
"unit"):
assert spec.dispersion.unit == test_spec.dispersion.unit
def test_multispec_spline():
pytest.importorskip("scipy")
spectra = read_fits.read_fits_spectrum1d(data_path('spline.fits'))
write_fits.write(spectra, 'test.fits')
test_spectra = read_fits.read_fits_spectrum1d('test.fits')
for spec, test_spec in zip(spectra, test_spectra):
np.testing.assert_allclose(spec.data, test_spec.data)
np.testing.assert_allclose(spec.dispersion, test_spec.dispersion)
if hasattr(spec.dispersion, "unit") or hasattr(test_spec.dispersion, "unit"):
assert spec.dispersion.unit == test_spec.dispersion.unit
def test_multispec_spline():
pytest.importorskip("scipy")
spectra = read_fits.read_fits_spectrum1d(data_path('spline.fits'))
write_fits.write(spectra, 'test.fits')
test_spectra = read_fits.read_fits_spectrum1d('test.fits')
for spec, test_spec in zip(spectra, test_spectra):
np.testing.assert_allclose(spec.data, test_spec.data)
np.testing.assert_allclose(spec.dispersion, test_spec.dispersion)
if hasattr(spec.dispersion, "unit") or hasattr(test_spec.dispersion,
"unit"):
assert spec.dispersion.unit == test_spec.dispersion.unit
def test_1d_multispec_combined():
legendre = read_fits.read_fits_spectrum1d(data_path('TRES.fits'))[0]
combined, chebyshev = read_fits.read_fits_spectrum1d(
data_path('Combined.fits'))[0:2]
weight_legendre = 2.0
offset_legendre = 1.0
weight_chebyshev = 3.0
offset_chebyshev = 0.0
test_value = weight_legendre*(offset_legendre+legendre.dispersion.value)\
+ weight_chebyshev*(offset_chebyshev+chebyshev.dispersion.value)
np.testing.assert_allclose(combined.dispersion.value, test_value)
def test_1d_multispec_combined():
legendre = read_fits.read_fits_spectrum1d(data_path('TRES.fits'))[0]
combined, chebyshev = read_fits.read_fits_spectrum1d(
data_path('Combined.fits'))[0:2]
weight_legendre = 2.0
offset_legendre = 1.0
weight_chebyshev = 3.0
offset_chebyshev = 0.0
test_value = weight_legendre*(offset_legendre+legendre.dispersion.value)\
+ weight_chebyshev*(offset_chebyshev+chebyshev.dispersion.value)
np.testing.assert_allclose(combined.dispersion.value, test_value)
def test_multispec_linear():
spectra = read_fits.read_fits_spectrum1d(data_path(
'multispec-linear-log.fits'))
write_fits.write(spectra, 'test.fits')
test_spectra = read_fits.read_fits_spectrum1d('test.fits')
for spec, test_spec in zip(spectra, test_spectra):
np.testing.assert_allclose(spec.data, test_spec.data)
np.testing.assert_allclose(spec.dispersion, test_spec.dispersion)
if hasattr(spec.dispersion, "unit") or hasattr(test_spec.dispersion, "unit"):
assert spec.dispersion.unit == test_spec.dispersion.unit
# TODO: create tests that utilize all methods to write fits header
def test_multispec_linear():
spectra = read_fits.read_fits_spectrum1d(
data_path('multispec-linear-log.fits'))
write_fits.write(spectra, 'test.fits')
test_spectra = read_fits.read_fits_spectrum1d('test.fits')
for spec, test_spec in zip(spectra, test_spectra):
np.testing.assert_allclose(spec.data, test_spec.data)
np.testing.assert_allclose(spec.dispersion, test_spec.dispersion)
if hasattr(spec.dispersion, "unit") or hasattr(test_spec.dispersion,
"unit"):
assert spec.dispersion.unit == test_spec.dispersion.unit
# TODO: create tests that utilize all methods to write fits header
def test_multispec_linear():
iraf = ascii.read(data_path('multispec-linear-log.fits.0001.dat'),
Reader=ascii.NoHeader, names=['wave', 'flux'])
spectra = read_fits.read_fits_spectrum1d(data_path('multispec-linear-log.fits'))
spec = spectra[0]
np.testing.assert_allclose(iraf['wave'], spec.dispersion.value)
assert spec.dispersion.unit == u.Angstrom
def test_multispec_cubic_spline():
pytest.importorskip("scipy")
filename = data_path("spline.fits")
spectra = read_fits.read_fits_spectrum1d(filename)
npieces = 10
pmin = 1
pmax = 2304
pixels = np.arange(pmin, pmax + 1) * 1.0
s = (pixels - pmin) / (pmax - pmin) * npieces
j = np.array(map(int, s))
a = (j + 1) - s
b = s - j
c2 = np.array([1.91932706, 4.50545551, 8.47358561, 8.37680956,
3.0511021, 2.54651656, 7.5758634, 7.68131867, 7.58694718,
3.14098023, 7.70766882, 7.90089733, 9.80179082])
x0 = a ** 3
x1 = (1 + 3 * a * (1 + a * b))
x2 = (1 + 3 * b * (1 + a * b))
x3 = b ** 3
w2 = np.take(c2, j, mode='clip') * x0 + np.take(c2, 1 + j, mode='clip') * x1 \
+ np.take(c2, 2 + j, mode='clip') * x2 + np.take(c2, 3 + j,
mode='clip') * x3
np.testing.assert_allclose(w2, spectra[1].dispersion.value)
def read_fits_file(self):
# filename = unicode(self.filename.toUtf8(), encoding="UTF-8")
try:
if 'specutils' not in sys.modules:
from specutils.io import read_fits
spectrum = read_fits.read_fits_spectrum1d(self.filename)
if len(spectrum) > 1:
spectrum = spectrum[0]
try:
wave = np.array(spectrum.wavelength)
flux = np.array(spectrum.flux)
except AttributeError:
wave = np.array(spectrum.dispersion)
flux = np.array(spectrum.flux)
print("No wavelength attribute in FITS File. Using 'dispersion' attribute instead")
except Exception as e:
hdulist = afits.open(self.filename)
flux = hdulist[0].data
header = hdulist[0].header
if 'CDELT1' in header:
wave_step = header['CDELT1']
else:
wave_step = header['CD1_1']
wave_start = header['CRVAL1'] - (header['CRPIX1'] - 1) * wave_step
wave_num = flux.shape[0]
wave = np.linspace(wave_start, wave_start + wave_step * wave_num, num=wave_num)
flux[np.isnan(flux)] = 0 # convert nan's to zeros
return wave, flux
def test_1dspec_UVES():
spec = read_fits.read_fits_spectrum1d(data_path('UVES.fits'))
iraf = ascii.read(data_path('uves_iraf_read_truncated.dat'),
names=['index', 'wave', 'flux'])
assert_almost_equal(spec.dispersion[iraf['index']], iraf['wave'])
assert not hasattr(spec.dispersion, 'unit')
def test_1dspec_UVES():
spec = read_fits.read_fits_spectrum1d(data_path('UVES.fits'))
iraf = ascii.read(data_path('uves_iraf_read_'
'truncated.dat'), names=['index', 'wave', 'flux'])
np.testing.assert_allclose(spec.dispersion[iraf['index']], iraf['wave'])
assert not hasattr(spec.dispersion, 'unit')
def fitspec():
s=read_fits.read_fits_spectrum1d('E5_1_004.fits',dispersion_unit='Angstrom')
wave_range = [21000,24000]
good = np.where((s.wavelength.value > wave_range[0]) & (s.wavelength.value < wave_range[1]))[0]
s = Spectrum1D.from_array(s.wavelength[good],s.flux[good]/np.median(s.flux[good]), dispersion_unit = s.wavelength.unit)
snr = 40
s.uncertainty = (np.zeros(len(s.flux.value))+1.0/snr)*s.flux.unit
#g=load_grid('phoenix_20000_k.h5')
g = load_grid('phoenix_r20000_1.9-2.5_k.h5')
my_model = assemble_model(g, vrad=0, vrot=0,R=20000,spectrum=s,normalize_npol=4)
wave,flux = my_model()
plt.clf()
plt.plot(s.wavelength,s.flux)
plt.plot(wave,flux)
teff_prior = priors.UniformPrior(3000,8000)
logg_prior = priors.UniformPrior(0.0,4.4)
mh_prior = priors.UniformPrior(-1.5,1.0)
alpha_prior = priors.UniformPrior(-0.2,1.2)
vrot_prior = priors.UniformPrior(0,20)
vrad_prior = priors.UniformPrior(-300,300)
R_prior = priors.GaussianPrior(5400,600)
ll = Chi2Likelihood(s)
my_model = my_model | ll
fitobj = MultiNest(my_model, [teff_prior, logg_prior, mh_prior, alpha_prior, vrot_prior, vrad_prior, R_prior])
result = fitobj.run()
return result
def test_multispec_cubic_spline():
pytest.importorskip("scipy")
filename = data_path("spline.fits")
spectra = read_fits.read_fits_spectrum1d(filename)
npieces = 10
pmin = 1
pmax = 2304
pixels = np.arange(pmin, pmax + 1) * 1.0
s = (pixels - pmin) / (pmax - pmin) * npieces
j = np.array(map(int, s))
a = (j + 1) - s
b = s - j
c2 = np.array([
1.91932706, 4.50545551, 8.47358561, 8.37680956, 3.0511021, 2.54651656,
7.5758634, 7.68131867, 7.58694718, 3.14098023, 7.70766882, 7.90089733,
9.80179082
])
x0 = a**3
x1 = (1 + 3 * a * (1 + a * b))
x2 = (1 + 3 * b * (1 + a * b))
x3 = b**3
w2 = np.take(c2, j, mode='clip') * x0 + np.take(c2, 1 + j, mode='clip') * x1 \
+ np.take(c2, 2 + j, mode='clip') * x2 + np.take(c2, 3 + j,
mode='clip') * x3
np.testing.assert_allclose(w2, spectra[1].dispersion.value)
def test_multispec_linear():
iraf = ascii.read(data_path('multispec-linear-log.fits.0001.dat'),
Reader=ascii.NoHeader, names=['wave', 'flux'])
spectra = read_fits.read_fits_spectrum1d(data_path('multispec-linear-log.fits'))
spec = spectra[0]
np.testing.assert_allclose(iraf['wave'], spec.dispersion.value)
assert spec.dispersion.unit == u.Angstrom
def test_multispec_chebyshev():
iraf = ascii.read(data_path('AAO_11.txt'),
data_start=175,
Reader=ascii.NoHeader,
names=['wave', 'flux'])
spectra = read_fits.read_fits_spectrum1d(data_path('AAO.fits'))
spec = spectra[10]
np.testing.assert_allclose(iraf['wave'], spec.wavelength.value)
def read_fits_file(self):
#filename = unicode(self.filename.toUtf8(), encoding="UTF-8")
spectrum = read_fits.read_fits_spectrum1d(self.filename)
wave = np.array(spectrum.wavelength)
flux = np.array(spectrum.flux)
flux[np.isnan(flux)] = 0 #convert nan's to zeros
return wave, flux
def test_multispec_legendre():
iraf = ascii.read(data_path('TRES.dat'),
data_start=127,
Reader=ascii.NoHeader,
names=['wave', 'flux'])
spectra = read_fits.read_fits_spectrum1d(data_path('TRES.fits'))
spec = spectra[10]
np.testing.assert_allclose(iraf['wave'], spec.dispersion.value)
assert spec.dispersion.unit == u.Angstrom
def read_1dspec(file_name):
"""
Reads 1-D Spectra from a FITS file and returns wavelength and flux arrays.
Args:
file_name : FITS file from which data has to be extracted
Returns:
wave_array : Array containing wavelength values extracted from the 1-D Spectra
flux_array : Array containing flux values extracted from the 1-D Spectra
"""
with fits.open(file_name) as hdulist:
axis = int(hdulist[0].header['NAXIS'])
if axis == 1:
flux_array = hdulist[0].data
wave_array = spec.read_fits_spectrum1d(file_name).dispersion
else:
flux_array = hdulist[0].data[0][0]
wave_array = spec.read_fits_spectrum1d(file_name)[0].dispersion
return wave_array, flux_array
def test_spectrum_slicing():
iraf = ascii.read(data_path('gbt_1d_iraf_read.dat'), names=['wave', 'flux'])
spec = read_fits.read_fits_spectrum1d(data_path('gbt_1d.fits'))
np.testing.assert_allclose(spec.dispersion.value, iraf['wave'])
np.testing.assert_allclose(spec.flux, iraf['flux'])
sliced = spec.slice_index(stop=100)
np.testing.assert_allclose(sliced.dispersion.value, iraf["wave"][:100])
np.testing.assert_allclose(sliced.flux, iraf["flux"][:100])
np.testing.assert_allclose(spec.dispersion.value, iraf['wave'])
np.testing.assert_allclose(spec.flux, iraf['flux'])
sliced = sliced.slice_index(start=-1, step=-1)
np.testing.assert_allclose(sliced.dispersion.value, iraf["wave"][99::-1])
np.testing.assert_allclose(sliced.flux, iraf["flux"][99::-1])
def from_fits(cls, path):
"""
Load an echelle spectrum from a FITS file.
Parameters
----------
path : str
Path to the FITS file
"""
spectrum_list = read_fits.read_fits_spectrum1d(path)
header = fits.getheader(path)
name = header.get('OBJNAME', None)
return cls(spectrum_list, header=header, name=name, fits_path=path)
def test_spectrum_slicing():
iraf = ascii.read(data_path('gbt_1d_iraf_read.dat'),
names=['wave', 'flux'])
spec = read_fits.read_fits_spectrum1d(data_path('gbt_1d.fits'))
np.testing.assert_allclose(spec.dispersion.value, iraf['wave'])
np.testing.assert_allclose(spec.flux, iraf['flux'])
sliced = spec.slice_index(stop=100)
np.testing.assert_allclose(sliced.dispersion.value, iraf["wave"][:100])
np.testing.assert_allclose(sliced.flux, iraf["flux"][:100])
np.testing.assert_allclose(spec.dispersion.value, iraf['wave'])
np.testing.assert_allclose(spec.flux, iraf['flux'])
sliced = sliced.slice_index(start=-1, step=-1)
np.testing.assert_allclose(sliced.dispersion.value, iraf["wave"][99::-1])
np.testing.assert_allclose(sliced.flux, iraf["flux"][99::-1])
def test_multispec_equispec_linear():
iraf11 = ascii.read(data_path('multispec_equispec.11.dat'),
Reader=ascii.NoHeader, names=['wave', 'flux'])
iraf12 = ascii.read(data_path('multispec_equispec.12.dat'),
Reader=ascii.NoHeader, names=['wave', 'flux'])
iraf21 = ascii.read(data_path('multispec_equispec.21.dat'),
Reader=ascii.NoHeader, names=['wave', 'flux'])
iraf22 = ascii.read(data_path('multispec_equispec.22.dat'),
Reader=ascii.NoHeader, names=['wave', 'flux'])
spectra = read_fits.read_fits_spectrum1d(data_path('multispec_equispec.fits'))
np.testing.assert_allclose(iraf11['wave'], spectra[0][0].dispersion.value)
np.testing.assert_allclose(iraf12['wave'], spectra[0][1].dispersion.value)
np.testing.assert_allclose(iraf21['wave'], spectra[1][0].dispersion.value)
np.testing.assert_allclose(iraf22['wave'], spectra[1][1].dispersion.value)
spec = spectra[0][0]
assert spec.dispersion.unit == u.Angstrom
def test_multispec_linear_spline():
pytest.importorskip("scipy")
filename = data_path("spline.fits")
spectra = read_fits.read_fits_spectrum1d(filename)
c1 = np.array([8.61795084, 5.18731657, 0.78303947, 8.60234236,
9.65883078, 9.86579257, 8.2952905, 1.47467708,
7.86243508, 4.54125793, 7.96101273])
npieces = 10
pmin = 1
pmax = 2304
pixels = np.arange(pmin, pmax + 1) * 1.0
s = (pixels - pmin) / (pmax - pmin) * npieces
j = s.astype(int)
a = (j + 1) - s
b = s - j
w1 = np.take(c1, j, mode='clip') * a + np.take(c1, 1 + j, mode='clip') * b
np.testing.assert_allclose(w1, spectra[0].dispersion.value)
def from_fits(cls, path):
"""
Load an echelle spectrum from a FITS file.
Parameters
----------
path : str
Path to the FITS file
"""
spectrum_list = [
Spectrum1D.from_specutils(s)
for s in read_fits.read_fits_spectrum1d(path)
]
header = fits.getheader(path)
name = header.get('OBJNAME', None)
return cls(spectrum_list, header=header, name=name, fits_path=path)
def __init__(self, velscale, sigma, _noread=False):
""" Load Miles templates for simulations. """
self.velscale = velscale
self.sigma = sigma
miles_path = os.path.join(context.basedir, "ppxf/miles_models")
# Search for spectra and their properties
fitsfiles = [_ for _ in os.listdir(miles_path) if _.endswith(".fits")]
# Define the different values of metallicities and ages of templates
self.metals = np.unique([
float(
_.split("Z")[1].split("T")[0].replace("m",
"-").replace("p", "+"))
for _ in fitsfiles
])
self.ages = np.unique([
float(
_.split("T")[1].split("_iP")[0].replace("m",
"-").replace("p", "+"))
for _ in fitsfiles
])
# Defining arrays
self.ages2D, self.metals2D = np.meshgrid(self.ages, self.metals)
self.metals1D = self.metals2D.reshape(-1)
self.ages1D = self.ages2D.reshape(-1)
if _noread:
return
templates, norms = [], []
for metal, age in zip(self.metals1D, self.ages1D):
template_file = os.path.join(miles_path,
self.miles_filename(metal, age))
spec = read_fits_spectrum1d(template_file)
wave = spec.dispersion
flux = spec.flux
speclog, logwave, _ = util.log_rebin([wave[0], wave[-1]],
flux,
velscale=self.velscale)
speclog = gaussian_filter1d(speclog, sigma / velscale)
wave = wave[1:-2]
flux = spectres(wave, np.exp(logwave), speclog)
norm = np.sum(flux)
templates.append(flux / norm)
self.templates = np.array(templates)
self.norms = np.array(norms)
self.wave = wave
return
def test_multispec_linear_spline():
pytest.importorskip("scipy")
filename = data_path("spline.fits")
spectra = read_fits.read_fits_spectrum1d(filename)
c1 = np.array([
8.61795084, 5.18731657, 0.78303947, 8.60234236, 9.65883078, 9.86579257,
8.2952905, 1.47467708, 7.86243508, 4.54125793, 7.96101273
])
npieces = 10
pmin = 1
pmax = 2304
pixels = np.arange(pmin, pmax + 1) * 1.0
s = (pixels - pmin) / (pmax - pmin) * npieces
j = s.astype(int)
a = (j + 1) - s
b = s - j
w1 = np.take(c1, j, mode='clip') * a + np.take(c1, 1 + j, mode='clip') * b
np.testing.assert_allclose(w1, spectra[0].dispersion.value)
def test_multispec_equispec_linear():
iraf11 = ascii.read(data_path('multispec_equispec.11.dat'),
Reader=ascii.NoHeader,
names=['wave', 'flux'])
iraf12 = ascii.read(data_path('multispec_equispec.12.dat'),
Reader=ascii.NoHeader,
names=['wave', 'flux'])
iraf21 = ascii.read(data_path('multispec_equispec.21.dat'),
Reader=ascii.NoHeader,
names=['wave', 'flux'])
iraf22 = ascii.read(data_path('multispec_equispec.22.dat'),
Reader=ascii.NoHeader,
names=['wave', 'flux'])
spectra = read_fits.read_fits_spectrum1d(
data_path('multispec_equispec.fits'))
np.testing.assert_allclose(iraf11['wave'], spectra[0][0].dispersion.value)
np.testing.assert_allclose(iraf12['wave'], spectra[0][1].dispersion.value)
np.testing.assert_allclose(iraf21['wave'], spectra[1][0].dispersion.value)
np.testing.assert_allclose(iraf22['wave'], spectra[1][1].dispersion.value)
spec = spectra[0][0]
assert spec.dispersion.unit == u.Angstrom
def drawspectrumUDSz(DR1_ID, DR11_ID, z):
spec = read_fits.read_fits_spectrum1d(
'variable-spectra/UDSz_DR1_' + DR1_ID + '_DR11_' + DR11_ID + '.fits',
dispersion_unit='angstrom')
plt.figure(figsize=[17, 4])
plt.plot(spec.wavelength, spec.flux)
axes = plt.gca()
ylims = axes.get_ylim()
for key in linedict:
val = linedict[key]
lineval = val * (z + 1) * u.AA
if lineval < max(spec.wavelength) and lineval > min(spec.wavelength):
plt.vlines(lineval.value,
ymin=ylims[0],
ymax=ylims[1],
linestyles='dashed')
if key == 'SiII' or key == 'LyA' or key == 'LyB':
plt.text(lineval.value - 140, ylims[0] + 0.2e-18, key)
elif key == 'SiIV_1393+OIV1402':
plt.text(lineval.value - 400, ylims[0] + 0.2e-18, key)
elif key == 'Balmer_break':
plt.text(lineval.value - 300, ylims[1] + 0.2e-18, key)
elif key == 'OIII_doublet-1/3':
plt.text(lineval.value - 200, ylims[1] + 0.2e-18,
'OIII_doublet')
elif key == 'OIII_doublet-1':
continue
else:
plt.text(lineval.value + 10, ylims[0] + 0.2e-18, key)
plt.ylim(ylims)
plt.ylabel('Flux')
unit = u.AA
plt.xlabel('Wavelength, ' + unit.to_string('latex'))
plt.tight_layout()
plt.savefig(DR11_ID + 'spectra.pdf')
synbands=[]
for name, lams in zip(synname,synlam):
synbands.append(sncosmo.Bandpass(lams, [1.,1.], name='tophat'+name))
names168 = [line.split()[0] for line in open('table.txt')]
dic_meta=cPickle.load(open("CABALLOv2/META.pkl"))
ans=[]
for sn in names168:
meta = dic_meta[sn]
for nm in meta['spectra']:
spec=meta['spectra'][nm]
if abs(spec['salt2.phase']) <2.5:
name = "CABALLOv2/"+spec['idr.spec_merged']
spectra = read_fits.read_fits_spectrum1d(name, dispersion_unit='angstrom')
model0 = sncosmo.TimeSeriesSource(numpy.array([0.,1,2]), spectra.dispersion.value/(1+meta['salt2.Redshift']), \
numpy.tile(spectra.flux.value,(3,1)))
dust = sncosmo.F99Dust(r_v=2.5)
dust.set(ebv=0.01)
model = sncosmo.Model(source=model0, effects=[dust], effect_names=['host'], effect_frames=['rest'])
try:
A= -2.5*numpy.log10(model.bandflux(synbands,0.)/model0.bandflux(synbands,0.))
ans.append(A[1]/(A[0]-A[1]))
except:
pass
ans = numpy.array(ans)
def test_1dspec_UVES():
spec = read_fits.read_fits_spectrum1d(data_path("UVES.fits"))
iraf = ascii.read(data_path("uves_iraf_read_" "truncated.dat"), names=["index", "wave", "flux"])
np.testing.assert_allclose(spec.dispersion[iraf["index"]], iraf["wave"])
assert not hasattr(spec.dispersion, "unit")
def test_1dspec_vrad():
iraf = ascii.read(data_path("gbt_1d_iraf_read.dat"), names=["wave", "flux"])
spec = read_fits.read_fits_spectrum1d(data_path("gbt_1d.fits"))
np.testing.assert_allclose(iraf["wave"], spec.dispersion.value)
assert spec.dispersion.unit == u.Unit("km/s")
def readspec(
specfil,
inflg=None,
efil=None,
outfil=None,
show_plot=0,
use_barak=False,
verbose=False,
flux_tags=None,
sig_tags=None,
multi_ivar=False,
):
"""
specfil: string or Table
multi_ivar: Bool (False)
BOSS format of flux, ivar, log10(wave) in multi-extension FITS
"""
from xastropy.files import general as xfg
# from xastropy.plotting import x_guis as xpxg
from astropy.table import Table
from astropy.table import Column
raise ValueError("USE LINETOOLS.spectra.io INSTEAD!!")
# Initialize
dat = None
if inflg == None:
inflg = 0
# Check specfil type
if type(specfil) is Table:
datfil = "None"
# Dummy hdulist
hdulist = [fits.PrimaryHDU(), specfil]
else:
# Read header
datfil, chk = xfg.chk_for_gz(specfil)
if chk == 0:
print("xastropy.spec.readwrite: File does not exist ", specfil)
return -1
hdulist = fits.open(os.path.expanduser(datfil))
head0 = hdulist[0].header
## #################
# Binary FITS table?
if head0["NAXIS"] == 0:
# Flux
if flux_tags is None:
flux_tags = ["SPEC", "FLUX", "FLAM", "FX", "FLUXSTIS", "FLUX_OPT", "fl"]
fx, fx_tag = get_table_column(flux_tags, hdulist)
# xdb.set_trace()
if fx is None:
print("spec.readwrite: Binary FITS Table but no Flux tag")
return
# Error
if sig_tags is None:
sig_tags = ["ERROR", "ERR", "SIGMA_FLUX", "FLAM_SIG", "SIGMA_UP", "ERRSTIS", "FLUXERR", "er"]
sig, sig_tag = get_table_column(sig_tags, hdulist)
if sig is None:
ivar_tags = ["IVAR", "IVAR_OPT"]
ivar, ivar_tag = get_table_column(ivar_tags, hdulist)
if ivar is None:
print("spec.readwrite: Binary FITS Table but no error tags")
return
else:
sig = np.zeros(ivar.size)
gdi = np.where(ivar > 0.0)[0]
sig[gdi] = np.sqrt(1.0 / ivar[gdi])
# Wavelength
wave_tags = ["WAVE", "WAVELENGTH", "LAMBDA", "LOGLAM", "WAVESTIS", "WAVE_OPT", "wa"]
wave, wave_tag = get_table_column(wave_tags, hdulist)
if wave_tag == "LOGLAM":
wave = 10.0 ** wave
if wave is None:
print("spec.readwrite: Binary FITS Table but no wavelength tag")
return
elif head0["NAXIS"] == 1: # Data in the zero extension
# How many entries?
if len(hdulist) == 1: # Old school (one file per flux, error)
# Error
if efil == None:
ipos = max(specfil.find("F.fits"), specfil.find("f.fits"))
if ipos < 0: # No error array
efil = None
# sig = np.zeros(fx.size)
else:
if specfil.find("F.fits") > 0:
efil, chk = xfg.chk_for_gz(specfil[0:ipos] + "E.fits")
else:
efil, chk = xfg.chk_for_gz(specfil[0:ipos] + "e.fits")
if efil != None:
efil = os.path.expanduser(efil)
# Generate Spectrum1D
spec1d = spec_read_fits.read_fits_spectrum1d(os.path.expanduser(datfil), dispersion_unit="AA", efil=efil)
xspec1d = XSpectrum1D.from_spec1d(spec1d)
# spec1d = spec_read_fits.read_fits_spectrum1d(os.path.expanduser(datfil))
elif len(hdulist) == 2: # NEW SCHOOL (one file per flux, error)
spec1d = spec_read_fits.read_fits_spectrum1d(os.path.expanduser(datfil), dispersion_unit="AA")
# Error array
sig = hdulist[1].data
spec1d.uncertainty = StdDevUncertainty(sig)
#
xspec1d = XSpectrum1D.from_spec1d(spec1d)
else: # ASSUMING MULTI-EXTENSION
if len(hdulist) <= 2:
print("spec.readwrite: No wavelength info but only 2 extensions!")
return
fx = hdulist[0].data.flatten()
sig = hdulist[1].data.flatten()
wave = hdulist[2].data.flatten()
# BOSS/SDSS?
try:
multi_ivar = head0["TELESCOP"][0:4] in ["SDSS"]
except KeyError:
pass
#
if multi_ivar is True:
tmpsig = np.zeros(len(sig))
gdp = np.where(sig > 0.0)[0]
tmpsig[gdp] = np.sqrt(1.0 / sig[gdp])
sig = tmpsig
wave = 10.0 ** wave
else: # Should not be here
print("spec.readwrite: Looks like an image")
return dat
# Generate, as needed
if "xspec1d" not in locals():
# Give Ang as default
if not hasattr(wave, "unit"):
uwave = u.Quantity(wave, unit=u.AA)
else:
if wave.unit is None:
uwave = u.Quantity(wave, unit=u.AA)
else:
uwave = u.Quantity(wave)
xspec1d = XSpectrum1D.from_array(uwave, u.Quantity(fx), uncertainty=StdDevUncertainty(sig))
xspec1d.filename = specfil
# Continuum?
try:
co = fits.getdata(name + "_c.fits")
except:
try:
npix = len(fx)
except UnboundLocalError:
npix = len(xspec1d.flux)
co = np.nan * np.ones(npix)
"""
# Generate a Barak Spectrum Class?
hd = hdulist[0].header
if use_barak is True:
# Barak
raise ValueError('Avoid!')
from barak import spec as bs
spec1d = bs.Spectrum(wa=wave, fl=fx, er=sig, co=co, filename=specfil)
spec1d.header = hd
"""
# Plot?
if show_plot:
xpxg.plot_1d_arrays(wave, fx, sig, co)
# Write to disk? Unlikely
if outfil != None:
if use_barak is True:
spec1d.fits_write(outfil, overwrite=True)
else:
xdb.set_trace() # Not ready
# Add in the header
xspec1d.head = head0
# Return
return xspec1d
def readspec(specfil,
inflg=None,
efil=None,
outfil=None,
show_plot=0,
use_barak=False,
verbose=False,
flux_tags=None,
sig_tags=None,
multi_ivar=False):
'''
specfil: string or Table
multi_ivar: Bool (False)
BOSS format of flux, ivar, log10(wave) in multi-extension FITS
'''
from xastropy.files import general as xfg
#from xastropy.plotting import x_guis as xpxg
from astropy.table import Table
from astropy.table import Column
raise ValueError('USE LINETOOLS.spectra.io INSTEAD!!')
# Initialize
dat = None
if inflg == None:
inflg = 0
# Check specfil type
if type(specfil) is Table:
datfil = 'None'
# Dummy hdulist
hdulist = [fits.PrimaryHDU(), specfil]
else:
# Read header
datfil, chk = xfg.chk_for_gz(specfil)
if chk == 0:
print('xastropy.spec.readwrite: File does not exist ', specfil)
return -1
hdulist = fits.open(os.path.expanduser(datfil))
head0 = hdulist[0].header
## #################
# Binary FITS table?
if head0['NAXIS'] == 0:
# Flux
if flux_tags is None:
flux_tags = [
'SPEC', 'FLUX', 'FLAM', 'FX', 'FLUXSTIS', 'FLUX_OPT', 'fl'
]
fx, fx_tag = get_table_column(flux_tags, hdulist)
#xdb.set_trace()
if fx is None:
print('spec.readwrite: Binary FITS Table but no Flux tag')
return
# Error
if sig_tags is None:
sig_tags = [
'ERROR', 'ERR', 'SIGMA_FLUX', 'FLAM_SIG', 'SIGMA_UP',
'ERRSTIS', 'FLUXERR', 'er'
]
sig, sig_tag = get_table_column(sig_tags, hdulist)
if sig is None:
ivar_tags = ['IVAR', 'IVAR_OPT']
ivar, ivar_tag = get_table_column(ivar_tags, hdulist)
if ivar is None:
print('spec.readwrite: Binary FITS Table but no error tags')
return
else:
sig = np.zeros(ivar.size)
gdi = np.where(ivar > 0.)[0]
sig[gdi] = np.sqrt(1. / ivar[gdi])
# Wavelength
wave_tags = [
'WAVE', 'WAVELENGTH', 'LAMBDA', 'LOGLAM', 'WAVESTIS', 'WAVE_OPT',
'wa'
]
wave, wave_tag = get_table_column(wave_tags, hdulist)
if wave_tag == 'LOGLAM':
wave = 10.**wave
if wave is None:
print('spec.readwrite: Binary FITS Table but no wavelength tag')
return
elif head0['NAXIS'] == 1: # Data in the zero extension
# How many entries?
if len(hdulist) == 1: # Old school (one file per flux, error)
# Error
if efil == None:
ipos = max(specfil.find('F.fits'), specfil.find('f.fits'))
if ipos < 0: # No error array
efil = None
#sig = np.zeros(fx.size)
else:
if specfil.find('F.fits') > 0:
efil, chk = xfg.chk_for_gz(specfil[0:ipos] + 'E.fits')
else:
efil, chk = xfg.chk_for_gz(specfil[0:ipos] + 'e.fits')
if efil != None:
efil = os.path.expanduser(efil)
# Generate Spectrum1D
spec1d = spec_read_fits.read_fits_spectrum1d(
os.path.expanduser(datfil), dispersion_unit='AA', efil=efil)
xspec1d = XSpectrum1D.from_spec1d(spec1d)
#spec1d = spec_read_fits.read_fits_spectrum1d(os.path.expanduser(datfil))
elif len(hdulist) == 2: # NEW SCHOOL (one file per flux, error)
spec1d = spec_read_fits.read_fits_spectrum1d(
os.path.expanduser(datfil), dispersion_unit='AA')
# Error array
sig = hdulist[1].data
spec1d.uncertainty = StdDevUncertainty(sig)
#
xspec1d = XSpectrum1D.from_spec1d(spec1d)
else: # ASSUMING MULTI-EXTENSION
if len(hdulist) <= 2:
print(
'spec.readwrite: No wavelength info but only 2 extensions!'
)
return
fx = hdulist[0].data.flatten()
sig = hdulist[1].data.flatten()
wave = hdulist[2].data.flatten()
# BOSS/SDSS?
try:
multi_ivar = head0['TELESCOP'][0:4] in ['SDSS']
except KeyError:
pass
#
if multi_ivar is True:
tmpsig = np.zeros(len(sig))
gdp = np.where(sig > 0.)[0]
tmpsig[gdp] = np.sqrt(1. / sig[gdp])
sig = tmpsig
wave = 10.**wave
else: # Should not be here
print('spec.readwrite: Looks like an image')
return dat
# Generate, as needed
if 'xspec1d' not in locals():
# Give Ang as default
if not hasattr(wave, 'unit'):
uwave = u.Quantity(wave, unit=u.AA)
else:
if wave.unit is None:
uwave = u.Quantity(wave, unit=u.AA)
else:
uwave = u.Quantity(wave)
xspec1d = XSpectrum1D.from_array(uwave,
u.Quantity(fx),
uncertainty=StdDevUncertainty(sig))
xspec1d.filename = specfil
# Continuum?
try:
co = fits.getdata(name + '_c.fits')
except:
try:
npix = len(fx)
except UnboundLocalError:
npix = len(xspec1d.flux)
co = np.nan * np.ones(npix)
'''
# Generate a Barak Spectrum Class?
hd = hdulist[0].header
if use_barak is True:
# Barak
raise ValueError('Avoid!')
from barak import spec as bs
spec1d = bs.Spectrum(wa=wave, fl=fx, er=sig, co=co, filename=specfil)
spec1d.header = hd
'''
# Plot?
if show_plot:
xpxg.plot_1d_arrays(wave, fx, sig, co)
# Write to disk? Unlikely
if outfil != None:
if use_barak is True:
spec1d.fits_write(outfil, overwrite=True)
else:
xdb.set_trace() # Not ready
# Add in the header
xspec1d.head = head0
# Return
return xspec1d
def readspec(specfil, inflg=None, efil=None, verbose=False, flux_tags=None,
sig_tags=None, multi_ivar=False, format='ascii', exten=None):
""" Read a FITS file (or astropy Table or ASCII file) into a
Spectrum1D class
Parameters
----------
specfil : str or Table
Input file. If str:
* FITS file must include in '.fit'
* ASCII must either have a proper Table format
or be 3 columns with WAVE,FLUX,ERROR
efil : string, optional
Explicit filename for Error array. Code will attempt to find this
file on its own.
flux_tags : list of strings, optional
Tags for flux in Binary FITS table. Default: flux_tags = ['SPEC',
'FLUX','FLAM','FX', 'FLUXSTIS', 'FLUX_OPT', 'fl']
sig_tags : list of strings, optional
Tags for error in Binary FITS table. Default : sig_tags =
['ERROR','ERR','SIGMA_FLUX','FLAM_SIG', 'SIGMA_UP', 'ERRSTIS',
'FLUXERR', 'er']
multi_ivar : bool, optional
If True, assume BOSS format of flux, ivar, log10(wave) in
multi-extension FITS.
format : str, optional
Format for ASCII table input ['ascii']
exten : int, optional
FITS extension (mainly for multiple binary FITS tables)
Returns
-------
An XSpectrum1D class
"""
from specutils.io import read_fits as spec_read_fits
from linetools.spectra.xspectrum1d import XSpectrum1D
# Initialize
if inflg == None:
inflg = 0
# Check specfil type
if isinstance(specfil, Table): # MAYBE SHOULD USE SPECUTILS FROM_TABLE
datfil = 'None'
# Dummy hdulist
hdulist = [fits.PrimaryHDU(), specfil]
elif isinstance(specfil, basestring):
datfil = specfil.strip()
flg_fits = False
for ext in ['.fit']:
if ext in specfil:
flg_fits = True
if flg_fits: # FITS
# Read header
datfil, chk = chk_for_gz(specfil.strip())
if chk == 0:
raise IOError('File does not exist {}'.format(specfil))
hdulist = fits.open(os.path.expanduser(datfil))
else: #ASCII
tbl = Table.read(specfil,format=format)
# No header?
if tbl.colnames[0] == 'col1':
names = 'WAVE', 'FLUX', 'ERROR', 'CONTINUUM'
for i,name in enumerate(tbl.colnames):
tbl[name].name = names[i]
hdulist = [fits.PrimaryHDU(), tbl]
else:
raise IOError('readspec: Bad spectra input')
head0 = hdulist[0].header
co = None
## #################
# Binary FITS table?
if is_UVES_popler(head0):
xspec1d = parse_UVES_popler(hdulist)
elif head0['NAXIS'] == 0:
# Flux
if flux_tags is None:
flux_tags = ['SPEC', 'FLUX', 'FLAM', 'FX',
'FLUXSTIS', 'FLUX_OPT', 'fl', 'flux', 'counts',
'COUNTS']
fx, fx_tag = get_table_column(flux_tags, hdulist, idx=exten)
if fx is None:
print('Binary FITS Table but no Flux tag')
return
# Error
if sig_tags is None:
sig_tags = ['ERROR','ERR','SIGMA_FLUX','FLAM_SIG', 'SIGMA_UP',
'ERRSTIS', 'FLUXERR', 'SIGMA', 'sigma', 'sigma_flux',
'er', 'err', 'error']
sig, sig_tag = get_table_column(sig_tags, hdulist)
if sig is None:
ivar_tags = ['IVAR', 'IVAR_OPT', 'ivar']
ivar, ivar_tag = get_table_column(ivar_tags, hdulist, idx=exten)
if ivar is None:
var_tags = ['VAR', 'var']
var, var_tag = get_table_column(var_tags, hdulist, idx=exten)
sig = np.sqrt(var)
else:
sig = np.zeros(ivar.size)
gdi = np.where( ivar > 0.)[0]
sig[gdi] = np.sqrt(1./ivar[gdi])
# Wavelength
wave_tags = ['WAVE','WAVELENGTH','LAMBDA','LOGLAM',
'WAVESTIS', 'WAVE_OPT', 'wa', 'wave', 'loglam']
wave, wave_tag = get_table_column(wave_tags, hdulist, idx=exten)
if wave_tag in ['LOGLAM','loglam']:
wave = 10.**wave
if wave is None:
print('Binary FITS Table but no wavelength tag')
return
co_tags = ['CONT', 'CO', 'CONTINUUM', 'co', 'cont']
co, co_tag = get_table_column(co_tags, hdulist, idx=exten)
elif head0['NAXIS'] == 1: # Data in the zero extension
# How many entries?
if len(hdulist) == 1: # Old school (one file per flux, error)
# Error
if efil == None:
ipos = max(specfil.find('F.fits'),
specfil.find('f.fits'), specfil.find('flx.fits'))
if ipos < 0:
# Becker XShooter style
ipos = specfil.find('.fits')
efil,chk = chk_for_gz(specfil[0:ipos]+'e.fits')
else:
if specfil.find('F.fits') > 0:
efil,chk = chk_for_gz(specfil[0:ipos]+'E.fits')
else:
efil,chk = chk_for_gz(specfil[0:ipos]+'e.fits')
if efil is None:
efil,chk = chk_for_gz(specfil[0:ipos]+'err.fits')
if efil is not None:
efil = os.path.expanduser(efil)
# Error file
if efil is not None:
sig = fits.getdata(efil)
uncertainty = StdDevUncertainty(sig)
else:
uncertainty = None
#Log-Linear?
try:
dc_flag = head0['DC-FLAG']
except KeyError:
# The following is necessary for Becker's XShooter output
cdelt1, dc_flag = get_cdelt_dcflag(head0)
# Read
if dc_flag == 0:
# Read FITS file
spec1d = spec_read_fits.read_fits_spectrum1d(os.path.expanduser(datfil), dispersion_unit='AA')
spec1d.uncertainty = uncertainty
xspec1d = XSpectrum1D.from_spec1d(spec1d)
elif dc_flag == 1: # Generate wavelengths and use array approach
fx = hdulist[0].data
# Generate wave
wave = setwave(head0)
else:
raise ValueError('DC-FLAG has unusual value {:d}'.format(dc_flag))
elif hdulist[0].name == 'FLUX':
# NEW SCHOOL (one file for flux and error)
if 'WAVELENGTH' not in hdulist:
spec1d = spec_read_fits.read_fits_spectrum1d(
os.path.expanduser(datfil), dispersion_unit='AA')
xspec1d = XSpectrum1D.from_spec1d(spec1d)
else:
wave = hdulist['WAVELENGTH'].data * u.AA
fx = hdulist['FLUX'].data
xspec1d = XSpectrum1D.from_tuple((wave, fx))
# Error array
if 'ERROR' in hdulist:
sig = hdulist['ERROR'].data
xspec1d.uncertainty = StdDevUncertainty(sig)
else:
sig = None
if 'CONTINUUM' in hdulist:
xspec1d.co = hdulist['CONTINUUM'].data
if 'METADATA' in head0:
xspec1d.meta.update(json.loads(head0['METADATA']))
else: # ASSUMING MULTI-EXTENSION
if len(hdulist) <= 2:
raise RuntimeError('No wavelength info but only 2 extensions!')
fx = hdulist[0].data.flatten()
try:
sig = hdulist[1].data.flatten()
except AttributeError: # Error array is "None"
sig = None
wave = hdulist[2].data.flatten()
# BOSS/SDSS?
try:
multi_ivar = head0['TELESCOP'][0:4] in ['SDSS']
except KeyError:
pass
#
if multi_ivar is True:
tmpsig = np.zeros(len(sig))
gdp = np.where(sig > 0.)[0]
tmpsig[gdp] = np.sqrt(1./sig[gdp])
sig = tmpsig
wave = 10.**wave
elif (head0['NAXIS'] == 2) and (head0['NAXIS2'] == 5): # SDSS .fit format
fx = hdulist[0].data[0,:].flatten()
sig = hdulist[0].data[2,:].flatten()
wave = setwave(head0)
else: # Should not be here
print('Looks like an image')
return
# Generate, as needed
if 'xspec1d' not in locals():
# Give Ang as default
if not hasattr(wave, 'unit'):
uwave = u.Quantity(wave, unit=u.AA)
elif wave.unit is None:
uwave = u.Quantity(wave, unit=u.AA)
else:
uwave = u.Quantity(wave)
if sig is not None:
xspec1d = XSpectrum1D.from_tuple((uwave, fx, sig))
else:
xspec1d = XSpectrum1D.from_tuple((uwave, fx))
if np.any(np.isnan(xspec1d.dispersion)):
warnings.warn('WARNING: Some wavelengths are NaN')
# Filename
xspec1d.filename = datfil
if not hasattr(xspec1d, 'co'):
xspec1d.co = co
# Final check for continuum in a separate file
if isinstance(specfil,basestring):
if co is None and specfil.endswith('.fits'):
try:
xspec1d.co = fits.getdata(specfil.replace('.fits', '_c.fits'))
except IOError:
pass
# Add in the header
xspec1d.head = head0
# Return
return xspec1d
def convert_spectrum(fraw, fout, BCV=False):
'''
param fraw: the raw counts
param fout: the .json file to save to
'''
raw_list = read_fits.read_fits_spectrum1d(fraw)
head = fits.getheader(fraw)
try:
BCV = head["BCV"]
except KeyError:
print("No BCV correction for", fraw)
BCV = 0.0
BCV_cor = np.sqrt((c_kms_air + BCV) / (c_kms_air - BCV))
echelle_dict = {}
npix = len(raw_list[0].wavelength)
# Do this for each order in the spectrum
for i,raw in enumerate(raw_list):
# Correct for the barycentric shift
wl = raw.wavelength.value
# Scale the sigma values by the same blaze function that the raw fluxes were scaled by
# raw_flux = raw.flux.value
# raw_flux[raw_flux==0] = 1.0
# Where the ratio values are 0, just set it to 1, since the noise will be 0 here too.
# ratio = blaze.flux.value/raw_flux
# sigma = ratio * np.sqrt(raw.flux.value)
if BCV:
wl = wl * BCV_cor
order_dict = { "wl":wl,
"fl":raw.flux.value,
"mask": np.ones((npix,), dtype="bool")}
echelle_dict["order_{}".format(i)] = order_dict
UT = head["DATE-OBS"]
echelle_dict["UT"] = UT
echelle_dict["AIR"] = head["AIR"]
echelle_dict["EXPTIME"] = head["EXPTIME"]
try:
echelle_dict["HJD"] = head["HJDN"]
except KeyError:
print("Spectrum does not have HJDN keyword", UT)
print("Setting to 0.0")
echelle_dict["HJD"] = 0.0
try:
echelle_dict["BCV"] = BCV
except KeyError:
print("Spectrum does not have BCV keyword", UT)
print("Setting to 0.0")
echelle_dict["BCV"] = 0.0
ej.write(fout, echelle_dict)
def test_1dspec_vrad():
iraf = ascii.read(data_path('gbt_1d_iraf_read.dat'), names=['wave', 'flux'])
spec = read_fits.read_fits_spectrum1d(data_path('gbt_1d.fits'))
np.testing.assert_allclose(iraf['wave'], spec.dispersion.value)
assert spec.dispersion.unit == u.Unit('km/s')
def main():
import argparse
parser = argparse.ArgumentParser(description="Merge TRES echelle orders.")
parser.add_argument(
"rfits",
help="Name of the FITS file containing the RAW spectrum to merge.")
parser.add_argument(
"bfits",
help=
"Name of the FITS file containing the BLAZE-corrected spectrum to merge."
)
parser.add_argument(
"template",
help="Name of the FITS file containing the Kurucz template spectrum.")
parser.add_argument(
"--outfile",
default="merged-spec.txt",
help="Name of the output file to write the merged echelle spectrum to."
)
parser.add_argument(
"--clobber",
action="store_true",
help="Overwrite any existing output file with new data.")
parser.add_argument("--plot",
action="store_true",
help="Make a set of plots of the merged spectra.")
parser.add_argument(
"-t",
"--trim",
type=int,
default=6,
help="How many pixels to trim from the front of the file. Default is 6"
)
parser.add_argument(
"--shift",
default=0.0,
type=float,
help=
"Doppler shift the synthetic spectrum by this amount (in km/s) before doing the merge process. This may help if the target star has an exceptionally high radial velocity. Positive velocities correspond to redshifting the template."
)
parser.add_argument(
"--poly-order",
default=3,
type=int,
help=
"The order Chebyshev polynomial used to flatten each echelle order. 0 = constant, 1 = line, 2 = parabola, 3 = cubic, ... etc."
)
args = parser.parse_args()
######################
# TEMPLATE PROCESSING
# read the template
hdul_t = fits.open(args.template)
fl_t = hdul_t[0].data
hdr_t = hdul_t[0].header
# calculate the wavelength vector from the quantities in the FITS header
num = len(fl_t)
p = np.arange(num)
w1 = hdr_t['CRVAL1']
dw = hdr_t['CDELT1']
wl_t = 10**(w1 + dw * p)
hdul_t.close()
dopp_shift = np.sqrt((c_kms_air + args.shift) / (c_kms_air - args.shift))
wl_t = wl_t * dopp_shift
#Also, we should convert from f_nu to f_lam
fl_t *= c_ang / wl_t**2 #Convert from f_nu to f_lambda
fl_t /= np.average(fl_t) #divide by the mean flux, so avg(f) = 1
# create an interpolation object to the synthetic spectrum
interp = InterpolatedUnivariateSpline(wl_t, fl_t, k=2, ext=2)
######################
######################
# READING IN THE DATA
######################
# returns all of the echelle orders as a list
raw_list = read_fits.read_fits_spectrum1d(args.rfits)
blaze_list = read_fits.read_fits_spectrum1d(args.bfits)
header = fits.getheader(args.rfits)
target = header["OBJECT"]
date = header["DATE"]
n_orders = 51
n_pix = 2304 - args.trim
# Create empty dataset to store pseudo-fluxcaled spectra
wls = np.empty((n_orders, n_pix))
fls = np.empty((n_orders, n_pix))
fls_cor = np.empty((n_orders, n_pix))
fls_t = np.empty(
(n_orders, n_pix)) # to store the interpolated model fluxes
sigmas = np.empty((n_orders, n_pix))
# loop through the array, put things into an array of wl, fls
# trimming and flux-caling along the way
for order in range(51):
# select the astropy spectrum corresponding to this order
# and truncate according to trim
raw = raw_list[order]
blaze = blaze_list[order]
wl = raw.wavelength.value[args.trim:]
fl_r = raw.flux.value[args.trim:]
# Where the ratio values are 0, just set it to 1, since the noise will be 0 here too.
fl_r[fl_r == 0] = 1.0
fl_b = blaze.flux.value[args.trim:]
fl_b[fl_b == 0] = 1.0
ratio = fl_b / fl_r
# calculate the uncertainty on this pixel as simply the sqrt of the number of counts,
# but in units of the blaze function
sigma = ratio * np.sqrt(
fl_r + 0.01 * np.median(fl_r)) # to avoid very low vals
wls[order] = wl
fls[order] = fl_b
sigmas[order] = sigma
try:
fls_t[order] = interp(wl)
except ValueError:
print(
"Cannot interpolate synthetic spectrum for echelle order {:}. Assuming flat continuum for now, but you may want to discard the spectrum in this order."
.format(d))
fls_t[order] = np.ones_like(wl)
############################################
# FLATTENING THE DATA TO MATCH THE TEMPLATE
###########################################
# Norm the average level of all orders to match the level of the synthetic spectrum
fl_median = np.median(fls, axis=1)
flt_median = np.median(fls_t, axis=1)
factors = flt_median / fl_median
# update these to be normalized to the synthetic spectra
fls = fls * factors[:, np.newaxis]
sigmas = sigmas * factors[:, np.newaxis]
for order in range(n_orders):
# get the coefficients for the polynomial which makes it match the synthetic spectrum.
fl_cor, X = solve_flux(wls[order],
fls[order],
sigmas[order],
fls_t[order],
order=args.poly_order)
fls_cor[order, :] = fl_cor
######################
# Smoothing the overlap
######################
# start with an existing stub, and add onto it with each iteration
wl_all = wls[0]
fl_all = fls_cor[0]
sigma_all = sigmas[0]
for order in range(1, n_orders):
# Find all wavelengths in the stub that have a value larger than the shortest wavelength in the red order
l_ind = (wl_all > np.min(wls[order]))
# Find all wavelengths in the red order that have a value smaller than the largest wavelength in the stub
r_ind = (wls[order] < np.max(wl_all))
# if either of these is less than 2, then there isn't enough overlap to actually merge and we should
# just take add on the new order to the stub without doing any fancy smoothing
if (np.sum(l_ind) < 2) or (np.sum(r_ind) < 2):
wl_all = np.concatenate((wl_all, wls[order]))
fl_all = np.concatenate((fl_all, fls_cor[order]))
sigma_all = np.concatenate((sigma_all, sigmas[order]))
else:
wl_smooth = wl_all[l_ind]
# Grab both wavelengths, fluxes, and sigmas in the overlap region
wl_comb = np.concatenate([wl_smooth, wls[order][r_ind]])
fl_comb = np.concatenate([fl_all[l_ind], fls_cor[order][r_ind]])
sigma_comb = np.concatenate(
[sigma_all[l_ind], sigmas[order][r_ind]])
# sort according to wl
indsort = np.argsort(wl_comb)
wl_sorted = wl_comb[indsort]
fl_sorted = fl_comb[indsort]
sigma_sorted = sigma_comb[indsort]
# construct a spline
# spline = UnivariateSpline(wl_sorted, fl_sorted, w=1/sigma_sorted)
# choose the left_wl as the wl to interpolate onto
# fl_smooth = spline(wl_smooth)
# transfer the sigmas, too, as the sqrt of sum of squares of the adjacent pixels
# go through each wl in wl_all[lind], find it's arguement in wl_sorted, and average the two
# nearest pixels in sigma_sorted
n_comb = len(sigma_sorted)
n_smooth = len(wl_smooth)
fl_smooth = np.empty(n_smooth)
sigma_smooth = np.empty(n_smooth)
for i in range(n_smooth):
w = wl_smooth[i]
# find where this appears in the combined array
arg = np.searchsorted(wl_sorted, w)
# choose this is the first value as long as it isn't the rightmost value
if arg < (n_smooth - 1):
arg_left = arg
arg_right = arg + 1
else:
arg_left = arg - 1
arg_right = arg
sigma_left = sigma_sorted[arg_left]
sigma_right = sigma_sorted[arg_right]
fl_smooth[i] = np.average(
(fl_sorted[arg_left], fl_sorted[arg_right]),
weights=np.array((1 / sigma_left**2, 1 / sigma_right**2)))
sigma_smooth[i] = np.sqrt(sigma_left**2 + sigma_right**2)
# append all of the pieces together to grow the merged spectrum until we're done adding orders
wl_all = np.concatenate((wl_all, wls[order][~r_ind]))
fl_all = np.concatenate(
(fl_all[~l_ind], fl_smooth, fls_cor[order][~r_ind]))
sigma_all = np.concatenate(
(sigma_all[~l_ind], sigma_smooth, sigmas[order][~r_ind]))
if args.plot:
######################
# PLOTTING THE DATA
######################
# make some plots to examine what the spectrum looks like at the overlap regions
with PdfPages('output.pdf') as pdf:
for order in range(n_orders):
order_min = order - 1 if order > 0 else 0
order_max = order + 1 if order < (n_orders - 2) else (
n_orders - 1)
wl_left = wls[order_min]
fl_left = fls[order_min]
fl_t_left = fls_t[order_min]
fl_cor_left = fls_cor[order_min]
wl_center = wls[order]
fl_center = fls[order]
fl_t_center = fls_t[order]
fl_cor_center = fls_cor[order]
wl_right = wls[order_max]
fl_right = fls[order_max]
fl_t_right = fls_t[order_max]
fl_cor_right = fls_cor[order_max]
# As many times as you like, create a figure fig and save it:
fig, ax = plt.subplots(nrows=3, figsize=(8.5, 12), sharex=True)
ax[0].plot(wl_left, fl_left, color="0.6")
ax[0].plot(wl_right, fl_right, color="0.6")
ax[0].plot(wl_center, fl_center, color="k", label="data")
ax[0].set_title("Order {:d}".format(order + 1))
ax[0].plot(wl_center, fl_cor_center, "r", label="cor. data")
ax[0].plot(wl_center, fl_t_center, "b", label="template")
ax[0].legend(loc="best", fontsize="x-small")
# The polynomial-corrected spectra, with the synthetic model on top
ax[1].plot(wl_left, fl_cor_left, "r", label="cor. data edge")
ax[1].plot(wl_right, fl_cor_right, "r")
ax[1].plot(wl_center,
fl_cor_center,
"g",
alpha=0.7,
label="cor. data center")
ax[1].legend(loc="best", fontsize="x-small")
ax[1].plot(wl_left, fl_t_left, "b", label="template")
ax[1].plot(wl_center, fl_t_center, "b")
ax[1].plot(wl_right, fl_t_right, "b")
# ax[1].plot(wl_t, fl_t, "k", lw=0.5)
ax[1].set_title("Flattened orders")
# The final merged spectrum
ax[2].plot(wl_all, fl_all, "b", label="merged data")
ax[2].legend(loc="best", fontsize="x-small")
ax[2].set_xlim(np.min(wl_left), np.max(wl_right))
ax[2].set_ylim(ax[1].get_ylim())
ax[2].set_title("Merged spectrum")
ax[0].set_ylabel(r"$f_\lambda\,[\propto$\,counts]")
ax[1].set_ylabel(r"$f_\lambda\,[\propto$\,counts]")
ax[2].set_ylabel(r"$f_\lambda\,[\propto$\,counts]")
ax[2].set_xlabel(r"$\lambda$\,[\AA]")
# save figure to large PDF file
pdf.savefig(fig)
plt.close('all')
# We can also set the file's metadata via the PdfPages object:
d = pdf.infodict()
d['Title'] = "{:} - {:}".format(target, date)
d['Author'] = "Ian Czekala"
d['CreationDate'] = datetime.datetime(2009, 11, 13)
d['ModDate'] = datetime.datetime.today()
# sort all of the wl, fl, and sigmas just for good measure
indsort = np.argsort(wl_all)
wl_all = wl_all[indsort]
fl_all = fl_all[indsort]
sigma_all = sigma_all[indsort]
# construct an astropy table with the merged files
t = Table((wl_all, fl_all, sigma_all), names=["wl", "fl", "sigma"])
for (key, value) in header.items():
t.meta[key] = value
# specify how much accuracy to use for each column
formats = {"wl": "%.3f", "fl": "%.3e", "sigma": "%.3e"}
# write the result to file
ascii.write(t,
args.outfile,
overwrite=args.clobber,
format="ecsv",
formats=formats)
def test_multispec_chebyshev():
iraf = ascii.read(data_path('AAO_11.txt'), data_start = 175, Reader = ascii.NoHeader, names = ['wave', 'flux'])
spectra = read_fits.read_fits_spectrum1d(data_path('AAO.fits'))
spec = spectra[10]
np.testing.assert_allclose(iraf['wave'], spec.wavelength.value)
def test_multispec_chebyshev():
iraf = ascii.read(data_path("AAO_11.txt"), data_start=175, Reader=ascii.NoHeader, names=["wave", "flux"])
spectra = read_fits.read_fits_spectrum1d(data_path("AAO.fits"))
spec = spectra[10]
np.testing.assert_allclose(iraf["wave"], spec.wavelength.value)
from pylab import *
from specutils.io import read_fits
myspec = read_fits.read_fits_spectrum1d('../../specutils/io/tests/files/UVES.fits', dispersion_unit='angstrom')
plot(myspec.wavelength, myspec.flux)
show()
def convert_spectrum(fraw, fblaze, fout, BCV=False):
'''
param fraw: the raw counts
param fblaze: the blaze-corrected spectrum
param fout: the .json file to save to
'''
raw_list = read_fits.read_fits_spectrum1d(fraw)
blaze_list = read_fits.read_fits_spectrum1d(fblaze)
head = fits.getheader(fraw)
try:
BCV = head["BCV"]
except KeyError:
print("No BCV correction for", fraw)
BCV = 0.0
BCV_cor = np.sqrt((c_kms_air + BCV) / (c_kms_air - BCV))
echelle_dict = {}
npix = len(blaze_list[0].wavelength)
# Do this for each order in the spectrum
for i, (raw, blaze) in enumerate(zip(raw_list, blaze_list)):
# Correct for the barycentric shift
wl = blaze.wavelength.value
# Scale the sigma values by the same blaze function that the raw fluxes were scaled by
raw_flux = raw.flux.value
raw_flux[raw_flux == 0] = 1.0
# Where the ratio values are 0, just set it to 1, since the noise will be 0 here too.
ratio = blaze.flux.value / raw_flux
sigma = ratio * np.sqrt(raw.flux.value)
if BCV:
wl = wl * BCV_cor
order_dict = {
"wl": wl,
"fl": blaze.flux.value,
"sigma": sigma,
"mask": np.ones((npix, ), dtype="bool")
}
echelle_dict["order_{}".format(i)] = order_dict
UT = head["DATE-OBS"]
echelle_dict["UT"] = UT
try:
echelle_dict["HJD"] = head["HJDN"]
except KeyError:
print("Spectrum does not have HJDN keyword", UT)
print("Setting to 0.0")
echelle_dict["HJD"] = 0.0
try:
echelle_dict["BCV"] = BCV
except KeyError:
print("Spectrum does not have BCV keyword", UT)
print("Setting to 0.0")
echelle_dict["BCV"] = 0.0
ej.write(fout, echelle_dict)
def two_gaussians(x, h1, c1, w1, h2, c2, w2, offset):
return gaussian(x, h1, c1, w1, offset=0) + gaussian(x, h2, c2, w2, offset=0) + offset
def three_gaussians(x, h1, c1, w1, h2, c2, w2, h3, c3, w3, offset):
return (gaussian(x, h1, c1, w1, offset=0) + gaussian(x, h2, c2, w2, offset=0) +
gaussian(x, h3, c3, w3, offset=0) + offset)
# ------------------------------------------------------------------------------------------------------------------- #
# ------------------------------------------------------------------------------------------------------------------- #
# Read Data From The Normalised Spectra
# ------------------------------------------------------------------------------------------------------------------- #
read_data = spec.read_fits_spectrum1d(DIR_SPEC + file_name)
with fits.open(str(file_name)) as hdulist:
image_data = hdulist[0].data
wav_data = read_data.dispersion
flux_data = image_data
# ------------------------------------------------------------------------------------------------------------------- #
# ------------------------------------------------------------------------------------------------------------------- #
# Setup The Plot For Fitting The Spectral Feature
# ------------------------------------------------------------------------------------------------------------------- #
fig = plt.figure(figsize=(12, 9))
ax = fig.add_subplot(111)
ax.xaxis.set_major_locator(major_locator)
ax.set_xlim(min(x_array) - 50, max(x_array) + 50)
ax.grid()
return fig, ax
# -------------------------------------------------------------------------------------------------------------------- #
# -------------------------------------------------------------------------------------------------------------------- #
# Read 1-D Spectra
# -------------------------------------------------------------------------------------------------------------------- #
# file_name = 'cfwcbs_ASASSN14dq-gr7.ms.fits'
file_name = 'final_28aug.fits'
read_data = spec.read_fits_spectrum1d(str(file_name))
with fits.open(str(file_name)) as hdulist:
image_data = hdulist[0].data
image_hdr = hdulist[0].header
wav_data = read_data.dispersion
flux_data = image_data
# print type(image_data), image_data.shape
# print read_data[0].dispersion
# print len(read_data[0].dispersion), len(list(read_data[0]))
# image_hdr2 = fits.getheader('fwcbs_ASASSN14dq-gr7.ms.fits')
# print image_data.shape, len(list(read_data.dispersion))
# init_value = image_hdr['CRVAL1']
# step_size = image_hdr['CD1_1']
# wav_array, flux_array = psl.read1dFitsSpec(fn=file_name, hdu=0)
def test_1dspec_vrad():
iraf = ascii.read(data_path('gbt_1d_iraf_read.dat'),
names=['wave', 'flux'])
spec = read_fits.read_fits_spectrum1d(data_path('gbt_1d.fits'))
np.testing.assert_allclose(iraf['wave'], spec.dispersion.value)
assert spec.dispersion.unit == u.Unit('km/s')
from pylab import *
from specutils.io import read_fits
myspec = read_fits.read_fits_spectrum1d(
'../../specutils/io/tests/files/UVES.fits', dispersion_unit='angstrom')
plot(myspec.wavelength, myspec.flux)
show()
allvaris = []
for sn in dic_meta.itervalues():
if sn['idr.subset'] != 'auxiliary':
# container for all spectra
phases = []
fluxes = []
varis = []
for spec in sn['spectra'].itervalues():
# salt2.phase is in the supernova restframe
if (spec['salt2.phase'] >= prange[0]
and spec['salt2.phase'] < prange[1]):
filename = 'SNF-0203-CABALLO2/' + spec['idr.spec_restframe']
#get wavelength solution
myspec = read_fits.read_fits_spectrum1d(filename)
if myspec.dispersion[0] < lmin or myspec.dispersion[1] > lmax:
sedge = (myspec.dispersion +
numpy.roll(myspec.dispersion, 1)) / 2
sedge = sedge[1:]
hdulist = fits.open(filename)
#containers for all bands in a spectrum
f_ = []
v_ = []
for fin in xrange(len(ledge) - 1):
insertloc = [
numpy.searchsorted(sedge, ledge[fin],
def spec_fits(filename, get_err=False, get_meta=False):
from specutils.io import read_fits
import astropy.units as u
from astropy.io import fits
from synphot import SourceSpectrum
from synphot.models import Empirical1D
#load fits file
spec_fits = read_fits.read_fits_spectrum1d(filename)
#read header info
spec_meta = fits.getheader(filename)
#check for multispec
if isinstance(spec_fits, list):
spec = spec_fits[1]
if get_err:
spec_err = spec_fits[3]
print spec_meta['SITEID']
else:
spec = spec_fits
#spectrum flux data
flux = spec.data
if spec_meta['BUNIT']=='erg/cm2/s/A':
flux = flux * u.erg/u.cm**2/u.s/u.AA
if get_err:
flux_err = spec_err.data
flux_err = flux_err * u.erg/u.cm**2/u.s/u.AA
wave = spec.dispersion
if isinstance(wave, u.Quantity):
wave = wave.value * u.AA
#create synphot spectrum object
spec = SourceSpectrum(Empirical1D, points=wave,
lookup_table=flux, keep_neg=True)
if get_err:
spec_err = SourceSpectrum(Empirical1D, points=wave,
lookup_table=flux_err, keep_neg=True)
#check if metadata is needed
if get_meta:
from astropy.coordinates import SkyCoord
#calculate time observed
datestr = 'DATE-OBS'
if 'T' in spec_meta[datestr]:
isot_obs = spec_meta[datestr]
elif 'UT' in spec_meta:
isot_obs = spec_meta[datestr]+'T'+spec_meta['UT']
else:
isot_obs = spec_meta[datestr]+'T'+spec_meta['UT-TIME']
#exposure time
exp_obs = spec_meta['EXPTIME']
#RA, DEC observed
RA, DEC = spec_meta['RA'], spec_meta['DEC']
coord = SkyCoord(RA, DEC, unit=(u.hourangle, u.deg))
RA, DEC = coord.ra.degree, coord.dec.degree
#return spectrum and metadata
#return spectrum
if get_err:
return spec, spec_err, isot_obs, exp_obs, (RA,DEC)
else:
return spec, isot_obs, exp_obs, (RA,DEC)
else:
#return spectrum
if get_err:
return spec, spec_err
else:
return spec
def test_multispec_legendre():
iraf = ascii.read(data_path('TRES.dat'), data_start = 127, Reader = ascii.NoHeader, names = ['wave', 'flux'])
spectra = read_fits.read_fits_spectrum1d(data_path('TRES.fits'))
spec = spectra[10]
np.testing.assert_allclose(iraf['wave'], spec.dispersion.value)
assert spec.dispersion.unit == u.Angstrom
synbands = []
for name, lams in zip(synname, synlam):
synbands.append(sncosmo.Bandpass(lams, [1., 1.], name='tophat' + name))
names168 = [line.split()[0] for line in open('table.txt')]
dic_meta = cPickle.load(open("CABALLOv2/META.pkl"))
ans = []
for sn in names168:
meta = dic_meta[sn]
for nm in meta['spectra']:
spec = meta['spectra'][nm]
if abs(spec['salt2.phase']) < 2.5:
name = "CABALLOv2/" + spec['idr.spec_merged']
spectra = read_fits.read_fits_spectrum1d(
name, dispersion_unit='angstrom')
model0 = sncosmo.TimeSeriesSource(numpy.array([0.,1,2]), spectra.dispersion.value/(1+meta['salt2.Redshift']), \
numpy.tile(spectra.flux.value,(3,1)))
dust = sncosmo.F99Dust(r_v=2.5)
dust.set(ebv=0.01)
model = sncosmo.Model(source=model0,
effects=[dust],
effect_names=['host'],
effect_frames=['rest'])
try:
A = -2.5 * numpy.log10(
model.bandflux(synbands, 0.) /
model0.bandflux(synbands, 0.))
def test_multispec_log_linear():
iraf = ascii.read(data_path("log-linear.dat"), Reader=ascii.NoHeader, names=["wave", "flux"])
spectra = read_fits.read_fits_spectrum1d(data_path("multispec-linear-log.fits"))
spec = spectra[1]
np.testing.assert_allclose(iraf["wave"], spec.dispersion.value)
assert spec.dispersion.unit == u.Angstrom
def from_fits(cls, path):
spectrum_list = read_fits.read_fits_spectrum1d(path)
header = fits.getheader(path)
return cls(spectrum_list, header=header)
