PyMca XAS treatments

pymca functions

The est processes are made from pymca functions. The main class dealing with XAS in pymca is the XASClass Here is the initialization of the class:

from PyMca5.PyMcaPhysics.xas.XASClass import XASClass
pymca_xas = XASClass()

The XASClass is associated to a XASParameters

Then we have to set some spectrum

from PyMca5.PyMcaIO import specfilewrapper as specfile

def read_spectrum(spec_file):
    """

    :param spec_file: path to the spec file containing the spectrum definition
    :return: (energy, mu)
    :rtype: tuple
    """

    scan = specfile.Specfile(spec_file)[0]
    data = scan.data()

    if data.shape[0] == 2:
        energy = data[0, :]
        mu = data[1, :]
    else:
        energy = None
        mu = None
        labels = scan.alllabels()
        i = 0
        for label in labels:
            if label.lower() == "energy":
                energy = data[i, :]
            elif label.lower() in ["counts", "mu", "absorption"]:
                mu = data[i, :]
            i = i + 1
        if (energy is None) or (mu is None):
            if len(labels) == 3:
                if labels[0].lower() == "point":
                    energy = data[1, :]
                    mu = data[2, :]
                else:
                    energy = data[0, :]
                    mu = data[1, :]
            else:
                energy = data[0, :]
                mu = data[1, :]
    return energy, mu

import os
from PyMca5.PyMcaPhysics.xas.XASClass import XASClass

from PyMca5.PyMcaDataDir import PYMCA_DATA_DIR
data_file = os.path.join(PYMCA_DATA_DIR, "EXAFS_Cu.dat")

energy, mu = read_spectrum(data_file)
print(energy)
print(mu)
pymca_xas = XASClass()

pymca_xas.setSpectrum(energy, mu)

[8002.894 8007.32  8011.75  ... 9972.721 9975.502 9978.284]
[0.5249888 0.5236315 0.5225714 ... 2.264979  2.263324  2.262075 ]

normalization

ddict_norm = pymca_xas.normalize()
ddict_norm

{'Jump': 2.7182920330495683,
 'JumpNormalizationMethod': 'Flattened',
 'Edge': 8981.095829364065,
 'NormalizedEnergy': array([8002.894, 8007.32 , 8011.75 , ..., 9972.721, 9975.502, 9978.284]),
 'NormalizedMu': array([0.00286416, 0.00261019, 0.00246576, ..., 1.02419698, 1.02461713,
        1.02524238]),
 'NormalizedBackground': array([0.51720316, 0.51653625, 0.51586874, ..., 0.22038917, 0.21997013,
        0.21955093]),
 'NormalizedSignal': array([3.94772789, 3.94383839, 3.93994538, ..., 2.21667492, 2.21423102,
        2.21178624]),
 'NormalizedPlotMin': 8002.894,
 'NormalizedPlotMax': 9481.095829364065}

output should be

EXAFS (signal extraction)

from PyMca5.PyMcaPhysics.xas.XASClass import e2k
params = pymca_xas._configuration["DefaultBackend"]["EXAFS"]
e0 = ddict_norm["Edge"]
kValues = e2k(energy - e0)
ddict_pe = pymca_xas.postEdge(k=kValues, mu=mu, backend=None)
print(ddict_pe)

{'PostEdgeK': array([-16.02332998, -15.98703908, -15.95063269, ...,  16.13289519,
        16.1555016 ,  16.17808453]), 'PostEdgeB': array([168.94520652, 168.04735184, 167.14989123, ...,   2.26707394,
         2.26555332,   2.26403998]), 'KnotsX': array([ 5.5445213,  9.089043 , 12.633563 ], dtype=float32), 'KnotsY': array([3.0420222, 2.8137376, 2.5351834], dtype=float32), 'KMin': 2, 'KMax': 16.17808452796121, 'KWeight': 0}

k weight

will just update k in the EXAFS and Fourier transform classes.

Fourier transform

from PyMca5.PyMcaPhysics.xas.XASClass import XASClass
pymca_xas = XASClass()
ddict = pymca_xas.fourierTransform(k=kValues, mu=mu, kMin=None, kMax=None)

est - xas workflow

To keep compatibility and to normalize the process we defined processes from tomwer which are based on the pymca functions. Those are simple function to be called with a configuration (as a dict)

TODO: present XASBase and PyMcaXAS classes

Reading a spectrum file (and a configuration file)

from PyMca5.PyMcaDataDir import PYMCA_DATA_DIR
import os
data_file = os.path.join(PYMCA_DATA_DIR, "EXAFS_Cu.dat")

from est.core.io import read as read_pymca_xas
from silx.io.url import DataUrl
from est.core.types import Dim
spec_url = DataUrl(file_path=data_file, scheme='PyMca')
print(spec_url.scheme())
xas_obj = read_pymca_xas(spectra_url=DataUrl(file_path=data_file, scheme='PyMca', data_path='Column 2'), channel_url=DataUrl(file_path=data_file, scheme='PyMca', data_path='Column 1'))
assert 'Mu' in xas_obj.spectra.data.flat[0]

PyMca

normalization

from est.core.process.pymca.normalization import pymca_normalization
xas_obj = pymca_normalization(xas_obj.copy())
assert 'NormalizedMu' in xas_obj.spectra.data.flat[0]

normalization: [####################] 100% DONE

exafs

from est.core.process.pymca.exafs import pymca_exafs
xas_obj = pymca_exafs(xas_obj.copy())
assert 'PostEdgeB' in xas_obj.spectra.data.flat[0]

exafs: [####################] 100% DONE

k weight

from est.core.process.pymca.k_weight import pymca_k_weight
l_xas_obj = xas_obj.copy()
l_xas_obj.configuration['SET_KWEIGHT'] = 1

xas_obj = pymca_k_weight(l_xas_obj)
assert xas_obj.spectra.data.flat[0]['KWeight'] == 1

k weight: [####################] 100% DONE

Fourier transform

from est.core.process.pymca.ft import pymca_ft
xas_obj = pymca_ft(xas_obj.copy())
assert 'FTRadius' in xas_obj.spectra.data.flat[0]['FT']

ft: [####################] 100% DONE