def export_fit(self, synth_fname, data_fname, parameters_fname):
self._update_parameter_names()
spectrum = self._verify_spectrum(None)
try:
(named_p_opt, cov, meta) = self.metadata["fitted_result"]
except KeyError:
print("Please run a fit first!")
return None
## Write synthetic spectrum
# take the mean of the two errors for simplicity
if len(meta["model_yerr"].shape) == 1:
ivar = (meta["model_yerr"])**-2.
elif len(meta["model_yerr"].shape) == 2:
assert meta["model_yerr"].shape[0] == 2, meta["model_yerr"].shape
ivar = (np.nanmean(meta["model_yerr"], axis=0))**-2.
synth_spec = Spectrum1D(meta["model_x"], meta["model_y"], ivar)
synth_spec.write(synth_fname)
## Write data only in the mask range
mask = self.mask(spectrum)
x, y, ivar = spectrum.dispersion[mask], spectrum.flux[
mask], spectrum.ivar[mask]
data_spec = Spectrum1D(x, y, ivar)
data_spec.write(data_fname)
## Write out all fitting parameters
with open(parameters_fname, "w") as fp:
## Fitted abundances
fp.write("----------Fit Abundances----------\n")
for elem, abund in zip(self.elements, meta["abundances"]):
fp.write("{} {:.3f}\n".format(elem, abund))
fp.write("\n")
fp.write("----------Fixed Abundances----------\n")
for elem, abund in iteritems(self.metadata["rt_abundances"]):
fp.write("{} {:.3f}\n".format(elem, abund))
fp.write("\n")
fp.write("p_opt: {}\n".format(named_p_opt))
fp.write("cov: {}\n".format(cov))
fp.write("\n")
fp.write("----------Parameters----------\n")
for key, value in iteritems(self.metadata):
if key == "rt_abundances": continue
if key == "fitted_result": continue
fp.write("{}: {}\n".format(key, value))
for key, value in iteritems(meta):
if key in ['chi_sq', 'dof']:
fp.write("{}: {}\n".format(key, value))
fp.write("\n")
fp.write("----------Isotopes----------\n")
fp.write(str(self.session.metadata["isotopes"]))
fp.write("\n")
return None
def make_master_dispersion():
order_table = rd.load_order_table()
alldisp = []
for order in np.sort(order_table["order"]):
disp = rd.load_tabulated_dispersion("max", order)
spec = Spectrum1D(disp, np.zeros_like(disp), np.zeros_like(disp))
alldisp.append(spec)
common_dispersion = common_dispersion_map(alldisp)
np.save("master_common_dispersion.npy", common_dispersion)
fig, ax = plt.subplots()
ax.plot(common_dispersion[:-1], np.diff(common_dispersion), label="dwl")
ax.plot(common_dispersion[:-1], 2*np.diff(common_dispersion), label="2*dwl")
ax.set_ylim(0,.25)
ax.legend(loc='lower right')
fig.savefig("common_dispersion_map_dwl.png", bbox_inches='tight')
plt.close(fig)
def make_norm0_spectra(minmax):
assert minmax in ["min", "max"]
order_table = rd.load_order_table()
for iorder, order in enumerate(np.sort(order_table["order"])):
wave = rd.load_tabulated_dispersion(minmax, order)
flux = rd.load_flux_order(minmax, order)
ivar = rd.load_ivar_order(minmax, order)
normflux = np.full_like(flux, np.nan)
normivar = np.full_like(ivar, np.nan)
for i in range(flux.shape[0]):
spec = Spectrum1D(wave, flux[i,:], ivar[i,:])
norm = utils.fit_quantile_continuum(spec, order=4, Niter=5)
normflux[i,:] = norm.flux
normivar[i,:] = norm.ivar
np.save("data_common_dispersion/{}normflux_order{:02}".format(minmax, order), normflux)
np.save("data_common_dispersion/{}normivar_order{:02}".format(minmax, order), normivar)
def stitch_normalized_spectra():
tab = rd.load_master_table()
common_dispersion = rd.load_master_common_dispersion()
order_table = rd.load_order_table()
order_labels = np.sort(order_table["order"])
wavelist = []
normfluxlist = []
normivarlist = []
minmax = "max"
for order in order_labels:
wavelist.append(rd.load_tabulated_dispersion(minmax, order))
normfluxlist.append(rd.load_normflux_order(minmax, order))
normivarlist.append(rd.load_normivar_order(minmax, order))
N = normfluxlist[0].shape[0]
starspeclist = []
bigfluxtable = np.zeros((N, len(common_dispersion)))
bigivartable = np.zeros((N, len(common_dispersion)))
for i in range(N):
specs = []
for order, wave, flux, ivar in zip(order_labels, wavelist, normfluxlist, normivarlist):
specs.append(Spectrum1D(wave, flux[i,:], ivar[i,:]))
starspec = spectrum.stitch(specs, new_dispersion=common_dispersion)
starspeclist.append(starspec)
starname = tab[i]["Star"]
starspec.write("data_stitched_spectra/{}-{:03}_{}.fits".format(starname,i,minmax))
bigfluxtable[i,:] = starspec.flux
bigivartable[i,:] = starspec.ivar
np.save("data_stitched_spectra/all_flux_{}.npy".format(minmax), bigfluxtable)
np.save("data_stitched_spectra/all_ivar_{}.npy".format(minmax), bigivartable)
fig, ax = plt.subplots(figsize=(20,5))
for starspec in starspeclist:
ax.plot(starspec.dispersion, starspec.flux, ',', alpha=.1)
ax.set_xlim(common_dispersion[0], common_dispersion[-1])
ax.set_ylim(0,1.2)
fig.savefig("all_stitched_norm0_{}.png".format(minmax), bbox_inches="tight")
def load_norm0_spec_order(minmax, index, order, fluxdata=None, ivardata=None):
assert minmax in ["min", "max"], minmax
if fluxdata is None: fluxdata = load_normflux_order(minmax, order)
if ivardata is None: ivardata = load_normivar_order(minmax, order)
wave = load_tabulated_dispersion(minmax, order)
return Spectrum1D(wave, fluxdata[index, :], ivardata[index, :])
def read_multispec(fname, full_output=False):
"""
There are some files that are not reduced with Dan Kelson's current pipeline version.
So we have to read those manually and define ivar
"""
# Hardcoded file with old CarPy format: 5 bands instead of 7
if "hd13979red_multi_200311ibt" in fname:
WAT_LENGTH = 67
else:
WAT_LENGTH = 68
with fits.open(fname) as hdulist:
assert len(hdulist) == 1, len(hdulist)
header = hdulist[0].header
data = hdulist[0].data
# orders x pixels
# assert len(data.shape)==2, data.shape
metadata = OrderedDict()
for k, v in header.items():
if k in metadata:
metadata[k] += v
else:
metadata[k] = v
## Compute dispersion
assert metadata["CTYPE1"].upper().startswith("MULTISPE") \
or metadata["WAT0_001"].lower() == "system=multispec"
# Join the WAT keywords for dispersion mapping.
i, concatenated_wat, key_fmt = (1, str(""), "WAT2_{0:03d}")
while key_fmt.format(i) in metadata:
value = metadata[key_fmt.format(i)]
concatenated_wat += value + (" " * (WAT_LENGTH - len(value)))
i += 1
# Split the concatenated header into individual orders.
order_mapping = np.array([map(float, each.rstrip('" ').split()) \
for each in re.split('spec[0-9]+ ?= ?"', concatenated_wat)[1:]])
dispersion = np.array([
specutils.spectrum.compute_dispersion(*mapping)
for mapping in order_mapping
])
if len(data.shape) == 2:
## Compute flux
flux = data
#flux[0 > flux] = np.nan
## Compute ivar assuming Poisson noise
ivar = 1. / np.abs(flux)
#ivar[0 > flux] = 0
code = 1
elif len(data.shape) == 3:
flux = data[1]
ivar = data[2]**(-2)
#flux[0 > flux] = np.nan
#ivar[0 > flux] = 0
code = 2
## Turn into orders
orders = [Spectrum1D(dispersion=d, flux=f, ivar=i, metadata=metadata.copy()) \
for d,f,i in zip(dispersion, flux, ivar)]
for order, mapping in zip(orders, order_mapping):
order.metadata["aperture"] = mapping[0]
order.metadata["beam"] = mapping[1]
if full_output: return orders, code
return orders
if __name__ == "__main__":
import sys
# This is just for development testing.
try:
app = QtGui.QApplication(sys.argv)
except RuntimeError:
None
# Load some spectra.
spectra = [] + \
Spectrum1D.read("/Users/arc/Downloads/hd122563_1blue_multi_090205_oldbutgood.fits") + \
Spectrum1D.read("/Users/arc/Downloads/hd122563_1red_multi_090205_oldbutgood.fits") + \
[Spectrum1D.read("smh/balmer/hd122563.fits")]
for spectrum in spectra[:-1]:
spectrum._dispersion = (1 + +52.1 / 299792.458) * spectrum.dispersion
#spectra = [Spectrum1D.read("hd140283.fits")]
#spectra = [Spectrum1D.read("/Users/arc/research/fe-rich-stars/sm0342-2842.rest.fits")]
sigma = 0.01 * np.ones_like(spectra[-1].dispersion)
spectra[-1]._ivar = sigma**(-2)
from smh import Session
session = Session.load("hd122563.smh")