def parser(compounds):
comp = xraylib.CompoundParser(compounds)
stoic_allowed = range(10)
stoic_allowed = map(str, stoic_allowed)
stoic_allowed.append('.')
_compounds = list(compounds)
elements = comp['Elements']
stoic = []
for i in elements:
symb = xraylib.AtomicNumberToSymbol(i)
ind = compounds.find(symb) + len(symb)
if ind >= len(_compounds):
stoic.append(1.0)
else:
if _compounds[ind] not in stoic_allowed:
stoic.append(1.0)
else:
temp = []
while _compounds[ind] in stoic_allowed:
temp.append(_compounds[ind])
ind += 1
if ind >= len(_compounds):
break
temp = ''.join(temp)
stoic.append(float(temp))
mw = np.sum(
np.asarray(stoic) * np.asarray(map(xraylib.AtomicWeight, elements)))
return elements, stoic, mw
def parse_compound(compund):
'''
Parse chemical formula
'''
import xraylib
return xraylib.CompoundParser(compund)
def test_H2SO4(self):
cd = xraylib.CompoundParser('H2SO4')
self.assertEqual(cd['nElements'], 3)
self.assertEqual(cd['molarMass'], 98.09)
self.assertEqual(cd['nAtomsAll'], 7.0)
self.assertEqual(cd['Elements'], (1, 8, 16))
self.assertAlmostEqual(
cd['massFractions'],
(0.02059333265368539, 0.6524620246712203, 0.32694464267509427))
self.assertAlmostEqual(cd['nAtoms'], (2.0, 4.0, 1.0))
def setUpClass(cls):
if not XmiMsim.Job.is_suspend_available():
raise
XmiMsim.init_hdf5()
cls.cd = xrl.CompoundParser(cls.COMPOUND)
if cls.cd is None:
raise
cls.data_file = os.environ['HDF5_DATA_DIR'] + "/xmimsimdata-" + cls.COMPOUND + ".h5"
logging.debug("data_file: {}".format(cls.data_file))
if XmiMsim.db(cls.data_file, cls.cd['Elements']) is not 1:
raise
def validate_str(*s):
boo = []
for i in s:
try:
if xraylib.SymbolToAtomicNumber(i) != 0:
boo.append(True)
elif xraylib.CompoundParser(i):
boo.append(True)
else:
boo.append(False)
except:
return False
return all(boo)
def getMaterialDensity(cls, material_formula):
if material_formula is None: return 0.0
if str(material_formula.strip()) == "": return 0.0
try:
compoundData = xraylib.CompoundParser(material_formula)
if compoundData["nElements"] == 1:
return xraylib.ElementDensity(compoundData["Elements"][0])
else:
return 0.0
except:
return 0.0
def parse_compound_formula(compound_formula):
r"""
Parses the chemical formula of a compound and returns the dictionary,
which contains element name, atomic number, number of atoms and mass fraction
in the compound.
Parameters
----------
compound_formula: str
chemical formula of the compound in the form ``FeO2``, ``CO2`` or ``Fe``.
Element names must start with capital letter.
Returns
-------
dictionary of dictionaries, data on each element in the compound: key -
sybolic element name, value - a dictionary that contains ``AtomicNumber``,
``nAtoms`` and ``massFraction`` of the element. The elements are sorted
in the order of growing atomic number.
Raises
------
RuntimeError is raised if compound formula cannot be parsed
"""
if LooseVersion(xraylib.__version__) < LooseVersion("4.0.0"):
xraylib.SetErrorMessages(
0) # This is supposed to stop XRayLib from printing
# internal error messages, but it doesn't work
try:
compound_data = xraylib.CompoundParser(compound_formula)
except (SystemError, ValueError):
msg = f"Invalid chemical formula '{compound_formula}' is passed, parsing failed"
raise RuntimeError(msg)
# Now create more manageable structure
compound_dict = {}
for e_an, e_mf, e_na in zip(compound_data["Elements"],
compound_data["massFractions"],
compound_data["nAtoms"]):
e_name = xraylib.AtomicNumberToSymbol(e_an)
compound_dict[e_name] = {
"AtomicNumber": e_an,
"nAtoms": e_na,
"massFraction": e_mf
}
return compound_dict
def get_application_data(data, **kwargs):
if data['method'] == 'validate_material':
name = data['material_name']
try:
xraylib.CompoundParser(str(name))
return {
'material_name': name,
}
except Exception:
return {
'error': 'invalid material name',
}
raise RuntimeError('unknown application data method: {}'.format(
data['method']))
def el_select(self):
Z = self.el_cb.currentIndex()
if Z > 0:
self.nist_cb.setCurrentIndex(0)
self.cp_le.setText("")
if self.name == "bet": self.chkbox_luxelht.setChecked(False)
self.mat = xrl.CompoundParser(xrl.AtomicNumberToSymbol(Z))
self.mat['name'] = xrl.AtomicNumberToSymbol(Z)
self.apply_mat_thickness()
self.mat['density'] = xrl.ElementDensity(Z)
self.mat_dens_le.setText(str(self.mat['density']))
self.apply_mat_density()
else:
self.mat = {}
def apply_mat_cp(self):
if self.cp_le.text() == "":
self.mat = {}
return
try:
self.nist_cb.setCurrentIndex(0)
self.el_cb.setCurrentIndex(0)
if self.name == "bet": self.chkbox_luxelht.setChecked(False)
self.mat = xrl.CompoundParser(self.cp_le.text())
self.mat['name'] = self.cp_le.text()
self.apply_mat_thickness()
self.apply_mat_density()
except:
self.mat = {}
def material_refraction(energy, compound, rho):
"""
Calculate complex refrative index of the material taking
into account it's density.
Args:
compound (str): compound chemical formula
rho (float): density in g / cm3
energy (numpy.array): energy in KeV
Returns:
float: refraction index in [1/mm]
"""
import xraylib
cmp = xraylib.CompoundParser(compound)
# Compute ration of Z and A:
z = (numpy.array(cmp['Elements']))
a = [xraylib.AtomicWeight(x) for x in cmp['Elements']]
za = ((z / a) * numpy.array(cmp['massFractions'])).sum()
# Electron density of the material:
Na = phys_const['Na']
rho_e = rho * za * Na
# Attenuation:
mu = mass_attenuation(energy, compound)
# Phase:
wavelength = 2 * numpy.pi * \
(phys_const['h_bar_ev'] * phys_const['c']) / energy * 10
# TODO: check this against phantoms.m:
phi = rho_e * phys_const['re'] * wavelength
# Refraction index (per mm)
return rho * (mu / 2 - 1j * phi) / 10
def test_good_compounds(self):
self.assertIsInstance(xraylib.CompoundParser("C19H29COOH"), dict)
self.assertIsInstance(xraylib.CompoundParser("C12H10"), dict)
self.assertIsInstance(xraylib.CompoundParser("C12H6O2"), dict)
self.assertIsInstance(xraylib.CompoundParser("C6H5Br"), dict)
self.assertIsInstance(xraylib.CompoundParser("C3H4OH(COOH)3"), dict)
self.assertIsInstance(xraylib.CompoundParser("HOCH2CH2OH"), dict)
self.assertIsInstance(xraylib.CompoundParser("C5H11NO2"), dict)
self.assertIsInstance(xraylib.CompoundParser("CH3CH(CH3)CH3"), dict)
self.assertIsInstance(xraylib.CompoundParser("NH2CH(C4H5N2)COOH"),
dict)
self.assertIsInstance(xraylib.CompoundParser("H2O"), dict)
self.assertIsInstance(xraylib.CompoundParser("Ca5(PO4)3F"), dict)
self.assertIsInstance(xraylib.CompoundParser("Ca5(PO4)3OH"), dict)
self.assertIsInstance(xraylib.CompoundParser("Ca5.522(PO4.48)3OH"),
dict)
self.assertIsInstance(xraylib.CompoundParser("Ca5.522(PO.448)3OH"),
dict)
def test_bad_compounds(self):
with self.assertRaises(ValueError):
xraylib.CompoundParser("CuI2ww")
with self.assertRaises(ValueError):
xraylib.CompoundParser("0C")
with self.assertRaises(ValueError):
xraylib.CompoundParser("2O")
with self.assertRaises(ValueError):
xraylib.CompoundParser("13Li")
with self.assertRaises(ValueError):
xraylib.CompoundParser("2(NO3)")
with self.assertRaises(ValueError):
xraylib.CompoundParser("H(2)")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Ba(12)")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Cr(5)3")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Pb(13)2")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Au(22)11")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Au11(H3PO4)2)")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Au11(H3PO4))2")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Au(11(H3PO4))2")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Ca5.522(PO.44.8)3OH")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Ba[12]")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Auu1")
with self.assertRaises(ValueError):
xraylib.CompoundParser("AuL1")
with self.assertRaises(ValueError):
xraylib.CompoundParser(None)
with self.assertRaises(ValueError):
xraylib.CompoundParser(" ")
with self.assertRaises(ValueError):
xraylib.CompoundParser("\t")
with self.assertRaises(ValueError):
xraylib.CompoundParser("\n")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Au L1")
with self.assertRaises(ValueError):
xraylib.CompoundParser("Au\tFe")
with self.assertRaises(TypeError):
xraylib.CompoundParser(26)
xraylib.LineEnergy(20, xraylib.KA_LINE)))
print("Fe partial photoionization cs of L3 at 6.0 keV: {}".format(
xraylib.CS_Photo_Partial(26, xraylib.L3_SHELL, 6.0)))
print("Zr L1 edge energy: {}".format(xraylib.EdgeEnergy(40, xraylib.L1_SHELL)))
print("Pb Lalpha XRF production cs at 20.0 keV (jump approx): {}".format(
xraylib.CS_FluorLine(82, xraylib.LA_LINE, 20.0)))
print("Pb Lalpha XRF production cs at 20.0 keV (Kissel): {}".format(
xraylib.CS_FluorLine_Kissel(82, xraylib.LA_LINE, 20.0)))
print("Bi M1N2 radiative rate: {}".format(
xraylib.RadRate(83, xraylib.M1N2_LINE)))
print("U M3O3 Fluorescence Line Energy: {}".format(
xraylib.LineEnergy(92, xraylib.M3O3_LINE)))
print("Ca(HCO3)2 Rayleigh cs at 10.0 keV: {}".format(
xraylib.CS_Rayl_CP("Ca(HCO3)2", 10.0)))
cdtest = xraylib.CompoundParser("Ca(HCO3)2")
print(
"Ca(HCO3)2 contains {} atoms, {} elements and has a molar mass of {} g/mol"
.format(cdtest['nAtomsAll'], cdtest['nElements'], cdtest['molarMass']))
for i in range(cdtest['nElements']):
print("Element {}: %lf %% and {} atoms".format(
cdtest['Elements'][i], cdtest['massFractions'][i] * 100.0,
cdtest['nAtoms'][i]))
cdtest = xraylib.CompoundParser("SiO2")
print("SiO2 contains {} atoms, {} elements and has a molar mass of {} g/mol".
format(cdtest['nAtomsAll'], cdtest['nElements'], cdtest['molarMass']))
for i in range(cdtest['nElements']):
print("Element {}: %lf %% and {} atoms".format(
cdtest['Elements'][i], cdtest['massFractions'][i] * 100.0,
cdtest['nAtoms'][i]))
def prerefl():
"""
Preprocessor for mirrors - python+xraylib version
-"""
# retrieve physical constants needed
codata = scipy.constants.codata.physical_constants
codata_c, tmp1, tmp2 = codata["speed of light in vacuum"]
codata_h, tmp1, tmp2 = codata["Planck constant"]
codata_ec, tmp1, tmp2 = codata["elementary charge"]
# or hard code them
# In [174]: print("codata_c = %20.11e \n" % codata_c )
# codata_c = 2.99792458000e+08
# In [175]: print("codata_h = %20.11e \n" % codata_h )
# codata_h = 6.62606930000e-34
# In [176]: print("codata_ec = %20.11e \n" % codata_ec )
# codata_ec = 1.60217653000e-19
tocm = codata_h*codata_c/codata_ec*1e2
# input section
print("prerefl: Preprocessor for mirrors - python+xraylib version")
iMaterial = raw_input("Enter material expression (symbol,formula): ")
density = raw_input("Density [ g/cm3 ] ?")
density = float(density)
estart = raw_input("Enter starting photon energy: ")
estart = float(estart)
efinal = raw_input("Enter end photon energy: ")
efinal = float(efinal)
estep = raw_input("Enter step photon energy:")
estep = float(estep)
out_file = raw_input("Output file : ")
twopi = math.pi*2
npoint = int( (efinal-estart)/estep + 1 )
depth0 = density/2.0
qmin = estart/tocm*twopi
qmax = efinal/tocm*twopi
qstep = estep/tocm*twopi
f = open(out_file, 'wb')
f.write( ("%20.11e "*4+"\n") % tuple([qmin,qmax,qstep,depth0]) )
f.write("%i \n" % int(npoint))
for i in range(npoint):
energy = (estart+estep*i)*1e-3
tmp = 2e0*(1e0-xraylib.Refractive_Index_Re(iMaterial,energy,density))
f.write("%e \n" % tmp)
for i in range(npoint):
energy = (estart+estep*i)*1e-3
tmp2 = 2e0*(xraylib.Refractive_Index_Im(iMaterial,energy,density))
f.write("%e \n" % tmp2)
print("File written to disk: %s" % out_file)
f.close()
# test (not needed)
itest = 0
if itest:
cdtest = xraylib.CompoundParser(iMaterial)
print " ",iMaterial," contains %i atoms and %i elements"% (cdtest['nAtomsAll'], cdtest['nElements'])
for i in range(cdtest['nElements']):
print " Element %i: %lf %%" % (cdtest['Elements'][i],cdtest['massFractions'][i]*100.0)
print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
print qmin,qmax,qstep,depth0
print npoint
for i in range(npoint):
energy = (estart+estep*i)*1e-3
qq = qmin+qstep*i
print energy,qq, \
2e0*(1e0-xraylib.Refractive_Index_Re(iMaterial,energy,density)),\
2e0*(xraylib.Refractive_Index_Im(iMaterial,energy,density))
print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
return None
def Reflectivity_coated(E,
theta,
sub_mat,
coat_mat,
coat_thickness,
f1f2data='default',
f1f2interp='linear'):
E = np.asarray(E, dtype=np.float64)
scalar_E = False
if E.ndim == 0:
E = E[None]
scalar_E = True
sub_Z = xl.SymbolToAtomicNumber(sub_mat)
if f1f2data == 'default':
f1f2_sub = get_Ef1f2(sub_Z)
else:
f1f2_sub = get_Ef1f2(sub_Z, datafile=f1f2data)
if f1f2interp == 'linear':
f1_sub = interp1d(f1f2_sub[:, 0], f1f2_sub[:, 1])(E)
f2_sub = interp1d(f1f2_sub[:, 0], f1f2_sub[:, 2])(E)
else:
f1_sub = loglog_negy_interp1d(f1f2_sub[:, 0], f1f2_sub[:, 1], E)
f2_sub = loglog_negy_interp1d(f1f2_sub[:, 0], f1f2_sub[:, 2], E)
rho_sub = xt.Density[sub_mat] * 1.e6 # g/cm3 --> g/m3
n_rho_sub = rho_sub / xt.AtomicMass[sub_mat] * NA # Atoms per m3
coat = xl.CompoundParser(coat_mat)
f1_coat = np.zeros_like(E)
f2_coat = np.zeros_like(E)
for i in range(coat['nElements']):
if f1f2data == 'default':
f1f2_coat = get_Ef1f2(coat['Elements'][i])
else:
f1f2_coat = get_Ef1f2(coat['Elements'][i], datafile=f1f2data)
if f1f2interp == 'linear':
f1_coat += interp1d(f1f2_coat[:, 0],
f1f2_coat[:, 1])(E) * coat['nAtoms'][i]
f2_coat += interp1d(f1f2_coat[:, 0],
f1f2_coat[:, 2])(E) * coat['nAtoms'][i]
else:
f1_coat += loglog_negy_interp1d(f1f2_coat[:, 0], f1f2_coat[:, 1],
E) * coat['nAtoms'][i]
f2_coat += loglog_negy_interp1d(f1f2_coat[:, 0], f1f2_coat[:, 2],
E) * coat['nAtoms'][i]
rho_coat = xt.Density[coat_mat] * 1.e6 # g/cm3 --> g/m3
n_rho_coat = rho_coat / coat['molarMass'] * NA # Atoms per m3
lamda = h * c / (E * eV) + 0j
K = 2 * np.pi / lamda
ah = r_e * lamda**2 / np.pi
Chi_sub = ah * n_rho_sub * (-f1_sub + f2_sub * 1j)
Chi_coat = ah * n_rho_coat * (-f1_coat + f2_coat * 1j)
K_z0 = K * np.sqrt(np.sin(theta)**2 + Chi_sub)
K_z1 = K * np.sqrt(np.sin(theta)**2 + Chi_coat)
K_z2 = K * np.sin(theta)
C1 = np.exp(1j * K_z1 * coat_thickness / 2)
C2 = np.exp(1j * K_z2 * 1 / 2)
R1 = (K_z1 - K_z0) / (K_z0 + K_z1) * C1**2 # R1 = r11_0
r11_2 = (K_z1 - K_z2) / (K_z2 + K_z1) * C1**2
r22_1 = (K_z2 - K_z1) / (K_z1 + K_z2) * C2**2
t12 = 2 * K_z2 / (K_z1 + K_z2) * C1 * C2
t21 = 2 * K_z1 / (K_z2 + K_z1) * C1 * C2
R2 = r22_1 + t21 * t12 * R1 / (1. - r11_2 * R1)
R = np.abs(R2)**2
if scalar_E:
return np.squeeze(R)
return R
#python 2 compatibility
if sys.version_info[0] < 3:
input = raw_input
print('----------------------------------')
print('** XAS SAMPLE OPTIMIZER v.' + _VERSION + ' **')
print('----------------------------------')
#Ask for user input
input_str = {}
input_str['compound'] = input('Compound: ')
input_str['absorption_edge'] = input('Absorption edge (e.g. Cu-K, U-L3): ')
photons_per_second = float(
input('Incident photon flux (background subtracted) (ph/s): '))
compound = xrl.CompoundParser(input_str['compound'])
#convert the absorption edge string to energy
edge_element, edge_shell = input_str['absorption_edge'].split('-')
edge_energy = xrl.EdgeEnergy(xrl.SymbolToAtomicNumber(edge_element),
_SHELL_MACROS[edge_shell])
#calculate the mass attenuation coefficient below and above edge
murho = [0, 0]
for i in range(compound['nElements']):
murho[0] = murho[0] + compound['massFractions'][i] * xrl.CS_Total(
compound['Elements'][i], edge_energy - 0.001)
murho[1] = murho[1] + compound['massFractions'][i] * xrl.CS_Total(
compound['Elements'][i], edge_energy + 0.001)
def funcWrapped(Id, *args, **kwargs):
Id = xraylib.CompoundParser(Id)
out = func(np.asarray(Id['Elements']), *args, **kwargs)
return np.sum(out, 0)
def index():
form = Xraylib_Request()
version = xraylib.__version__
# Populates select fields
form.function.choices = form.function.choices + cs_tup + dcs_tup
form.transition.siegbahn.choices = trans_S_tup
form.shell.choices = shell_tup
form.nistcomp.choices = nist_tup
form.rad_nuc.choices = rad_name_tup
if request.method == 'POST':
# Get user input
select_input = request.form.get('function')
examples = request.form.get('examples')
notation = request.form.get('transition-notation')
siegbahn = request.form.get('transition-siegbahn')
iupac1 = request.form.get('transition-iupac1')
iupac2 = request.form.get('transition-iupac2')
ex_shell = request.form.get('augtrans-ex_shell')
trans_shell = request.form.get('augtrans-trans_shell')
aug_shell = request.form.get('augtrans-aug_shell')
cktrans = request.form.get('cktrans')
nistcomp = request.form.get('nistcomp')
rad_nuc = request.form.get('rad_nuc')
shell = request.form.get('shell')
int_z = request.form['int_z']
float_q = request.form['float_q']
comp = request.form['comp']
int_z_or_comp = request.form['int_z_or_comp']
energy = request.form['energy']
theta = request.form['theta']
phi = request.form['phi']
density = request.form['density']
pz = request.form['pz']
# Turns user input => valid args for calc_output
trans = iupac1 + iupac2 + '_LINE'
augtrans = ex_shell + '_' + trans_shell + aug_shell + '_AUGER'
if select_input == 'AtomicWeight' or select_input == 'ElementDensity':
if validate_int(int_z) or validate_str(int_z):
examples = code_example(form.examples.choices, select_input,
int_z)
output = calc_output(select_input, int_z)
return render_template('index.html',
form=form,
version=version,
output=output,
units=getattr(Request_Units,
select_input + '_u'),
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'FF_Rayl' or select_input == 'SF_Compt':
if validate_int(
int_z) or validate_str(int_z) and validate_float(float_q):
examples = code_example(form.examples.choices, select_input,
int_z, float_q)
output = calc_output(select_input, int_z, float_q)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'AugerRate':
if validate_int(int_z) or validate_str(int_z):
examples = code_example(form.examples.choices, select_input,
int_z, augtrans)
output = calc_output(select_input, int_z, augtrans)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'LineEnergy' or select_input == 'RadRate':
if notation == 'IUPAC':
if validate_int(int_z) or validate_str(int_z):
examples = code_example(form.examples.choices,
select_input, int_z, trans)
output = calc_output(select_input, int_z, trans)
if select_input == 'LineEnergy':
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.Energy_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif notation == 'Siegbahn':
if validate_int(int_z) or validate_str(int_z):
examples = code_example(form.examples.choices,
select_input, int_z, siegbahn)
output = calc_output(select_input, int_z, siegbahn)
print(output)
if select_input == 'LineEnergy':
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.Energy_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif notation == 'All':
if validate_int(int_z) or validate_str(int_z):
output = all_trans(trans_I_tup, select_input, int_z)
if select_input == 'LineEnergy':
#needs units
#output = dict(out, Line = 'Energies')
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.Energy_u)
else:
return render_template('index.html',
form=form,
version=version,
output=output)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
else:
return render_template('index.html', error=Request_Error.error)
elif (select_input == 'EdgeEnergy' or select_input == 'JumpFactor'
or select_input == 'FluorYield' or select_input == 'AugerYield'
or select_input == 'AtomicLevelWidth'
or select_input == 'ElectronConfig'):
if validate_int(int_z) or validate_str(int_z):
examples = code_example(form.examples.choices, select_input,
int_z, shell)
output = calc_output(select_input, int_z, shell)
if select_input == 'EdgeEnergy' or select_input == 'AtomicLevelWidth':
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.Energy_u,
code_examples=examples)
elif select_input == 'ElectronConfig':
return render_template(
'index.html',
form=form,
version=version,
output=output,
units=Request_Units.ElectronConfig_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'CS_Photo_Partial':
if validate_int(
int_z) or validate_str(int_z) and validate_float(energy):
output = calc_output(select_input, int_z, shell, energy)
examples = code_example(form.examples.choices, select_input,
int_z, shell, energy)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.CS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'CS_KN':
if validate_float(energy) and energy != '0':
output = calc_output(select_input, energy)
examples = code_example(form.examples.choices, select_input,
energy)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.CS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input.startswith('CS_FluorLine'):
if validate_float(energy):
if notation == 'IUPAC':
if validate_int(int_z) or validate_str(int_z):
examples = code_example(form.examples.choices,
select_input, int_z, trans,
energy)
output = calc_output(select_input, int_z, trans,
energy)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.CS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif notation == 'Siegbahn':
if validate_int(int_z) or validate_str(int_z):
examples = code_example(form.examples.choices,
select_input, int_z, siegbahn,
energy)
output = calc_output(select_input, int_z, siegbahn,
energy)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.CS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif notation == 'All':
if validate_int(int_z) or validate_str(int_z):
output = all_trans_xrf(form.transition.iupac.choices,
select_input, int_z, energy)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.CS_u)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input.startswith('CS_'):
if validate_float(energy) and validate_int(
int_z_or_comp) or validate_str(int_z_or_comp):
examples = code_example(form.examples.choices, select_input,
int_z_or_comp, energy)
output = calc_output(select_input, int_z_or_comp, energy)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.CS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'DCS_Thoms':
if validate_float(theta):
output = calc_output(select_input, theta)
examples = code_example(form.examples.choices, select_input,
theta)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.DCS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'DCS_KN' or select_input == 'ComptonEnergy':
if validate_float(energy, theta):
output = calc_output(select_input, energy, theta)
examples = code_example(form.examples.choices, select_input,
energy, theta)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.DCS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input.startswith('DCS_'):
if validate_float(energy, theta) and validate_int(
int_z_or_comp) or validate_str(int_z_or_comp):
output = calc_output(select_input, int_z_or_comp, energy,
theta)
examples = code_example(form.examples.choices, select_input,
int_z_or_comp, energy, theta)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.DCS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'DCSP_KN':
if validate_float(energy, theta, phi):
output = calc_output(select_input, energy, theta, phi)
examples = code_example(form.examples.choices, select_input,
energy, theta, phi)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.DCS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'DCSP_Thoms':
if validate_float(theta, phi):
output = calc_output(select_input, theta, phi)
examples = code_example(form.examples.choices, select_input,
theta, phi)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.DCS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input.startswith('DCSP_'):
if validate_float(energy, theta, phi) and validate_int(
int_z_or_comp) or validate_str(int_z_or_comp):
output = calc_output(select_input, int_z_or_comp, energy,
theta, phi)
examples = code_example(form.examples.choices, select_input,
int_z_or_comp, energy, theta, phi)
return render_template('index.html',
form=form,
version=version,
output=output,
units=Request_Units.DCS_u,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input.startswith('Fi'):
if validate_int(
int_z) or validate_str(int_z) and validate_float(energy):
output = calc_output(select_input, int_z, energy)
examples = code_example(form.examples.choices, select_input,
int_z, energy)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'CosKronTransProb':
if validate_int(int_z) or validate_str(int_z):
output = calc_output(select_input, int_z, cktrans)
examples = code_example(form.examples.choices, select_input,
int_z, cktrans)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'ComptonProfile':
if validate_float(pz) and validate_int(int_z) or validate_str(
int_z):
output = calc_output(select_input, int_z, pz)
examples = code_example(form.examples.choices, select_input,
int_z, pz)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'ComptonProfile_Partial':
if validate_float(pz) and validate_int(int_z) or validate_str(
int_z):
output = calc_output(select_input, int_z, shell, pz)
examples = code_example(form.examples.choices, select_input,
int_z, shell, pz)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'MomentTransf':
if validate_float(energy, theta) == True:
output = calc_output(select_input, energy, theta)
examples = code_example(form.examples.choices, select_input,
energy, theta)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'Refractive_Index':
# Special Case: Refractive_Index input needs to be const char compound
if validate_float(energy, density) and validate_int(
int_z_or_comp) or validate_str(int_z_or_comp):
try:
output = xraylib.Refractive_Index(
xraylib.AtomicNumberToSymbol(int(int_z_or_comp),
float(energy),
float(density)))
examples = code_example(form.examples.choices,
select_input, int_z_or_comp,
energy, density)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
except:
output = xraylib.Refractive_Index(int_z_or_comp,
float(energy),
float(density))
examples = code_example(form.examples.choices,
select_input, int_z_or_comp,
energy, density)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'CompoundParser':
# Special Case: CompoundParser input needs to be const char compound
if validate_str(comp):
try:
out = xraylib.CompoundParser(str(comp))
# Format output
w_fracts = out['massFractions']
w_pers = [str(round(i * 100, 2)) + ' %' for i in w_fracts]
z = out['Elements']
sym = [
'<sub>' + str(i) + '</sub>' +
str(xraylib.AtomicNumberToSymbol(i)) for i in z
]
mmass = str(out['molarMass']) + ' g mol<sup>-1</sup>'
output = {
'Elements': sym,
'Weight Fraction': w_pers,
'Number of Atoms': out['nAtoms'],
' Molar Mass': mmass
}
examples = code_example(form.examples.choices,
select_input, comp)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples,
units=Request_Units.per_u)
except:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
else:
return render_template('index.html',
form=form,
version=version,
error=Request_Error.error)
elif select_input == 'GetRadioNuclideDataList':
output = xraylib.GetRadioNuclideDataList()
output.insert(0, '<b> Radionuclides: </b>')
output = '<br/>'.join(output)
examples = code_example(form.examples.choices, select_input)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
elif select_input == 'GetRadioNuclideDataByIndex':
out = calc_output(select_input, rad_nuc)
print(out)
# Format output
line_nos = out['XrayLines']
x_energy = [xraylib.LineEnergy(out['Z_xray'], i) for i in line_nos]
output = {
'X-ray Energies': x_energy,
'Disintegrations s<sup>-1</sup>': out['XrayIntensities'],
'Gamma-ray Energy': out['GammaEnergies'],
'Disintegrations s<sup>-1</sup> ': out['GammaIntensities']
}
examples = code_example(form.examples.choices,
'GetRadioNuclideDataByName', rad_nuc)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
elif select_input == 'GetCompoundDataNISTList':
output = xraylib.GetCompoundDataNISTList()
output.insert(0, '<b> NIST Compounds: </b>')
output = '<br/>'.join(output)
examples = code_example(form.examples.choices, select_input)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
elif select_input == 'GetCompoundDataNISTByIndex':
out = calc_output(select_input, nistcomp)
# Format output
w_fracts = out['massFractions']
w_pers = [str(round(i * 100, 2)) + ' %' for i in w_fracts]
z = out['Elements']
sym = [
'<sub>' + str(i) + '</sub>' +
str(xraylib.AtomicNumberToSymbol(i)) for i in z
]
density = str(out['density']) + ' g cm<sup>-3</sup>'
output = {
'Elements': sym,
'Weight Fraction': w_pers,
' Density': density
}
examples = code_example(form.examples.choices,
'GetCompoundDataNISTByName', nistcomp)
return render_template('index.html',
form=form,
version=version,
output=output,
code_examples=examples)
return render_template('index.html', form=form, version=version)
def parse_compound(compund):
return xraylib.CompoundParser(compund)
def prerefl(cls, interactive=True, SYMBOL="SiC", DENSITY=3.217, FILE="prerefl.dat", E_MIN=100.0, E_MAX=20000.0,
E_STEP=100.0):
"""
Preprocessor for mirrors - python+xraylib version
-"""
# retrieve physical constants needed
import scipy
import xraylib
import scipy.constants as codata
tocm = codata.h * codata.c / codata.e * 1e2
if interactive:
# input section
print("prerefl: Preprocessor for mirrors - python+xraylib version")
iMaterial = input("Enter material expression (symbol,formula): ")
density = input("Density [ g/cm3 ] ?")
density = float(density)
estart = input("Enter starting photon energy: ")
estart = float(estart)
efinal = input("Enter end photon energy: ")
efinal = float(efinal)
estep = input("Enter step photon energy:")
estep = float(estep)
out_file = input("Output file : ")
else:
iMaterial = SYMBOL
density = DENSITY
estart = E_MIN
efinal = E_MAX
estep = E_STEP
out_file = FILE
twopi = numpy.pi * 2
npoint = int((efinal - estart) / estep + 1)
depth0 = density / 2.0
qmin = estart / tocm * twopi
qmax = efinal / tocm * twopi
qstep = estep / tocm * twopi
f = open(out_file, 'wt')
f.write(("%20.11e " * 4 + "\n") % tuple([qmin, qmax, qstep, depth0]))
f.write("%i \n" % int(npoint))
for i in range(npoint):
energy = (estart + estep * i) * 1e-3
tmp = 2e0 * (1e0 - xraylib.Refractive_Index_Re(iMaterial, energy, density))
f.write("%e \n" % tmp)
for i in range(npoint):
energy = (estart + estep * i) * 1e-3
tmp2 = 2e0 * (xraylib.Refractive_Index_Im(iMaterial, energy, density))
f.write("%e \n" % tmp2)
print("File written to disk: %s" % out_file)
f.close()
# test (not needed)
itest = 0
if itest:
cdtest = xraylib.CompoundParser(iMaterial)
print(" ", iMaterial, " contains %i atoms and %i elements" % (cdtest['nAtomsAll'], cdtest['nElements']))
for i in range(cdtest['nElements']):
print(" Element %i: %lf %%" % (cdtest['Elements'][i], cdtest['massFractions'][i] * 100.0))
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(qmin, qmax, qstep, depth0)
print(npoint)
for i in range(npoint):
energy = (estart + estep * i) * 1e-3
qq = qmin + qstep * i
print(energy, qq, \
2e0 * (1e0 - xraylib.Refractive_Index_Re(iMaterial, energy, density)), \
2e0 * (xraylib.Refractive_Index_Im(iMaterial, energy, density)))
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
return None
