def element(elem=None):
edges = atomic = lines = {}
if elem is not None:
atomic = {
'n': xraydb.atomic_number(elem),
'mass': xraydb.atomic_mass(elem),
'density': xraydb.atomic_density(elem)
}
_edges = xraydb.xray_edges(elem)
_lines = xraydb.xray_lines(elem)
lines = OrderedDict()
for k in sorted(_lines.keys()):
en, inten, init, final = _lines[k] # XrayLine
lines[k] = XrayLine(energy=f'{en:.1f}',
intensity=f'{inten:.5f}',
initial_level=init,
final_level=final)
edges = OrderedDict()
for k in sorted(_edges.keys()):
en, fy, jump = _edges[k] # XrayEdge
edges[k] = XrayEdge(energy=f'{en:.1f}',
fyield=f'{fy:.5f}',
jump_ratio=f'{jump:.3f}')
return render_template('elements.html',
edges=edges,
elem=elem,
atomic=atomic,
lines=lines,
materials_dict=materials_dict)
def test_emission_lines():
cu_lines = xray_lines('Cu')
for lname in ('Ka3', 'Ka2', 'Ka1', 'Kb3', 'Kb1', 'Kb5', 'Lb4', 'Lb3', 'Ln',
'Lb1', 'Ll', 'La2', 'La1'):
assert (lname in cu_lines)
assert cu_lines['Ka1'].energy > 8045.0
assert cu_lines['Ka1'].energy < 8047.0
assert cu_lines['Ka1'].initial_level == 'K'
assert cu_lines['Ka1'].final_level == 'L3'
def darwinwidth(elem=None):
edges = atomic = lines = {}
if elem is not None:
edges= xraydb.xray_edges(elem)
atomic= {'n': xraydb.atomic_number(elem),
'mass': xraydb.atomic_mass(elem),
'density': xraydb.atomic_density(elem)}
lines= xraydb.xray_lines(elem)
return render_template('darwinwidth.html', edges=edges, elem=elem,
atomic=atomic, lines=lines, materials_dict=materials_dict)
def find_xray_line(z, edge):
"""
Finds most intense X-ray emission line energy for a given element and edge.
"""
intensity = 0
line = ''
for key, value in xray_lines(z).items() :
if value.initial_level == edge.upper():
if value.intensity > intensity:
intensity = value.intensity
line = key
return xray_line(z, line[:-1])
def element(elem=None):
edges = atomic = lines = {}
if elem is not None:
atomic= {'n': xraydb.atomic_number(elem),
'mass': xraydb.atomic_mass(elem),
'density': xraydb.atomic_density(elem)}
_edges= xraydb.xray_edges(elem)
_lines= xraydb.xray_lines(elem)
lines = OrderedDict()
for k in sorted(_lines.keys()):
lines[k] = _lines[k]
edges = OrderedDict()
for k in sorted(_edges.keys()):
edges[k] = _edges[k]
return render_template('elements.html', edges=edges, elem=elem,
atomic=atomic, lines=lines, materials_dict=materials_dict)
def MakeFLlinesDictionary(sample_size, sample_size_l, element_name,
fl_lines_xdb, fl_lines, probe_energy, an_lib,
det_energy_u, n_det_energy_bins):
voxel_size = sample_size_l / sample_size
FL_dic = {'element': element_name}
fl_cs_ls = xlib_np.CS_FluorLine_Kissel_Cascade(
np.array([an_lib[element_name]]), fl_lines, probe_energy)
i = 0
detected_fl_unit_concentration = np.zeros((n_det_energy_bins * 2))
det_energy_list_full = np.linspace(
-det_energy_u + det_energy_u / n_det_energy_bins, det_energy_u,
n_det_energy_bins * 2)
for name, line in xdb.xray_lines(element_name).items():
if name in set(fl_lines_xdb):
idx_nearest, value_nearest = find_nearest(det_energy_list_full,
line[0])
detected_fl_unit_concentration[idx_nearest] += fl_cs_ls[0, i][0]
i += 1
FL_dic['detected_fl_unit'] = detected_fl_unit_concentration * voxel_size
return FL_dic
def test_xray_line():
cuk = xray_line('Cu', 'K')
assert_allclose(cuk.energy, 8039.626, rtol=0.001)
assert_allclose(cuk.intensity, 0.8716833, rtol=0.001)
assert cuk.final_level == 'L'
cuka = xray_line('Cu', 'Ka1')
assert_allclose(cuka.energy, 8046.3, rtol=0.001)
assert_allclose(cuka.intensity, 0.5771, rtol=0.001)
assert cuka.final_level == 'L3'
ti_klines = xray_lines('Ti', 'K')
for line in ('Ka1', 'Ka2', 'Ka3', 'Kb1', 'Kb3', 'Kb5'):
assert ti_klines[line].initial_level == 'K'
assert_allclose(ti_klines['Ka1'].energy, 4512.2, rtol=0.001)
assert_allclose(ti_klines['Ka2'].energy, 4505.8, rtol=0.001)
assert_allclose(ti_klines['Ka3'].energy, 4405.1, rtol=0.001)
assert_allclose(ti_klines['Kb1'].energy, 4933.4, rtol=0.001)
assert_allclose(ti_klines['Kb3'].energy, 4933.4, rtol=0.001)
assert_allclose(ti_klines['Kb5'].energy, 4964.0, rtol=0.001)
assert_allclose(ti_klines['Ka1'].intensity, 0.58455, rtol=0.001)
assert_allclose(ti_klines['Ka2'].intensity, 0.29369, rtol=0.001)
assert_allclose(ti_klines['Ka3'].intensity, 0.000235, rtol=0.01)
assert_allclose(ti_klines['Kb1'].intensity, 0.07965, rtol=0.001)
assert_allclose(ti_klines['Kb3'].intensity, 0.04126, rtol=0.001)
assert_allclose(ti_klines['Kb5'].intensity, 0.000607, rtol=0.01)
assert_allclose(ti_klines['Ka1'].intensity, 0.58455, rtol=0.001)
assert ti_klines['Ka1'].final_level == 'L3'
assert ti_klines['Ka2'].final_level == 'L2'
assert ti_klines['Ka3'].final_level == 'L1'
assert ti_klines['Kb1'].final_level == 'M3'
assert ti_klines['Kb3'].final_level == 'M2'
assert ti_klines['Kb5'].final_level == 'M4,5'
def __init__(self,
symbol,
xray_energy=None,
energy_min=1.5,
overlap_energy=None):
self.symbol = symbol
self.xray_energy = xray_energy
self.mu = 1.0
self.edges = ['K']
self.fyields = {}
if xray_energy is not None:
self.mu = mu_elam(symbol, 1000 * xray_energy, kind='photo')
self.edges = []
for ename, xedge in xray_edges(self.symbol).items():
if ename.lower() in ('k', 'l1', 'l2', 'l3', 'm5'):
edge_kev = 0.001 * xedge.energy
if (edge_kev < xray_energy and edge_kev > energy_min):
self.edges.append(ename)
self.fyields[ename] = xedge.fyield
# currently, we consider only one edge per element
if 'K' in self.edges:
self.edges = ['K']
if 'L3' in self.edges:
tmp = []
for ename in self.edges:
if ename.lower().startswith('l'):
tmp.append(ename)
self.edges = tmp
# apply CK corrections to fluorescent yields
if 'L3' in self.edges:
nlines = 1.0
ck13 = ck_probability(symbol, 'L1', 'L3')
ck12 = ck_probability(symbol, 'L1', 'L2')
ck23 = ck_probability(symbol, 'L2', 'L3')
fy3 = self.fyields['L3']
fy2 = self.fyields.get('L2', 0)
fy1 = self.fyields.get('L1', 0)
if 'L2' in self.edges:
nlines = 2.0
fy3 = fy3 + fy2 * ck23
fy2 = fy2 * (1 - ck23)
if 'L1' in self.edges:
nlines = 3.0
fy3 = fy3 + fy1 * (ck13 + ck12 * ck23)
fy2 = fy2 + fy1 * ck12
fy1 = fy1 * (1 - ck12 - ck13 - ck12 * ck23)
self.fyields['L1'] = fy1
self.fyields['L2'] = fy2
self.fyields['L3'] = fy3 / nlines
self.fyields['L2'] = fy2 / nlines
self.fyields['L1'] = fy1 / nlines
# look up X-ray lines, keep track of very close lines
# so that they can be consolidate
# slightly confusing (and working with XrayLine energies in ev)
self.lines = {}
self.all_lines = {}
energy0 = None
for ename in self.edges:
for key, xline in xray_lines(symbol, ename).items():
self.all_lines[key] = xline
if xline.intensity > 0.002:
self.lines[key] = xline
if energy0 is None:
energy0 = xline.energy
if overlap_energy is None:
if xray_energy is None: xray_energy = 10.0
if energy0 is not None: xray_energy = energy0
# note: at this point xray_energy is in keV
overlap_energy = 5.0 * (2 + np.sqrt(5 + xray_energy))
# collect lines from the same initial level that are close in energy
nlines = len(self.lines)
combos = [[] for k in range(nlines)]
comboe = [-1 for k in range(nlines)]
combol = [None for k in range(nlines)]
for key, xline in self.lines.items():
assigned = False
for i, en in enumerate(comboe):
if (abs(0.001 * xline.energy - en) < overlap_energy
and xline.initial_level == combol[i]):
combos[i].append(key)
assigned = True
break
if not assigned:
for k in range(nlines):
if comboe[k] < 0:
break
combol[k] = xline.initial_level
comboe[k] = xline.energy
combos[k].append(key)
# consolidate overlapping X-ray lines
for comps in combos:
if len(comps) > 0:
key = comps[0]
l0 = self.lines.pop(key)
ilevel = l0.initial_level
iweight = l0.intensity
flevel = [l0.final_level]
en = [l0.energy]
wt = [l0.intensity]
for other in comps[1:]:
lx = self.lines.pop(other)
if lx.intensity > iweight:
iweight = lx.intensity
ilevel = lx.initial_level
flevel.append(lx.final_level)
en.append(lx.energy)
wt.append(lx.intensity)
wt = np.array(wt)
en = np.array(en)
flevel = ', '.join(flevel)
if len(comps) > 1:
newkey = key.replace('1', '').replace('2',
'').replace('3', '')
newkey = newkey.replace('4',
'').replace('5',
'').replace(',', '')
if newkey not in self.lines:
key = newkey
self.lines[key] = XrayLine(energy=(en * wt).sum() / wt.sum(),
intensity=wt.sum(),
initial_level=ilevel,
final_level=flevel)
def test_xray_lines_levels():
assert len(xray_lines('Hg', excitation_energy=2800)) == 2
assert len(xray_lines('Hg', excitation_energy=12000)) == 3
assert len(xray_lines('Hg', excitation_energy=12500)) == 9
assert len(xray_lines('Hg', excitation_energy=14300)) == 13
assert len(xray_lines('Hg', excitation_energy=16000)) == 17
'7 7 7', '8 0 0', '8 2 2', '8 4 0', '8 4 4', '8 6 2', '8 6 6',
'8 8 0', '8 8 4', '8 8 8', '9 1 1', '9 3 1', '9 5 1', '9 5 3',
'9 5 5', '9 7 1', '9 7 3', '9 7 5', '9 7 7', '9 9 1', '9 9 3',
'9 9 5', '9 9 7', '9 9 9', '10 2 0', '10 4 2', '10 6 0', '10 6 4',
'10 8 2', '10 10 0', '10 10 4', '10 10 8', '11 1 1', '11 3 1',
'11 3 3', '11 5 1', '11 5 3', '11 5 5', '11 7 1', '11 7 3',
'11 7 5', '11 7 7', '11 9 1', '11 9 3', '11 9 5', '11 9 7',
'11 9 9', '11 11 1', '11 11 3', '11 11 5', '11 11 7', '11 11 9',
'11 11 11')
emission_energies = {}
analyzer_lines = ('Ka1', 'Ka2', 'Ka3', 'Kb1', 'Kb3', 'Kb5', 'La1', 'La2',
'Lb1', 'Lb3')
for z in range(1, 96):
atsym = xraydb.atomic_symbol(z)
xlines = xraydb.xray_lines(z)
for line in analyzer_lines:
key = '%s_%s' % (atsym, line)
en = xlines.get(line, None)
if en is None:
emission_energies[key] = '0'
else:
emission_energies[key] = '%.0f' % (en.energy)
emission_energies_json = json.dumps(emission_energies)
PY_TOP = """#!/usr/bin/env python
# this script requires Python3, numpy, matplotlib, and xraydb modules. Use:
# pip install xraydb
import numpy as np
import matplotlib.pyplot as plt
