def dsigma_el(theta, energy, mw, elements, stoic):
dsigma = 0
for i in range(0, len(elements)):
q = xraylib.MomentTransf(energy, theta)
w = xraylib.AtomicWeight(elements[i]) * stoic[i] / mw
temp = dsigma_th(theta) * xraylib.FF_Rayl(elements[i], q)**2
temp = temp / xraylib.AtomicWeight(elements[i]) * w
dsigma += temp
dsigma *= mw
return dsigma
def GetMaterialMu(E, data): # send in the photon energy and the dictionary holding the layer information
Ele = data['Element']
Mol = data['MolFrac']
t = 0
for i in range(len(Ele)):
t += xraylib.AtomicWeight(xraylib.SymbolToAtomicNumber(Ele[i]))*Mol[i]
mu=0
for i in range(len(Ele)):
mu+= (xraylib.CS_Total(xraylib.SymbolToAtomicNumber(Ele[i]),E) *
xraylib.AtomicWeight(xraylib.SymbolToAtomicNumber(Ele[i]))*Mol[i]/t)
return mu # total attenuataion w/ coherent scattering in cm2/g
def dsigma_inel(theta, energy, mw, elements, stoic):
dsigma = 0
for i in range(0, len(elements)):
q = xraylib.MomentTransf(energy, theta)
w = xraylib.AtomicWeight(elements[i]) * stoic[i] / mw
temp = dsigma_kn(theta, energy) * xraylib.SF_Compt(elements[i], q)
temp = temp / xraylib.AtomicWeight(elements[i]) * w
dsigma += temp
dsigma *= mw
return dsigma
def get_data():
sym, z, group, period, _type = ([], [], [], [], [])
mass, density, absedge, alw, flyield, augyield = ([], [], [], [], [], [])
for i in range(1, 104):
s = xraylib.AtomicNumberToSymbol(i)
sym.append(s)
z.append(i)
mass.append(xraylib.AtomicWeight(i))
density.append(str(xraylib.ElementDensity(i)) + ' g/cm^3')
absedge.append(str(xraylib.EdgeEnergy(i, 0)) + ' keV')
alw.append(str(xraylib.AtomicLevelWidth(i, 0)) + ' keV')
flyield.append(str(xraylib.FluorYield(i, 0)))
augyield.append(str(xraylib.AugerYield(i, 0)))
pop_period(i, period)
pop_group(i, group)
pop_type(i, _type)
data = {
'sym': sym,
'z': z,
'mass': mass,
'group': group,
'period': period,
'_type': _type,
'density': density,
'flyield': flyield,
'augyield': augyield,
'absedge': absedge,
'alw': alw
}
return data
def ug_to_mol(samp, map_key, scan_idx, eles, e_idx):
e_list_idx = e_idx - 1
e = eles[e_list_idx]
if len(e) > 2: e = e[:-2]
else: pass
z = xl.SymbolToAtomicNumber(e)
factor = (1 / 1E6) * (1 / xl.AtomicWeight(z)) #(1g/1E6ug) * (1mol/g)
mol_map = samp[map_key][scan_idx][e_idx, :, :-2] * factor
return mol_map
def formula(compound):
elt_CP = [
xrl.AtomicNumberToSymbol(compound['Elements'][i])
for i in range(compound['nElements'])
]
atf_CP = [
compound['massFractions'][i] /
xrl.AtomicWeight(compound['Elements'][i])
for i in range(compound['nElements'])
]
atfn_CP = [str(atf / min(atf_CP)) for atf in atf_CP]
return "".join(np.core.defchararray.add(elt_CP, atfn_CP))
def ug_to_mol(self, elements):
# get the XRF maps from each scan
XRF_maps = [scan[-1:,:,:-2] for scan in self.maps]
# get atomic number for xraylib reference
z_list = [xl.SymbolToAtomicNumber(e) for e in elements]
# calculate mol for each atomic number (1g/1E6ug)*(1mol/g)
factors = [(1/1E6) * (1/xl.AtomicWeight(z)) for z in z_list]
# convert factor list to array for easy matrix math
factor_arr = np.array(factors)
# 1D fact arr * 3D xrf arr along depth axis for each set of XRF maps
XRF_mol = [factor_arr[:, None, None] * XRF_map for XRF_map in XRF_maps]
# assign empty attribute to store mol maps
self.mol = lambda:None
# store mol maps; note these do not have electical map!
self.mol = XRF_mol
return
def make_mol_maps(samples, elements, dict_data, new_dict_data):
elements = [element[0:2] for element in elements]
mol_masses = [
xl.AtomicWeight(xl.SymbolToAtomicNumber(element))
for element in elements
]
#ug/cm2 * (g/ug) * (mol/g) == mol/cm2
conv_factors = [(1 / 1E6) / (1 / mol_mass) for mol_mass in mol_masses]
for sample in samples:
mol_scans = []
for scan_raw_maps in sample[dict_data]:
mol_maps = scan_raw_maps.copy()
for ele_idx, factor in enumerate(conv_factors):
map_idx = ele_idx + 1
ele_map = scan_raw_maps[map_idx, :, :]
mol_map = ele_map * factor
mol_maps[map_idx, :, :] = mol_map
mol_scans.append(mol_maps)
samp_dict_grow.build_dict(sample, new_dict_data, mol_scans)
return
def reflectivity(descriptor,energy,theta,density=None,rough=0.0):
if isinstance(descriptor,str):
Z = xraylib.SymbolToAtomicNumber(descriptor)
symbol = descriptor
else:
Z = descriptor
symbol = xraylib.AtomicNumberToSymbol(descriptor)
if density == None:
density = xraylib.ElementDensity(Z)
atwt = xraylib.AtomicWeight(Z)
avogadro = codata.Avogadro
toangstroms = codata.h * codata.c / codata.e * 1e10
re = codata.e**2 / codata.m_e / codata.c**2 / (4*numpy.pi*codata.epsilon_0) * 1e2 # in cm
molecules_per_cc = density * avogadro / atwt
wavelength = toangstroms / energy * 1e-8 # in cm
k = molecules_per_cc * re * wavelength * wavelength / 2.0 / numpy.pi
f1 = numpy.zeros_like(energy)
f2 = numpy.zeros_like(energy)
for i,ienergy in enumerate(energy):
f1[i] = Z + xraylib.Fi(Z,1e-3*ienergy)
f2[i] = - xraylib.Fii(Z,1e-3*ienergy)
alpha = 2.0 * k * f1
gamma = 2.0 * k * f2
rs,rp,runp = interface_reflectivity(alpha,gamma,theta)
if rough != 0:
rough *= 1e-8 # to cm
debyewaller = numpy.exp( -( 4.0 * numpy.pi * numpy.sin(theta) * rough / wavelength)**2)
else:
debyewaller = 1.0
return rs*debyewaller,rp*debyewaller,runp*debyewaller
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_bad_Z(self):
with self.assertRaises(ValueError):
width = xraylib.AtomicWeight(185)
def spectrum(E0, Mat_Z, Mat_X):
xrs = xg.calculate_spectrum(E0, 12, 3, 100, epsrel=0.5, monitor=None, z=74)
#Inherent filtration: 1.2mm Al + 100cm Air
mu_Al = xg.get_mu(13)
xrs.attenuate(0.12, mu_Al)
xrs.attenuate(100, xg.get_mu("air"))
fluence_to_dose = xg.get_fluence_to_dose()
xrs.set_norm(value=0.146, weight=fluence_to_dose)
#Attenuation
if Mat_Z > 0: #Atomic number
dMat = xrl.ElementDensity(Mat_Z)
fMat = xrl.AtomicNumberToSymbol(Mat_Z)
xrs.attenuate(0.1 * Mat_X, xg.get_mu(Mat_Z))
else: #-1 == 'Water'
mH2O = 2. * xrl.AtomicWeight(1) + xrl.AtomicWeight(8)
wH = 0.1 * Mat_X * 2. * xrl.AtomicWeight(1) / (xrl.ElementDensity(1) *
mH2O)
wO = 0.1 * Mat_X * xrl.AtomicWeight(8) / (xrl.ElementDensity(8) * mH2O)
xrs.attenuate(wH, xg.get_mu(1))
xrs.attenuate(wO, xg.get_mu(8))
#Get the figures
Nr_Photons = "%.4g" % (xrs.get_norm())
Average_Energy = "%.2f keV" % (xrs.get_norm(lambda x: x) / xrs.get_norm())
Dose = "%.3g mGy" % (xrs.get_norm(fluence_to_dose))
HVL_Al = xrs.hvl(0.5, fluence_to_dose, mu_Al)
HVL_Al_text = "%.2f mm (Al)" % (10 * HVL_Al)
a = [["Dose à 1m", Dose], ["Nombre total de photons", Nr_Photons],
["Énergie moyenne des photons", Average_Energy],
["Couche de Demi-Atténuation", HVL_Al_text]]
print(to_text(a))
(x2, y2) = xrs.get_points()
plt.close(2)
plt.figure(num=2, dpi=150, clear=True)
mpl.rcParams.update({'font.size': 6})
axMW = plt.subplot(111)
axMW.plot(x2, y2)
axMW.set_xlim(3, E0)
axMW.set_ylim(0, )
plt.xlabel("Énergie [keV]")
plt.ylabel("Nombre de photons par [keV·cm²·mGy] @ 1m")
axMW.grid(which='major',
axis='x',
linewidth=0.5,
linestyle='-',
color='0.75')
axMW.grid(which='minor',
axis='x',
linewidth=0.2,
linestyle='-',
color='0.85')
axMW.grid(which='major',
axis='y',
linewidth=0.5,
linestyle='-',
color='0.75')
axMW.grid(which='minor',
axis='y',
linewidth=0.2,
linestyle='-',
color='0.85')
axMW.xaxis.set_major_formatter(mpl.ticker.FormatStrFormatter("%d"))
axMW.yaxis.set_major_formatter(mpl.ticker.FormatStrFormatter("%.2g"))
axMW.xaxis.set_minor_locator(mpl.ticker.AutoMinorLocator())
axMW.yaxis.set_minor_locator(mpl.ticker.AutoMinorLocator())
axMW.grid(True)
plt.show()
def test_U(self):
weight = xraylib.AtomicWeight(92)
self.assertAlmostEqual(weight, 238.070)
def xoppy_calc_mlayer(self):
# copy the variable locally, so no more use of self.
MODE = self.MODE
SCAN = self.SCAN
F12_FLAG = self.F12_FLAG
SUBSTRATE = self.SUBSTRATE
ODD_MATERIAL = self.ODD_MATERIAL
EVEN_MATERIAL = self.EVEN_MATERIAL
ENERGY = self.ENERGY
THETA = self.THETA
SCAN_STEP = self.SCAN_STEP
NPOINTS = self.NPOINTS
ODD_THICKNESS = self.ODD_THICKNESS
EVEN_THICKNESS = self.EVEN_THICKNESS
NLAYERS = self.NLAYERS
FILE = self.FILE
for file in ["mlayer.inp", "mlayer.par", "mlayer.f12"]:
try:
os.remove(os.path.join(locations.home_bin_run(), file))
except:
pass
#
# write input file for Fortran mlayer: mlayer.inp
#
f = open('mlayer.inp', 'w')
if SCAN == 0 and MODE == 0: a0 = 1
if SCAN == 1 and MODE == 0: a0 = 2
if SCAN == 0 and MODE == 1: a0 = 3
if SCAN == 1 and MODE == 1: a0 = 4
f.write("%d \n" % a0)
f.write("N\n")
f.write("%g\n" % (codata.h * codata.c / codata.e * 1e10 / ENERGY))
f.write("%g\n" % THETA)
#
if SCAN == 0:
f.write("%g\n" % SCAN_STEP)
a2 = codata.h * codata.c / codata.e * 1e10 / ENERGY
a3 = codata.h * codata.c / codata.e * 1e10 / (ENERGY + SCAN_STEP)
a4 = a3 - a2
if SCAN != 0:
f.write("%g\n" % a4)
#
f.write("%d\n" % NPOINTS)
if MODE == 0:
f.write("%d\n" % NLAYERS)
if MODE == 0:
if a0 != 5:
f.write("%g %g \n" % (ODD_THICKNESS, EVEN_THICKNESS))
else:
for i in range(NLAYERS):
f.write("%g %g \n" % (ODD_THICKNESS, EVEN_THICKNESS))
if MODE != 0:
f1 = open(FILE, 'r')
a5 = f1.read()
f1.close()
if MODE != 0:
print("Number of layers in %s file is %d " % (FILE, NLAYERS))
f.write("%d\n" % NLAYERS)
f.write(a5)
f.write("mlayer.par\n")
f.write("mlayer.dat\n")
f.write("6\n")
f.close()
print('File written to disk: mlayer.inp')
#
# create f12 file
#
if F12_FLAG == 0:
energy = numpy.arange(0, 500)
elefactor = numpy.log10(10000.0 / 30.0) / 300.0
energy = 10.0 * 10**(energy * elefactor)
f12_s = f1f2_calc(SUBSTRATE, energy)
f12_e = f1f2_calc(EVEN_MATERIAL, energy)
f12_o = f1f2_calc(ODD_MATERIAL, energy)
f = open("mlayer.f12", 'w')
f.write(
'; File created by xoppy for materials [substrate=%s,even=%s,odd=%s]: \n'
% (SUBSTRATE, EVEN_MATERIAL, ODD_MATERIAL))
f.write('; Atomic masses: \n')
f.write(
"%g %g %g \n" %
(xraylib.AtomicWeight(xraylib.SymbolToAtomicNumber(SUBSTRATE)),
xraylib.AtomicWeight(
xraylib.SymbolToAtomicNumber(EVEN_MATERIAL)),
xraylib.AtomicWeight(
xraylib.SymbolToAtomicNumber(ODD_MATERIAL))))
f.write('; Densities: \n')
f.write("%g %g %g \n" %
(xraylib.ElementDensity(
xraylib.SymbolToAtomicNumber(SUBSTRATE)),
xraylib.ElementDensity(
xraylib.SymbolToAtomicNumber(EVEN_MATERIAL)),
xraylib.ElementDensity(
xraylib.SymbolToAtomicNumber(ODD_MATERIAL))))
f.write('; Number of energy points: \n')
f.write("%d\n" % (energy.size))
f.write(
'; For each energy point, energy[eV], f1[substrate], f2[substrate], f1[even], f2[even], f1[odd], f2[odd]: \n'
)
for i in range(energy.size):
f.write("%g %g %g %g %g %g %g \n" %
(energy[i], f12_s[0, i], f12_s[1, i], f12_e[0, i],
f12_e[1, i], f12_o[0, i], f12_o[1, i]))
f.close()
print('File written to disk: mlayer.f12')
#
# run external program mlayer
#
if platform.system() == "Windows":
command = os.path.join(locations.home_bin(),
'mlayer.exe < mlayer.inp')
else:
command = "'" + os.path.join(locations.home_bin(),
'mlayer') + "' < mlayer.inp"
print("Running command '%s' in directory: %s " %
(command, locations.home_bin_run()))
print("\n--------------------------------------------------------\n")
os.system(command)
print("\n--------------------------------------------------------\n")
#send exchange
calculated_data = DataExchangeObject(
"XOPPY", self.get_data_exchange_widget_name())
try:
if SCAN == 0:
calculated_data.add_content("xoppy_data",
numpy.loadtxt("mlayer.dat"))
calculated_data.add_content("plot_x_col", 0)
calculated_data.add_content("plot_y_col", 3)
elif SCAN == 1: # internal scan is in wavelength. Add a column with energy
aa = numpy.loadtxt("mlayer.dat")
photon_energy = (codata.h * codata.c / codata.e * 1e10) / aa[:,
0]
bb = numpy.zeros((aa.shape[0], 1 + aa.shape[1]))
bb[:, 0] = photon_energy
bb[:, 1:] = aa
calculated_data.add_content("xoppy_data", bb)
calculated_data.add_content("plot_x_col", 0)
calculated_data.add_content("plot_y_col", 4)
calculated_data.add_content("units_to_degrees", 1.0)
except:
pass
try:
info = "ML %s(%3.2f A):%s(%3.2f A) %d pairs; E=%5.3f eV" % (
ODD_MATERIAL, ODD_THICKNESS, EVEN_MATERIAL, EVEN_THICKNESS,
NLAYERS, ENERGY)
calculated_data.add_content("info", info)
except:
pass
return calculated_data
def calcTemperatureFactor(temperature,
crystal='Si',
debyeTemperature=644.92,
millerIndex=[1, 1, 1],
atomicMass=28.09,
dSpacing=3.1354162886330583):
"""
Calculates the (Debye) temperature factor for single crystals.
Parameters
----------
temperature : float
Crystal temperature in Kelvin (positive number).
crystal : str
Crystal single-element symbol (e.g. Si, Ge, ...).
debyeTemperature : float
Debye temperature of the crystal material in Kelvin.
millerIndex : array-like (1D), optional
Miller indexes of the crystal orientation. For use with xraylib only.
atomicMass : float, optional.
Atomic mass of the crystal element (amu unit). if atomicMass == 0, get from xraylib.
dSpacing : float, optional.
dSpacing in Angstroms, given the crystal and millerIndex . if dSpacing == 0, get from xraylib.
Returns:
--------
temperatureFactor : float
Examples:
---------
### using xraylib:
>>> calcTemperatureFactor(80, crystal='Si', millerIndex=[3,1,1], debyeTemperature=644.92, dSpacing=0, atomicMass=0)
0.983851994268226
### forcing it to use given dSpacing and atomicMass:
>>> calcTemperatureFactor(80, crystal='Si', millerIndex=[1,1,1], debyeTemperature=644.92, atomicMass=28.09, dSpacing=3.1354163)
0.9955698950510736
References:
-----------
[1]: A. Freund, Nucl. Instrum. and Meth. 213 (1983) 495-501
[2]: M. Sanchez del Rio and R. J. Dejus, "Status of XOP: an x-ray optics software toolkit",
SPIE proc. vol. 5536 (2004) pp.171-174
"""
def debyeFunc(x):
return x / (np.exp(-x) - 1)
def debyePhi(y):
from scipy.integrate import quad
integral = quad(lambda x: debyeFunc(x), 0, y)[0]
return (1 / y) * integral
planck = 6.62607015e-34 # codata.Planck
Kb = 1.380649e-23 # codata.Boltzmann
atomicMassTokg = 1.6605390666e-27 # codata.atomic_mass
try:
import xraylib
h, k, l = millerIndex
crystalDict = xraylib.Crystal_GetCrystal(crystal)
if (dSpacing == 0):
dSpacing = xraylib.Crystal_dSpacing(crystalDict, h, k, l)
if (atomicMass == 0):
atomicMass = xraylib.AtomicWeight(
xraylib.SymbolToAtomicNumber(crystal))
except:
print(
"xraylib not available. Please give dSpacing and atomicMass manually."
)
if ((dSpacing == 0) or (atomicMass == 0)):
return np.nan
atomicMass *= atomicMassTokg # converting to [kg]
dSpacing *= 1e-10 # converting to [m]
x = debyeTemperature / (-1 * temperature) # invert temperature sign (!!!)
B0 = (3 * planck**2) / (2 * Kb * debyeTemperature * atomicMass)
BT = 4 * B0 * debyePhi(x) / x
ratio = 1 / (2 * dSpacing)
M = (B0 + BT) * ratio**2
temperatureFactor = np.exp(-M)
return temperatureFactor
def xoppy_calc_xraylib_widget(FUNCTION=0,ELEMENT=26,ELEMENTORCOMPOUND="FeSO4",COMPOUND="Ca5(PO4)3",TRANSITION_IUPAC_OR_SIEGBAHN=1,\
TRANSITION_IUPAC_TO=0,TRANSITION_IUPAC_FROM=0,TRANSITION_SIEGBAHN=0,SHELL=0,ENERGY=10.0):
functions = [
'0 Fluorescence line energy', '1 Absorption edge energy',
'2 Atomic weight', '3 Elemental density',
'4 Total absorption cross section', '5 Photoionization cross section',
'6 Partial photoionization cross section',
'7 Rayleigh scattering cross section',
'8 Compton scattering cross section', '9 Klein-Nishina cross section',
'10 Mass energy-absorption cross section',
'11 Differential unpolarized Klein-Nishina cross section',
'12 Differential unpolarized Thomson cross section',
'13 Differential unpolarized Rayleigh cross section',
'14 Differential unpolarized Compton cross section',
'15 Differential polarized Klein-Nishina cross section',
'16 Differential polarized Thomson cross section',
'17 Differential polarized Rayleigh cross section',
'18 Differential polarized Compton cross section',
'19 Atomic form factor', '20 Incoherent scattering function',
'21 Momentum transfer function',
'22 Coster-Kronig transition probability', '23 Fluorescence yield',
'24 Jump factor', '25 Radiative transition probability',
'26 Energy after Compton scattering',
'27 Anomalous scattering factor φ′',
'28 Anomalous scattering factor φ″',
'29 Electronic configuration',
'30 X-ray fluorescence production cross section (with full cascade)',
'31 X-ray fluorescence production cross section (with radiative cascade)',
'32 X-ray fluorescence production cross section (with non-radiative cascade)',
'33 X-ray fluorescence production cross section (without cascade)',
'34 Atomic level width', '35 Auger yield', '36 Auger rate',
'37 Refractive index', '38 Compton broadening profile',
'39 Partial Compton broadening profile',
'40 List of NIST catalog compounds',
'41 Get composition of NIST catalog compound',
'42 List of X-ray emitting radionuclides',
'43 Get excitation profile of X-ray emitting radionuclide',
'44 Compoundparser'
]
print("\nInside xoppy_calc_xraylib with FUNCTION = %s. " %
(functions[FUNCTION]))
if FUNCTION == 0:
if TRANSITION_IUPAC_OR_SIEGBAHN == 0:
lines = [
'K', 'L1', 'L2', 'L3', 'M1', 'M2', 'M3', 'M4', 'M5', 'N1',
'N2', 'N3', 'N4', 'N5', 'N6', 'N7', 'O1', 'O2', 'O3', 'O4',
'O5', 'O6', 'O7', 'P1', 'P2', 'P3', 'P4', 'P5', 'Q1', 'Q2',
'Q3'
]
line = lines[TRANSITION_IUPAC_TO] + lines[
TRANSITION_IUPAC_FROM] + "_LINE"
command = "result = xraylib.LineEnergy(%d,xraylib.%s)" % (ELEMENT,
line)
print("executing command: ", command)
line = getattr(xraylib, line)
result = xraylib.LineEnergy(ELEMENT, line)
print("result: %f keV" % (result))
if TRANSITION_IUPAC_OR_SIEGBAHN == 1:
lines = [
'KA1_LINE', 'KA2_LINE', 'KB1_LINE', 'KB2_LINE', 'KB3_LINE',
'KB4_LINE', 'KB5_LINE', 'LA1_LINE', 'LA2_LINE', 'LB1_LINE',
'LB2_LINE', 'LB3_LINE', 'LB4_LINE', 'LB5_LINE', 'LB6_LINE',
'LB7_LINE', 'LB9_LINE', 'LB10_LINE', 'LB15_LINE', 'LB17_LINE',
'LG1_LINE', 'LG2_LINE', 'LG3_LINE', 'LG4_LINE', 'LG5_LINE',
'LG6_LINE', 'LG8_LINE', 'LE_LINE', 'LL_LINE', 'LS_LINE',
'LT_LINE', 'LU_LINE', 'LV_LINE'
]
line = lines[TRANSITION_SIEGBAHN]
command = "result = xraylib.LineEnergy(%d,xraylib.%s)" % (ELEMENT,
line)
print("executing command: ", command)
line = getattr(xraylib, line)
result = xraylib.LineEnergy(ELEMENT, line)
print("result: %f keV" % (result))
if TRANSITION_IUPAC_OR_SIEGBAHN == 2:
lines = [
'K', 'L1', 'L2', 'L3', 'M1', 'M2', 'M3', 'M4', 'M5', 'N1',
'N2', 'N3', 'N4', 'N5', 'N6', 'N7', 'O1', 'O2', 'O3', 'O4',
'O5', 'O6', 'O7', 'P1', 'P2', 'P3', 'P4', 'P5', 'Q1', 'Q2',
'Q3'
]
for i1, l1 in enumerate(lines):
for i2, l2 in enumerate(lines):
if i1 != i2:
line = l1 + l2 + "_LINE"
try:
line = getattr(xraylib, line)
result = xraylib.LineEnergy(ELEMENT, line)
except:
pass
else:
if result != 0.0:
print("%s%s %f keV" % (l1, l2, result))
elif FUNCTION == 1:
shells = [
'All shells', 'K_SHELL', 'L1_SHELL', 'L2_SHELL', 'L3_SHELL',
'M1_SHELL', 'M2_SHELL', 'M3_SHELL', 'M4_SHELL', 'M5_SHELL',
'N1_SHELL', 'N2_SHELL', 'N3_SHELL', 'N4_SHELL', 'N5_SHELL',
'N6_SHELL', 'N7_SHELL', 'O1_SHELL', 'O2_SHELL', 'O3_SHELL',
'O4_SHELL', 'O5_SHELL', 'O6_SHELL', 'O7_SHELL', 'P1_SHELL',
'P2_SHELL', 'P3_SHELL', 'P4_SHELL', 'P5_SHELL', 'Q1_SHELL',
'Q2_SHELL', 'Q3_SHELL'
]
if SHELL == 0: #"all"
for i, myshell in enumerate(shells):
if i >= 1:
# command = "result = xraylib.EdgeEnergy(%d,xraylib.%s)"%(ELEMENT,myshell)
# print("executing command: ",command)
shell_index = getattr(xraylib, myshell)
try:
result = xraylib.EdgeEnergy(ELEMENT, shell_index)
except:
pass
else:
if result != 0.0:
print("%s %f keV" % (myshell, result))
else:
print("No result")
else:
shell_index = getattr(xraylib, shells[SHELL])
try:
command = "result = xraylib.EdgeEnergy(%d,xraylib.%s)" % (
ELEMENT, shells[SHELL])
print("executing command: ", command)
result = xraylib.EdgeEnergy(ELEMENT, shell_index)
except:
pass
else:
if result != 0.0:
print("Z=%d %s : %f keV" %
(ELEMENT, shells[SHELL], result))
else:
print("No result")
elif FUNCTION == 2:
result = xraylib.AtomicWeight(ELEMENT)
if result != 0.0:
print("Atomic weight for Z=%d : %f g/mol" % (ELEMENT, result))
elif FUNCTION == 3:
result = xraylib.ElementDensity(ELEMENT)
if result != 0.0:
print("Element density for Z=%d : %f g/cm3" % (ELEMENT, result))
else:
print("No result")
elif FUNCTION == 4:
command = "result = xraylib.CS_Total_CP('%s',%f)" % (ELEMENTORCOMPOUND,
ENERGY)
print("executing command: ", command)
result = xraylib.CS_Total_CP(ELEMENTORCOMPOUND, ENERGY)
if result != 0.0:
print("Total absorption cross section: %f g/cm3" % (result))
else:
print("No result")
elif FUNCTION == 5:
command = "result = xraylib.CS_Photo_CP('%s',%f)" % (ELEMENTORCOMPOUND,
ENERGY)
print("executing command: ", command)
result = xraylib.CS_Photo_CP(ELEMENTORCOMPOUND, ENERGY)
if result != 0.0:
print("Photoionization cross section: %f g/cm3" % (result))
else:
print("No result")
elif FUNCTION == 6:
shells = [
'All shells', 'K_SHELL', 'L1_SHELL', 'L2_SHELL', 'L3_SHELL',
'M1_SHELL', 'M2_SHELL', 'M3_SHELL', 'M4_SHELL', 'M5_SHELL',
'N1_SHELL', 'N2_SHELL', 'N3_SHELL', 'N4_SHELL', 'N5_SHELL',
'N6_SHELL', 'N7_SHELL', 'O1_SHELL', 'O2_SHELL', 'O3_SHELL',
'O4_SHELL', 'O5_SHELL', 'O6_SHELL', 'O7_SHELL', 'P1_SHELL',
'P2_SHELL', 'P3_SHELL', 'P4_SHELL', 'P5_SHELL', 'Q1_SHELL',
'Q2_SHELL', 'Q3_SHELL'
]
if SHELL == 0: #"all"
for index in range(1, len(shells)):
shell_index = getattr(xraylib, shells[index])
try:
command = "result = xraylib.xraylib.CS_Photo_Partial('%d',xraylib.%s,%f)" % (
ELEMENT, shells[index], ENERGY)
print("executing command: ", command)
result = xraylib.CS_Photo_Partial(ELEMENT, shell_index,
ENERGY)
except:
pass
else:
if result != 0.0:
print("Z=%d, %s at E=%f keV: %f cm2/g" %
(ELEMENT, shells[index], ENERGY, result))
else:
print("No result")
else:
shell_index = getattr(xraylib, shells[SHELL])
try:
command = "result = xraylib.xraylib.CS_Photo_Partial('%d',xraylib.%s,%f)" % (
ELEMENT, shells[SHELL], ENERGY)
print("executing command: ", command)
result = xraylib.CS_Photo_Partial(ELEMENT, shell_index, ENERGY)
except:
pass
else:
if result != 0.0:
print("Z=%d, %s at E=%f keV: %f cm2/g" %
(ELEMENT, shells[SHELL], ENERGY, result))
else:
print("No result")
elif FUNCTION == 7:
command = "result = xraylib.CS_Rayl_CP('%s',%f)" % (ELEMENTORCOMPOUND,
ENERGY)
print("executing command: ", command)
result = xraylib.CS_Rayl_CP(ELEMENTORCOMPOUND, ENERGY)
if result != 0.0: print("Rayleigh cross section: %f cm2/g" % (result))
else: print("No result")
elif FUNCTION == 8:
command = "result = xraylib.CS_Compt_CP('%s',%f)" % (ELEMENTORCOMPOUND,
ENERGY)
print("executing command: ", command)
result = xraylib.CS_Compt_CP(ELEMENTORCOMPOUND, ENERGY)
if result != 0.0: print("Compton cross section: %f cm2/g" % (result))
else: print("No result")
elif FUNCTION == 9:
command = "result = xraylib.CS_KN(%f)" % (ENERGY)
print("executing command: ", command)
result = xraylib.CS_KN(ENERGY)
if result != 0.0:
print("Klein Nishina cross section: %f cm2/g" % (result))
else:
print("No result")
elif FUNCTION == 10:
command = "result = xraylib.CS_Energy_CP('%s',%f)" % (
ELEMENTORCOMPOUND, ENERGY)
print("executing command: ", command)
result = xraylib.CS_Energy_CP(ELEMENTORCOMPOUND, ENERGY)
if result != 0.0:
print("Mass-energy absorption cross section: %f cm2/g" % (result))
else:
print("No result")
else:
print("\n#### NOT YET IMPLEMENTED ####")
def atomicWeight(element,Z):
z = elementDB[element]["Z"]
return xraylib.AtomicWeight(z)
def test_Fe(self):
weight = xraylib.AtomicWeight(26)
self.assertAlmostEqual(weight, 55.850)
def ele_weight(atomicNumber):
W = xl.AtomicWeight(atomicNumber)
return W
def test_refractiveindex(self):
density = float(2.328)
c = compoundfromformula.CompoundFromFormula("Si", density, name="silicon")
energy = np.asarray([5, 10], dtype=float)
Z = 14
# Xraylib (TODO: n_im sign is wrong!)
n_re0 = np.asarray(
[xraylib.Refractive_Index_Re("Si", e, density) for e in energy]
)
n_im0 = -np.asarray(
[xraylib.Refractive_Index_Im("Si", e, density) for e in energy]
)
# Exactly like Xraylib (TODO: CS_Total -> CS_Photo_Total)
delta = (
density
* 4.15179082788e-4
* (Z + np.asarray([xraylib.Fi(Z, e) for e in energy]))
/ xraylib.AtomicWeight(Z)
/ energy ** 2
)
beta = (
np.asarray([xraylib.CS_Total(Z, e) for e in energy])
* density
* 9.8663479e-9
/ energy
)
n_re1 = 1 - delta
n_im1 = -beta
np.testing.assert_allclose(n_re0, n_re1)
np.testing.assert_allclose(n_im0, n_im1)
# Im: Kissel
n_im1b = (
-np.asarray([xraylib.CS_Total_Kissel(Z, e) for e in energy])
* density
* 9.8663479e-9
/ energy
)
# Im: Kissel with pint
n_im1d = (
ureg.Quantity(c.mass_att_coeff(energy), "cm^2/g")
* ureg.Quantity(c.density, "g/cm^3")
* ureg.Quantity(energy, "keV").to("cm", "spectroscopy")
/ (4 * np.pi)
)
n_im1d = -n_im1d.to("dimensionless").magnitude
r = n_im1b / n_im1d
np.testing.assert_allclose(r, r[0])
# Im: other formula
n_im1c = (
density
* 4.15179082788e-4
* (np.asarray([xraylib.Fii(Z, e) for e in energy]))
/ xraylib.AtomicWeight(Z)
/ energy ** 2
)
# Spectrocrunch
n_re2 = c.refractive_index_real(energy)
n_im2 = c.refractive_index_imag(energy)
np.testing.assert_allclose(n_re2, n_re0)
np.testing.assert_allclose(n_im2, n_im1c, rtol=1e-6)
