def process_Rfwhm(Rfwhm, wa, model, models):
""" Convolve the input models using the Rfwhm option
Return the new models.
wa: wavelength array, shape (N,)
model: model flux array, shape (N,)
models: list of model flux arrays each with shape (N,)
Rfwhm is one of:
'convolve_with_COS_FOS'
a float
an array floats with shape (N,)
Returns
-------
new_model, new_models
"""
model_out = None
models_out = []
#import pdb; pdb.set_trace()
if Rfwhm is None:
return model, models
elif Rfwhm == 'convolve_with_COS_FOS':
#print 'convolving with COS/FOS instrument profile'
#import pdb; pdb.set_trace()
model_out = convolve_with_COS_FOS(model, wa, use_COS_nuv=True)
for m in models:
#if m.min() < (1 - 1e-2):
m = convolve_with_COS_FOS(m, wa, use_COS_nuv=True)
models_out.append(m)
elif isinstance(Rfwhm, float):
#print 'Convolving with fwhm %.2f km/s' % Rfwhm
# use a pixel velocity width 4 times smaller than the FWHM
ndiv = 4.
try:
wa_dv = make_constant_dv_wa_scale(wa[0], wa[-1], Rfwhm / ndiv)
except:
import pdb
pdb.set_trace()
model_out = convolve_constant_dv(wa, model, wa_dv, ndiv)
# do the same to every model if there's more than one
for m in models:
#if m.min() < (1 - 1e-2):
m = convolve_constant_dv(wa, m, wa_dv, ndiv)
models_out.append(m)
else:
raise ValueError('Unknown value for Rfwhm option')
return model_out, models_out
def process_Rfwhm(Rfwhm, wa, model, models):
""" Convolve the input models using the Rfwhm option
Return the new models.
wa: wavelength array, shape (N,)
model: model flux array, shape (N,)
models: list of model flux arrays each with shape (N,)
Rfwhm is one of:
'convolve_with_COS_FOS'
a float
an array floats with shape (N,)
Returns
-------
new_model, new_models
"""
model_out = None
models_out = []
#import pdb; pdb.set_trace()
if Rfwhm is None:
return model, models
elif Rfwhm == 'convolve_with_COS_FOS':
#print 'convolving with COS/FOS instrument profile'
#import pdb; pdb.set_trace()
model_out = convolve_with_COS_FOS(model, wa, use_COS_nuv=True)
for m in models:
#if m.min() < (1 - 1e-2):
m = convolve_with_COS_FOS(m, wa, use_COS_nuv=True)
models_out.append(m)
elif isinstance(Rfwhm, float):
#print 'Convolving with fwhm %.2f km/s' % Rfwhm
# use a pixel velocity width 4 times smaller than the FWHM
ndiv = 4.
try:
wa_dv = make_constant_dv_wa_scale(wa[0], wa[-1], Rfwhm / ndiv)
except:
import pdb
pdb.set_trace()
model_out = convolve_constant_dv(wa, model, wa_dv, ndiv)
# do the same to every model if there's more than one
for m in models:
#if m.min() < (1 - 1e-2):
m = convolve_constant_dv(wa, m, wa_dv, ndiv)
models_out.append(m)
else:
raise ValueError('Unknown value for Rfwhm option')
return model_out, models_out
def bin_shift_and_tilt_spline(self, order, singlebin, binSize, multiple,
shift, sigma, slope, offset, minuit,
**kwargs):
"""trying to smooth, interpolate, and integrate the fit."""
mask = self.Orders[order]['mask']
ok = reduce(np.logical_and,
[self.Orders[order][binSize][singlebin]['ok'], mask])
iok = self.Orders[order][binSize][singlebin]['iok']
iow = self.Orders[order]['iow'][iok]
iof = self.Orders[order]['iof'][iok]
wav = self.Orders[order]['wav'][ok]
flx = self.Orders[order]['flx'][ok]
err = self.Orders[order]['err'][ok]
con = self.Orders[order]['con'][ok]
pix = self.Orders[order]['pix'][ok]
overflx = multiple * slope_to_array(
slope,
interp.interp_spline(
wav + shift, iow,
convolve.convolve_constant_dv(iow, iof, vfwhm=sigma))) + offset
chi_square = np.sum((overflx - flx / con)**2 / (err / con)**2)
if minuit == 0:
return chi_square
else:
return chi_square, wav, flx / con, err / con, pix, overflx
def bin_shift_and_tilt_spline(self, order, singlebin, binSize, multiple, shift, sigma, slope, offset, minuit, **kwargs):
"""trying to smooth, interpolate, and integrate the fit."""
mask = self.Orders[order]['mask']
ok = reduce(np.logical_and, [self.Orders[order][binSize][singlebin]['ok'], mask])
iok = self.Orders[order][binSize][singlebin]['iok']
iow = self.Orders[order]['iow'][iok]
iof = self.Orders[order]['iof'][iok]
wav = self.Orders[order]['wav'][ok]
flx = self.Orders[order]['flx'][ok]
err = self.Orders[order]['err'][ok]
con = self.Orders[order]['con'][ok]
pix = self.Orders[order]['pix'][ok]
overflx = multiple * slope_to_array(slope,
wav + shift,
interp.interp_spline(wav + shift,
iow,
convolve.convolve_constant_dv(iow,
iof,
vfwhm=sigma)
)
) + offset
chi_square = np.sum((overflx - flx/con)**2 / (err/con)**2)
if minuit == 0:
return chi_square
else:
return chi_square, wav, flx/con, err/con, pix, overflx
def process_Rfwhm(Rfwhm, wa, model, models):
""" Convolve the input models using the Rfwhm option
Return the new models.
wa: wavelength array, shape (N,)
model: model flux array, shape (N,)
models: list of model flux arrays each with shape (N,)
Rfwm is one of:
'convolve_with_COS_FOS'
a float
Returns
-------
new_model, new_models
"""
model_out = None
models_out = []
if Rfwhm is None:
return model, models
elif Rfwhm == 'convolve_with_COS_FOS':
print 'convolving with COS/FOS instrument profile'
model_out = convolve_with_COS_FOS(model, wa, wa[1] - wa[0])
models_out = [convolve_with_COS_FOS(m, wa, wa[1] - wa[0]) for m
in models]
elif isinstance(Rfwhm, float):
print 'Convolving with fwhm %.2f km/s' % Rfwhm
# use a pixel velocity width 4 times smaller than the FWHM
ndiv = 4.
wa_dv = make_constant_dv_wa_scale(wa[0], wa[-1], Rfwhm / ndiv)
model_out = convolve_constant_dv(wa, model, wa_dv, ndiv)
# do the same to every model if there's more than one
for m in models:
models_out.append(convolve_constant_dv(wa, m, wa_dv, ndiv))
else:
raise ValueError('Unknown value for Rfwhm option')
return model_out, models_out
def order_shift_and_scale_spline(self, order, multiple, shift, sigma,
slope, offset, minuit, **kwargs):
"""trying to smooth, interpolate, and integrate the fit."""
mask = self.Orders[order]['mask']
iow = self.Orders[order]['iow']
iof = self.Orders[order]['iof']
wav = self.Orders[order]['wav'][mask]
flx = self.Orders[order]['flx'][mask]
err = self.Orders[order]['err'][mask]
con = self.Orders[order]['con'][mask]
pix = self.Orders[order]['pix'][mask]
overflx = multiple * slope_to_array(
slope,
interp.interp_spline(
wav + shift, iow,
convolve.convolve_constant_dv(iow, iof, vfwhm=sigma))) + offset
chi_square = np.sum((overflx - flx / con)**2 / (err / con)**2)
if minuit == 0:
return chi_square
else:
return chi_square, wav, flx / con, err / con, pix, overflx
def order_shift_and_scale_spline(self, order, multiple, shift, sigma, slope, offset, minuit, **kwargs):
"""trying to smooth, interpolate, and integrate the fit."""
mask = self.Orders[order]['mask']
iow = self.Orders[order]['iow']
iof = self.Orders[order]['iof']
wav = self.Orders[order]['wav'][mask]
flx = self.Orders[order]['flx'][mask]
err = self.Orders[order]['err'][mask]
con = self.Orders[order]['con'][mask]
pix = self.Orders[order]['pix'][mask]
overflx = multiple * slope_to_array(slope,
wav + shift,
interp.interp_spline(wav + shift,
iow,
convolve.convolve_constant_dv(iow,
iof,
vfwhm=sigma)
)
) + offset
chi_square = np.sum((overflx - flx/con)**2 / (err/con)**2)
if minuit == 0:
return chi_square
else:
return chi_square, wav, flx/con, err/con, pix, overflx
def liske_conv(vel1, wav1, err1_in, disp1, vel2, wav2, err2_in, disp2, smoothing):
"""
Finds a representative liske et al error for each chunk if the chunk were made
of only noisy continuum. Does this many times and give returns an average and standard deviation.
"""
# give param info for chi2. see spectra_shift for more info on each param
parinfo = [{} for i in range(3)]
parinfo[0]["step"] = 0.005
parinfo[1]["step"] = 1.0e-5
parinfo[2]["step"] = 1.0e-6
parinfo[0]["mpside"] = 2
parinfo[1]["mpside"] = 2
parinfo[2]["mpside"] = 2
# list to put uncertainties in from each MC test. avearged later.
uncerts = []
# remove correction to error array before creating the flux array)
err1 = array(err1_in) / sqrt(
exp(
-0.250538878193 * (log(smoothing / disp1)) ** 2 - 0.722721962458 * (log(smoothing / disp1)) - 0.811329540423
)
)
err2 = array(err2_in) / sqrt(
exp(
-0.250538878193 * (log(smoothing / disp1)) ** 2 - 0.722721962458 * (log(smoothing / disp1)) - 0.811329540423
)
)
for q in xrange(50):
# create error arrays comprised of the median error
med_err1 = median(array(err1_in))
med_err2 = median(array(err2_in))
err1 = med_err1 * ones_like(err1_in)
err2 = med_err2 * ones_like(err2_in)
flux1 = np.random.normal(1.0, med_err1, size=len(err1))
flux2 = np.random.normal(1.0, med_err2, size=len(err2))
# re-correct the error arrays.
err1 = err1 * sqrt(
exp(
-0.250538878193 * (log(smoothing / disp1)) ** 2
- 0.722721962458 * (log(smoothing / disp1))
- 0.811329540423
)
)
err2 = err2 * sqrt(
exp(
-0.250538878193 * (log(smoothing / disp1)) ** 2
- 0.722721962458 * (log(smoothing / disp1))
- 0.811329540423
)
)
# convolve
flux1_con = convolve.convolve_constant_dv(wav1, flux1, vfwhm=smoothing)
flux2_con = convolve.convolve_constant_dv(wav2, flux2, vfwhm=smoothing)
# find the spline coefficients for flux then error array
kErr = UnivariateSpline(vel1, err1, s=0)
kFlx = UnivariateSpline(vel1, flux1_con, s=0)
# print 'in loop',pcont
# print cor_flx_noise,cor_err_noise
# calculate uncertatinty via Liske et al method
[noise_liske] = Calc(kFlx(vel2), flux2_con, vel2, kErr(vel2), err2)
# print noise_liske
if noise_liske == inf:
noise_liske = 0.0
# correct liske et al uncertainty
noise_liske = noise_liske / exp(
-0.0815 * (log(smoothing / disp2)) ** 2 - 0.2490 * (log(smoothing / disp2)) - 0.3123
)
uncerts.append(noise_liske)
avg_uncerts = average(array(uncerts))
stdev_uncerts = std(array(uncerts))
return [avg_uncerts, stdev_uncerts]
}
cfg = parse_config(config)
transitions = read_transitions(cfg.trfilename, ATOMDAT)
if 1:
sp = barak.spec.read(cfg.spfilename)
ndiv = 4.
wa_dv = make_constant_dv_wa_scale(sp.wa[0], sp.wa[-1], cfg.Rfwhm / ndiv)
expand_cont_adjustment = 5
vp = readf26(cfg.f26name)
lines = vp.lines[vp.lines.name != '<>']
tau, ticks, alltau = find_tau(sp.wa, lines, ATOMDAT, per_trans=1)
model = convolve_constant_dv(sp.wa, np.exp(-tau), wa_dv, ndiv)
models = [convolve_constant_dv(sp.wa, np.exp(-t), wa_dv, ndiv) for t in
alltau]
adjust = [l for l in vp.lines if l['name'].strip() == '<>']
print 'Nadjust', adjust
if len(adjust) > 0:
regions = vp.regions
isort = regions.wmin.argsort()
print 'Applying continuum adjustments for', len(adjust), 'regions'
for val in adjust:
wav0 = ATOMDAT['<>'].wa[0] * (1 + val['z'])
i0 = regions.wmin[isort].searchsorted(wav0)
i1 = regions.wmax[isort].searchsorted(wav0)
#print i0, i1
#import pdb; pdb.set_trace()
assert i0 - 1 == i1
}
cfg = parse_config(config)
transitions = read_transitions(cfg.trfilename, ATOMDAT)
if 1:
sp = barak.spec.read(cfg.spfilename)
ndiv = 4.
wa_dv = make_constant_dv_wa_scale(sp.wa[0], sp.wa[-1], cfg.Rfwhm / ndiv)
expand_cont_adjustment = 5
vp = readf26(cfg.f26name)
lines = vp.lines[vp.lines.name != '<>']
tau, ticks, alltau = find_tau(sp.wa, lines, ATOMDAT, per_trans=1)
model = convolve_constant_dv(sp.wa, np.exp(-tau), wa_dv, ndiv)
models = [
convolve_constant_dv(sp.wa, np.exp(-t), wa_dv, ndiv) for t in alltau
]
adjust = [l for l in vp.lines if l['name'].strip() == '<>']
print 'Nadjust', adjust
if len(adjust) > 0:
regions = vp.regions
isort = regions.wmin.argsort()
print 'Applying continuum adjustments for', len(adjust), 'regions'
for val in adjust:
wav0 = ATOMDAT['<>'].wa[0] * (1 + val['z'])
i0 = regions.wmin[isort].searchsorted(wav0)
i1 = regions.wmax[isort].searchsorted(wav0)
#print i0, i1
#import pdb; pdb.set_trace()
