def testfrom_string(self):
self.assertEqual(from_string('Al Ka1'), Transition(13, siegbahn='Ka1'))
self.assertEqual(from_string('Al K-L3'), Transition(13, siegbahn='Ka1'))
self.assertEqual(from_string('Al Ka'), Ka(13))
self.assertEqual(from_string('Al K-L(2,3)'), Ka(13))
self.assertEqual(from_string('Al K'), K_family(13))
self.assertRaises(ValueError, from_string, 'Al K a1')
self.assertRaises(ValueError, from_string, 'Al Kc1')
def testfrom_string(self):
self.assertEqual(from_string('Al Ka1'), Transition(13, siegbahn='Ka1'))
self.assertEqual(from_string('Al K-L3'), Transition(13,
siegbahn='Ka1'))
self.assertEqual(from_string('Al Ka'), Ka(13))
self.assertEqual(from_string('Al K-L(2,3)'), Ka(13))
self.assertEqual(from_string('Al K'), K_family(13))
self.assertRaises(ValueError, from_string, 'Al K a1')
self.assertRaises(ValueError, from_string, 'Al Kc1')
def _load_photonintensity(zipfile, key):
fp = zipfile.open(key + '.csv', 'r')
reader = csv.reader(StringIO(fp.read().decode('ascii')))
next(reader)
intensities = {}
for row in reader:
transition = from_string(row[0])
# skip row[1] (energy)
intensities[PhotonKey(transition, False, PhotonKey.P)] = \
(float(row[6]), float(row[7]))
intensities[PhotonKey(transition, False, PhotonKey.C)] = \
(float(row[2]), float(row[3]))
intensities[PhotonKey(transition, False, PhotonKey.B)] = \
(float(row[4]), float(row[5]))
intensities[PhotonKey(transition, False, PhotonKey.T)] = \
(float(row[8]), float(row[9]))
intensities[PhotonKey(transition, True, PhotonKey.P)] = \
(float(row[14]), float(row[15]))
intensities[PhotonKey(transition, True, PhotonKey.C)] = \
(float(row[10]), float(row[11]))
intensities[PhotonKey(transition, True, PhotonKey.B)] = \
(float(row[12]), float(row[13]))
intensities[PhotonKey(transition, True, PhotonKey.T)] = \
(float(row[16]), float(row[17]))
return PhotonIntensityResult(intensities)
def iter_results(self, transition, primary, absorption,
characteristic_fluorescence, bremsstrahlung_fluorescence):
if isinstance(transition, str):
transition = from_string(transition)
keys = self._create_photon_keys(transition, primary, absorption,
characteristic_fluorescence,
bremsstrahlung_fluorescence)
for key in keys:
yield self[key]
def has_transition(self, transition):
"""
Returns whether the result contains an intensity for the specified
transition.
:arg transition: transition or set of transitions or name of the
transition or transitions set (see examples in :meth:`.intensity`)
"""
if isinstance(transition, str):
transition = from_string(transition)
for key in self._results.keys():
if key.transition == transition:
return True
return False
def _create_key(self, transition, name):
transition = xraytransition.from_string(transition)
absorption = name.startswith('e')
if name[1:] == 'nf':
flag = PhotonKey.PRIMARY
elif name[1:] == 'cf':
flag = PhotonKey.CHARACTERISTIC_FLUORESCENCE
elif name[1:] == 'bf':
flag = PhotonKey.BREMSSTRAHLUNG_FLUORESCENCE
elif name[1:] == 't':
flag = PhotonKey.TOTAL
elif name[1:] == 'f':
flag = PhotonKey.FLUORESCENCE
return PhotonKey(transition, absorption, flag)
def _import_photon_intensity(self, options, name, detector, path):
wxrresult = CharacteristicIntensity(path)
factor = self._get_normalization_factor(options, detector)
# Retrieve intensities
intensities = {}
for z, line in wxrresult.getAtomicNumberLines():
data = wxrresult.intensities[z][line]
transition = from_string("%s %s" % (symbol(z), line))
gnf = list(map(mul, data[WXRGENERATED], [factor] * 2))
enf = list(map(mul, data[WXREMITTED], [factor] * 2))
intensities[PhotonKey(transition, False, PhotonKey.P)] = gnf
intensities[PhotonKey(transition, True, PhotonKey.P)] = enf
return PhotonIntensityResult(intensities)
def _extract(data, absorption):
distributions = {}
for z in data:
for xrayline in data[z]:
transition = from_string(symbol(z) + " " + xrayline)
dist = np.array(data[z][xrayline]).T
# Convert z values in meters
dist[:, 0] *= -1e-9
# WinXRay starts from the bottom to the top
# The order must be reversed
dist = dist[::-1]
key = PhotonKey(transition, absorption, PhotonKey.P)
distributions[key] = dist
return distributions
def exists(self, transition, primary=True, absorption=True,
characteristic_fluorescence=True, bremsstrahlung_fluorescence=True):
"""
Returns whether the result contains a photon distribution for
the specified transition.
:arg transition: transition or set of transitions or name of the
transition or transitions set (see examples in :meth:`.get`)
:arg absorption: distribution with absorption. If ``True``, emitted
distribution is returned, if ``False`` generated distribution.
:arg fluorescence: distribution with fluorescence. If ``True``,
distribution with fluorescence is returned, if ``False``
distribution without fluorescence.
"""
if isinstance(transition, str):
transition = from_string(transition)
keys = self._create_photon_keys(transition, primary, absorption,
characteristic_fluorescence,
bremsstrahlung_fluorescence)
return len(keys) == 1
def _import_photon_intensity(self, options, name, detector, jobdir):
intensities_filepath = os.path.join(jobdir, 'intensities_%s.csv' % name)
if not os.path.exists(intensities_filepath):
raise ImporterException('Result file "intensites_%s.csv" not found in job directory (%s)' % \
(name, jobdir))
intensities = {}
with open(intensities_filepath, 'r') as fp:
reader = csv.DictReader(fp, delimiter=';')
try:
row = next(reader)
except StopIteration:
row = {}
for transition, intensity in row.items():
transition = from_string(transition.strip())
enf = (float(intensity.strip().replace(',', '.')), 0.0) # FIXME: Hack to handle locale problem
intensities[PhotonKey(transition, True, PhotonKey.P)] = enf
return PhotonIntensityResult(intensities)
def _load_phirhoz(zipfile, key):
# Find all phi-rho-z files
arcnames = [name for name in zipfile.namelist() if name.startswith(key)]
# Read files
distributions = {}
for arcname in arcnames:
parts = os.path.splitext(arcname)[0].split('+')
transition = from_string(parts[-2].replace('_', ' '))
suffix = parts[-1]
absorption = suffix.startswith('e')
if suffix[1:] == 'nf':
flag = PhotonKey.PRIMARY
elif suffix[1:] == 'cf':
flag = PhotonKey.CHARACTERISTIC_FLUORESCENCE
elif suffix[1:] == 'bf':
flag = PhotonKey.BREMSSTRAHLUNG_FLUORESCENCE
elif suffix[1:] == 't':
flag = PhotonKey.TOTAL
elif suffix[1:] == 'f':
flag = PhotonKey.FLUORESCENCE
key = PhotonKey(transition, absorption, flag)
fp = zipfile.open(arcname, 'r')
reader = csv.reader(StringIO(fp.read().decode('ascii')))
next(reader)
zs = []
values = []
uncs = []
for row in reader:
zs.append(float(row[0]))
values.append(float(row[1]))
uncs.append(float(row[2]))
datum = np.array([zs, values, uncs]).T
distributions[key] = datum
return PhotonDepthResult(distributions)
def _get_intensity(self, transition, primary, absorption,
characteristic_fluorescence, bremsstrahlung_fluorescence):
def _create_photon_keys2(transition):
return self._create_photon_keys(transition, primary, absorption,
characteristic_fluorescence,
bremsstrahlung_fluorescence)
if isinstance(transition, str):
transition = from_string(transition)
# Collect photon keys
list_keys = []
if isinstance(transition, transitionset): # transitionset
keys = _create_photon_keys2(transition)
for key in keys:
if key in self:
list_keys.append(key)
else:
for t in transition:
keys = _create_photon_keys2(t)
list_keys.extend(keys)
else: # single transition
keys = _create_photon_keys2(transition)
list_keys.extend(keys)
# Retrieve intensity (and its uncertainty)
total_val = 0.0
total_unc = 0.0
for key in list_keys:
try:
intensity = self[key]
except KeyError:
continue
total_val += intensity[0][0]
total_unc += intensity[0][1] ** 2
total_unc = sqrt(total_unc)
return total_val, total_unc
def _import_phi_z(self, options, name, detector, jobdir):
prz_filepath = os.path.join(jobdir, 'phi_%s.csv' % name)
if not os.path.exists(prz_filepath):
raise ImporterException('Result file "phi_%s.csv" not found in job directory (%s)' % \
(name, jobdir))
with open(prz_filepath, 'r') as fp:
reader = csv.reader(fp, delimiter=';')
header = next(reader)
data = {}
for row in reader:
for i, val in enumerate(row):
data.setdefault(header[i], []).append(float(val.replace(',', '.'))) # FIXME: Hack to handle locale problem
rzs = np.array(data.pop('rho z'))
distributions = {}
for transition, values in data.items():
transition = from_string(transition.strip())
enf = np.array([rzs, values]).transpose()
distributions[PhotonKey(transition, True, PhotonKey.P)] = enf
return PhiZResult(distributions)
