def rate_spectrum(spid=None):
session_init(session, db)
error = None
if session['username'] is None:
error = 'must be logged in to rate spectrum'
return redirect(url_for('spectrum', spid=spid, error=error))
pid = session['person_id']
s = db.get_spectrum(spid)
if s is None:
error = 'Could not find Spectrum #%i' % spid
return render_template('ptable', error=error)
opts = parse_spectrum(s, db)
score = 3
review = '<review>'
for _s, _r, _d, _p in spectrum_ratings(db, spid):
if int(_p) == int(pid):
score = _s
review = _r
spid = s.id
spname = s.name
return render_template('ratespectrum.html',
error=error,
spectrum_id=spid,
spectrum_name=spname,
person_id=pid,
score=score,
review=review)
def rate_spectrum(spid=None):
session_init(session, db)
error=None
if session['username'] is None:
error='must be logged in to rate spectrum'
return redirect(url_for('spectrum', spid=spid, error=error))
pid = session['person_id']
s = db.get_spectrum(spid)
if s is None:
error = 'Could not find Spectrum #%i' % spid
return render_template('ptable', error=error)
opts = parse_spectrum(s, db)
score = 3
review = '<review>'
for _s, _r, _d, _p in spectrum_ratings(db, spid):
if int(_p) == int(pid):
score = _s
review = _r
spid = s.id
spname = s.name
return render_template('ratespectrum.html', error=error,
spectrum_id=spid, spectrum_name=spname,
person_id=pid, score=score, review=review)
def submit_upload():
session_init(session, db)
error = None
if session['username'] is None:
error = 'must be logged in to submit a spectrum'
return redirect(url_for('search', error=error))
if request.method == 'POST':
pid = request.form['person']
pemail = db.get_person(int(pid)).email
file = request.files['file']
s = None
file_ok = False
if file and allowed_file(file.filename):
fname = secure_filename(file.filename)
fullpath = os.path.abspath(
os.path.join(app.config['UPLOAD_FOLDER'], fname))
try:
file.save(fullpath)
file_ok = True
except IOError:
pass
if file_ok:
time.sleep(1.0)
db.add_xdifile(fullpath, person=pemail, create_sample=True)
time.sleep(1.0)
db.session.commit()
s = db.get_spectra()[-1]
if s is None:
error = 'Could not find Spectrum #%i' % s.id
return render_template('upload.html', error=error)
if s is None:
error = "File '%s' not found or not suppported type" % (
file.filename)
return render_template('upload.html', error=error)
try:
opts = parse_spectrum(s, db)
except:
error = "Could not read spectrum from '%s'" % (file.filename)
return render_template('upload.html', error=error)
return redirect(url_for('spectrum', spid=s.id, error=error))
return render_template('upload.html', error='upload error')
def submit_upload():
session_init(session, db)
error=None
if session['username'] is None:
error='must be logged in to submit a spectrum'
return redirect(url_for('search', error=error))
if request.method == 'POST':
pid = request.form['person']
pemail = db.get_person(int(pid)).email
file = request.files['file']
s = None
file_ok = False
if file and allowed_file(file.filename):
fname = secure_filename(file.filename)
fullpath = os.path.abspath(os.path.join(
app.config['UPLOAD_FOLDER'], fname))
try:
file.save(fullpath)
file_ok = True
except IOError:
pass
if file_ok:
time.sleep(1.0)
db.add_xdifile(fullpath, person=pemail, create_sample=True)
time.sleep(1.0)
db.session.commit()
s = db.get_spectra()[-1]
if s is None:
error = 'Could not find Spectrum #%i' % s.id
return render_template('upload.html', error=error)
if s is None:
error = "File '%s' not found or not suppported type" % (file.filename)
return render_template('upload.html', error=error)
try:
opts = parse_spectrum(s, db)
except:
error = "Could not read spectrum from '%s'" % (file.filename)
return render_template('upload.html', error=error)
return redirect(url_for('spectrum', spid=s.id, error=error))
return render_template('upload.html', error='upload error')
def edit_spectrum(spid=None):
session_init(session, db)
error = None
if session['username'] is None:
error = 'must be logged in to edit spectrum'
return render_template('ptable.html', error=error)
s = db.get_spectrum(spid)
if s is None:
error = 'Could not find Spectrum #%i' % spid
return render_template('ptable.html', error=error)
opts = parse_spectrum(s, db)
return render_template('editspectrum.html',
error=error,
elems=get_element_list(db),
eunits=get_energy_units_list(db),
edges=get_edge_list(db),
beamlines=get_beamline_list(db),
samples=get_sample_list(db),
**opts)
def edit_spectrum(spid=None):
session_init(session, db)
error=None
if session['username'] is None:
error='must be logged in to edit spectrum'
return render_template('ptable.html',
error=error)
s = db.get_spectrum(spid)
if s is None:
error = 'Could not find Spectrum #%i' % spid
return render_template('ptable.html', error=error)
opts = parse_spectrum(s, db)
return render_template('editspectrum.html', error=error,
elems=get_element_list(db),
eunits=get_energy_units_list(db),
edges=get_edge_list(db),
beamlines=get_beamline_list(db),
samples=get_sample_list(db),
**opts)
def showspectrum_rating(spid=None):
session_init(session, db)
s = db.get_spectrum(spid)
if s is None:
error = 'Could not find Spectrum #%i' % spid
return render_template('ptable.html', error=error)
opts = parse_spectrum(s, db)
ratings = []
for score, review, dtime, pid in spectrum_ratings(db, spid):
person = db.get_person(pid)
ratings.append({'score': score,
'review': multiline_text(review),
'date': fmttime(dtime),
'person_email': person.email,
'person_name': person.name,
'person_affil': person.affiliation})
return render_template('show_spectrum_ratings.html',
ratings=ratings,
spectrum_name=opts['spectrum_name'])
def _optimize_nuisance_parameters(self, dispersion, flux, ivar, grid_index,
**kwargs):
"""
Optimize nuisance parameters at a single grid point. Note that no
slicing and masking is performed to the data by this function.
:param dispersion:
The observed dispersion points.
:param flux:
The observed flux values.
:param ivar:
The inverse variance values for the observed fluxes.
:param grid_index:
The grid index.
"""
return_model_spectrum = kwargs.pop("__return_model_spectrum", False)
# Load the spectrum from the grid.
model_disp, model_flux = utils.parse_spectrum(self.paths[grid_index]).T
kwds = {
"f": lambda x, *theta: \
self.fitting_function(x, model_disp, model_flux, *theta),
"xdata": dispersion,
"ydata": flux,
"sigma": ivar,
"absolute_sigma": False,
"p0": self.initial_guess(dispersion, flux),
"full_output": True,
"maxfev": 10000
}
kwds.update(kwargs)
result = op.curve_fit(**kwds)
return tuple(list(result) + [model_disp, model_flux]) \
if return_model_spectrum else result
def showspectrum_rating(spid=None):
session_init(session, db)
s = db.get_spectrum(spid)
if s is None:
error = 'Could not find Spectrum #%i' % spid
return render_template('ptable.html', error=error)
opts = parse_spectrum(s, db)
ratings = []
for score, review, dtime, pid in spectrum_ratings(db, spid):
person = db.get_person(pid)
ratings.append({
'score': score,
'review': multiline_text(review),
'date': fmttime(dtime),
'person_email': person.email,
'person_name': person.name,
'person_affil': person.affiliation
})
return render_template('show_spectrum_ratings.html',
ratings=ratings,
spectrum_name=opts['spectrum_name'])
def plot_projection(self,
data,
ax=None,
index=None,
sample_cov=0,
**kwargs):
if ax is None:
fig, ax = plt.subplots()
else:
fig = ax.figure
obs_dispersion, obs_flux, obs_ivar = self._slice_spectrum(data)
# Apply masks.
mask = _generate_mask(obs_dispersion, self.metadata["mask"]) \
* np.isfinite(obs_flux * obs_ivar)
if 0 in (obs_dispersion.size, mask.sum()):
raise ValueError("no overlapping spectra with finite flux/ivar")
#obs_dispersion = obs_dispersion[mask]
#obs_flux, obs_ivar = obs_flux[mask], obs_ivar[mask]
_ = np.where(mask)[0]
si, ei = _[0], _[-1]
# Show uncertainties.
obs_sigma = np.sqrt(1.0 / obs_ivar)
fill_between_steps(ax,
obs_dispersion[si:ei],
obs_flux[si:ei] - obs_sigma[si:ei],
obs_flux[si:ei] + obs_sigma[si:ei],
facecolor="#AAAAAA",
edgecolor="none",
alpha=1)
# Limit to the edge of what is OK.
ax.plot(obs_dispersion[si:ei],
obs_flux[si:ei],
c="#444444",
drawstyle="steps-mid")
obs_flux[~mask] = np.nan
ax.plot(obs_dispersion, obs_flux, c='k', drawstyle="steps-mid")
# Get the MAP value.
if index is None:
index = np.nanargmax(self._inference_result[1])
op_theta = self._inference_result[3][index]
model_disp, model_flux = utils.parse_spectrum(self.paths[index]).T
y = self(obs_dispersion, model_disp, model_flux, *op_theta)
y[~mask] = np.nan
c = kwargs.pop("c", "r")
ax.plot(obs_dispersion, y, c=c, **kwargs)
# Get the covariance matrix?
if sample_cov > 0:
cov = self._inference_result[4][index]
print(np.sqrt(np.diag(cov)))
# Sample values from the cov matrix and project them.
draws = np.random.multivariate_normal(
self._inference_result[3][index],
self._inference_result[4][index],
size=sample_cov)
for draw in draws:
y_draw = self(obs_dispersion, model_disp, model_flux, *draw)
y_draw[~mask] = np.nan
ax.plot(obs_dispersion, y_draw, c=c, alpha=10.0 / sample_cov)
# Draw fill_between in y?
ax.set_title("Index {}: {}".format(index,
self.stellar_parameters[index]))
return fig
def _get_wavelength_limits(self, path):
wavelengths = utils.parse_spectrum(self.paths[0])[:, 0]
return (min(wavelengths), max(wavelengths))
def spectrum(spid=None):
session_init(session, db)
s = db.get_spectrum(spid)
if s is None:
error = 'Could not find Spectrum #%i' % spid
return render_template('ptable.html', error=error)
opts = parse_spectrum(s, db)
opts['spectrum_owner'] = (session['person_id'] == "%i" % s.person_id)
opts['rating'] = get_rating(s)
modes = db.get_spectrum_mode(spid)
if modes is None:
modes = 1
else:
modes = modes[0][1]
if modes == 1:
try:
energy = np.array(json.loads(s.energy))
i0 = np.array(json.loads(s.i0))
itrans = np.array(json.loads(s.itrans))
mutrans = -np.log(itrans / i0)
except:
error = 'Could not extract data from spectrum'
return render_template('spectrum.html', **opts)
else: #get a fluorescence
try:
energy = np.array(json.loads(s.energy))
i0 = np.array(json.loads(s.i0))
ifluor = np.array(json.loads(s.ifluor))
mutrans = ifluor / i0
except:
error = 'Could not extract data from spectrum'
return render_template('spectrum.html', **opts)
murefer = None
try:
irefer = np.array(json.loads(s.irefer))
murefer = -np.log(irefer / itrans)
except:
pass
eunits = opts['energy_units']
if eunits.startswith('keV'):
energy = energy / 1000.0
elif eunits.startswith('deg'):
print 'Need to convert angle to energy'
if modes != 7:
group = preedge(energy, mutrans)
e0 = group['e0']
try:
e0 = edge_energies[int(s.element_z)][str(opts['edge'])]
except:
pass
try:
i1 = max(np.where(energy <= e0 - 25)[0])
except:
i1 = 0
i2 = max(np.where(energy <= e0 + 75)[0]) + 1
xanes_en = energy[i1:i2] - e0
if modes != 3:
xanes_mu = group['norm'][i1:i2]
else:
xanes_mu = mutrans[i1:i2]
xanes_ref = None
if murefer is not None:
rgroup = preedge(energy, murefer)
xanes_ref = rgroup['norm'][i1:i2]
opts['e0'] = '%f' % e0
opts['fullfig'] = make_xafs_plot(energy,
mutrans,
s.name,
ylabel='Raw XAFS')
opts['xanesfig'] = make_xafs_plot(xanes_en,
xanes_mu,
s.name,
xlabel='Energy-%.1f (eV)' % e0,
ylabel='Normalized XANES',
x0=e0,
ref_mu=xanes_ref,
ref_name='with reference')
suites = []
for r in db.filtered_query('spectrum_suite', spectrum_id=s.id):
st = db.filtered_query('suite', id=r.suite_id)[0]
suites.append({'id': r.suite_id, 'name': st.name})
opts['nsuites'] = len(suites)
opts['suites'] = suites
return render_template('spectrum.html', **opts)
def spectrum(spid=None):
session_init(session, db)
s = db.get_spectrum(spid)
if s is None:
error = 'Could not find Spectrum #%i' % spid
return render_template('ptable.html', error=error)
opts = parse_spectrum(s, db)
opts['spectrum_owner'] = (session['person_id'] == "%i" % s.person_id)
opts['rating'] = get_rating(s)
modes = db.get_spectrum_mode(spid)
if modes is None:
modes = 1
else:
modes = modes[0][1]
if modes == 1:
try:
energy = np.array(json.loads(s.energy))
i0 = np.array(json.loads(s.i0))
itrans = np.array(json.loads(s.itrans))
mutrans = -np.log(itrans/i0)
except:
error = 'Could not extract data from spectrum'
return render_template('spectrum.html', **opts)
else: #get a fluorescence
try:
energy = np.array(json.loads(s.energy))
i0 = np.array(json.loads(s.i0))
ifluor = np.array(json.loads(s.ifluor))
mutrans = ifluor/i0
except:
error = 'Could not extract data from spectrum'
return render_template('spectrum.html', **opts)
murefer = None
try:
irefer = np.array(json.loads(s.irefer))
murefer = -np.log(irefer/itrans)
except:
pass
eunits = opts['energy_units']
if eunits.startswith('keV'):
energy = energy /1000.0
elif eunits.startswith('deg'):
print 'Need to convert angle to energy'
if modes != 7:
group = preedge(energy, mutrans)
e0 = group['e0']
try:
e0 = edge_energies[int(s.element_z)][str(opts['edge'])]
except:
pass
try:
i1 = max(np.where(energy<=e0 - 25)[0])
except:
i1 = 0
i2 = max(np.where(energy<=e0 + 75)[0]) + 1
xanes_en = energy[i1:i2] - e0
if modes !=3:
xanes_mu = group['norm'][i1:i2]
else:
xanes_mu = mutrans[i1:i2]
xanes_ref = None
if murefer is not None:
rgroup = preedge(energy, murefer)
xanes_ref = rgroup['norm'][i1:i2]
opts['e0'] = '%f' % e0
opts['fullfig'] = make_xafs_plot(energy, mutrans, s.name,
ylabel='Raw XAFS')
opts['xanesfig'] = make_xafs_plot(xanes_en, xanes_mu, s.name,
xlabel='Energy-%.1f (eV)' % e0,
ylabel='Normalized XANES',
x0=e0, ref_mu=xanes_ref,
ref_name='with reference')
suites = []
for r in db.filtered_query('spectrum_suite', spectrum_id=s.id):
st = db.filtered_query('suite', id=r.suite_id)[0]
suites.append({'id': r.suite_id, 'name': st.name})
opts['nsuites'] = len(suites)
opts['suites'] = suites
return render_template('spectrum.html', **opts)