def setPositions(self, in_meta_data):
paramdict = XRFDataset().paramdict
paramdict["FitParams"]["pileup_cutoff_keV"] = \
self.parameters["pileup_cutoff_keV"]
paramdict["FitParams"]["include_pileup"] = \
self.parameters["include_pileup"]
paramdict["FitParams"]["include_escape"] = \
self.parameters["include_escape"]
paramdict["FitParams"]["fitted_energy_range_keV"] = \
self.parameters["fitted_energy_range_keV"]
if self.parameters['mono_energy'] is None:
paramdict["Experiment"]["incident_energy_keV"] = \
in_meta_data.get_meta_data("mono_energy")
else:
paramdict["Experiment"]["incident_energy_keV"] = \
self.parameters['mono_energy']
paramdict["Experiment"]["elements"] = \
self.parameters["elements"]
engy = self.findLines(paramdict)
# make it an index since this is what find peak will also give us
# print 'basefluo meta is:'+str(in_meta_data.get_dictionary().keys())
axis = self.axis = in_meta_data.get_meta_data("energy")
dq = axis[1] - axis[0]
logging.debug("the peak energies are:" + str(engy))
logging.debug("the offset is" + str(axis[0]))
self.idx = np.round((engy - axis[0]) / dq).astype(int)
return self.idx
def prep_xrfd(self, in_meta_data):
self.axis = in_meta_data.get_meta_data("energy")
xrfd = XRFDataset()
# now to overide the experiment
xrfd.paramdict["Experiment"] = {}
xrfd.paramdict["Experiment"]["incident_energy_keV"] = \
self.parameters["mono_energy"]
# print xrfd.paramdict["Experiment"]["incident_energy_keV"]
xrfd.paramdict["Experiment"]["collection_time"] = 1
xrfd.paramdict["Experiment"]['Attenuators'] = \
self.parameters['sample_attenuators']
xrfd.paramdict["Experiment"]['detector_distance'] = \
self.parameters['detector_distance']
xrfd.paramdict["Experiment"]['elements'] = \
self.parameters['elements']
xrfd.paramdict["Experiment"]['incident_angle'] = \
self.parameters['incident_angle']
xrfd.paramdict["Experiment"]['exit_angle'] = \
self.parameters['exit_angle']
xrfd.paramdict["Experiment"]['photon_flux'] = self.parameters['flux']
# overide the fitting parameters
xrfd.paramdict["FitParams"]["background"] = 'strip'
xrfd.paramdict["FitParams"][
"fitted_energy_range_keV"] = self.parameters[
"fitted_energy_range_keV"]
xrfd.paramdict["FitParams"]["include_pileup"] = self.parameters[
"include_pileup"]
xrfd.paramdict["FitParams"]["include_escape"] = self.parameters[
"include_escape"]
datadict = {}
datadict["rows"] = self.get_max_frames()
datadict["cols"] = 1 # we will just treat it as one long row
datadict["average_spectrum"] = np.zeros_like(self.axis)
datadict["Detectors"] = {}
datadict["Detectors"]["type"] = 'Vortex_SDD_Xspress'
xrfd.xrfdata(datadict)
xrfd._createSpectraMatrix()
if xrfd.paramdict['FitParams']['mca_energies_used'] == self.axis:
pass
else:
self.axis = xrfd.paramdict['FitParams']['mca_energies_used']
return xrfd
def findLines(self, paramdict=XRFDataset().paramdict):
"""
Calculates the line energies to fit
"""
# Incident Energy used in the experiment
# Energy range to use for fitting
pileup_cut_off = paramdict["FitParams"]["pileup_cutoff_keV"]
include_pileup = paramdict["FitParams"]["include_pileup"]
include_escape = paramdict["FitParams"]["include_escape"]
fitting_range = paramdict["FitParams"]["fitted_energy_range_keV"]
# x = paramdict["FitParams"]["mca_energies_used"]
energy = paramdict["Experiment"]["incident_energy_keV"]
detectortype = 'Vortex_SDD_Xspress'
fitelements = paramdict["Experiment"]["elements"]
peakpos = []
escape_peaks = []
for _j, el in enumerate(fitelements):
z = xl.SymbolToAtomicNumber(str(el))
for i, shell in enumerate(shells):
if (xl.EdgeEnergy(z, shell) < energy - 0.5):
linepos = 0.0
count = 0.0
for line in transitions[i]:
en = xl.LineEnergy(z, line)
if (en > 0.0):
linepos += en
count += 1.0
if (count == 0.0):
break
linepos = linepos / count
if (linepos > fitting_range[0]
and linepos < fitting_range[1]):
peakpos.append(linepos)
peakpos = np.array(peakpos)
too_low = set(list(peakpos[peakpos > fitting_range[0]]))
too_high = set(list(peakpos[peakpos < fitting_range[1]]))
bar = list(too_low and too_high)
bar = np.unique(bar)
peakpos = list(bar)
peaks = []
peaks.extend(peakpos)
if (include_escape):
for i in range(len(peakpos)):
escape_energy = calc_escape_energy(peakpos[i], detectortype)[0]
if (escape_energy > fitting_range[0]):
if (escape_energy < fitting_range[1]):
escape_peaks.extend([escape_energy])
# print escape_peaks
peaks.extend(escape_peaks)
if (include_pileup): # applies just to the fluorescence lines
pileup_peaks = []
peakpos1 = np.array(peakpos)
peakpos_high = peakpos1[peakpos1 > pileup_cut_off]
peakpos_high = list(peakpos_high)
for i in range(len(peakpos_high)):
foo = [peakpos_high[i] + x for x in peakpos_high[i:]]
foo = np.array(foo)
pileup_peaks.extend(foo)
pileup_peaks = np.unique(sorted(pileup_peaks))
peaks.extend(pileup_peaks)
peakpos = peaks
peakpos = np.array(peakpos)
too_low = set(list(peakpos[peakpos > fitting_range[0]]))
too_high = set(list(peakpos[peakpos < fitting_range[1] - 0.5]))
bar = list(too_low and too_high)
bar = np.unique(bar)
peakpos = list(bar)
peakpos = np.unique(peakpos)
# print peakpos
return peakpos
