\(\newcommand{\AA}{\unicode{x212B}}\)
13.7. XAFS: Reading and using Feff Paths¶
For modeling EXAFS data, Larch relies heavily on calculations of theoretical XAFS spectra using Feff. Being able to run Feff and use its results is of fundamental importance for using Larch for fitting EXAFS spectra. While a complete description of Feff ([Rehr et al. (1991)], [Zabinsky et al. (1995)], [Rehr and Albers (2000)]) is beyond the scope of this documentation, here we describe how to read the results from Feff into Larch.
The funcionality of Feff within Larch has been evolving to better incorporate Feff8l into Larch. Feff8L provideds a free version of Feff Version 8.5 for EXAFS calculations (not XANES or other spectroscopies), and is being developed in parallel to Larch at feff85exafs [1]. Part of the goal for this project is to replace Feff Version 6l as a robust and easy-to-use EXAFS calculation engine for EXAFS Analysis. A larger goal for feff85exafs and Larch is to be able to create the potentials and scattering factors needed for the EXAFS calculation, and then to be able to use that to dynamically create EXAFS scatternig paths with changing geometries. This is a work-in-progress. If you’re interested in exploring or helping with this, contact us!
The main interface for this is the feffpath()
function that
reads feffNNNN.dat file and creates a FeffPath Group.
13.7.1. Running Feff¶
Larch comes with external programs for Feff6l and Feff8l, and provides two
simple functions for running the external Feff6l andFeff8l programs from
within Larch: feff6l()
and feff8l()
. Note that the input files
for these two programs are similar but have important differences in syntax
such that the input for one cannot be used for running the other.
13.7.1.1. Running Feff6l with feff6l()
¶
- feff6l(folder='.', feffinp='feff.inp', verbose=True)¶
run Feff6 in the supplied folder.
- Parameters:
folder – name of folder containing the Feff6 input file, and where to put the output files [‘.’, the current working directory]
feffinp – name of feff.inp file within the supplied folder [‘feff.inp’]
verbose – flag controlling screen output from Feff [True]
- Returns:
a FeffRunner Group.
This will generate a number of outputs, including the feffNNNN.dat files containing the data for each scattering path.
13.7.1.2. Running Feff8l with feff8l()
¶
- feff8l(folder='.', feffinp='feff.inp', verbose=True)¶
run Feff8L in the supplied folder.
- Parameters:
folder – name of folder containing the Feff6 input file, and where to put the output files [‘.’, the current working directory]
feffinp – name of feff.inp file within the supplied folder [‘feff.inp’]
verbose – flag controlling screen output from Feff [True]
- Returns:
a FeffRunner Group.
As with feff6l()
, this will generate a number of outputs, including the feffNNNN.dat files
containing the data for each scattering path.
13.7.1.3. Running Feff8l with feffrunner()
¶
The incorporation of Feff8l in Larch is still in development, but is ntended to make the executables from the feff85exafs package easy to use and a seamless drop-in replacement for Feff6l. The FeffRunner tool is quite flexible and can be used to run specific modules from feff85exafs or other versions of Feff that you might have on your computer.
- feffrunner(feffinp=None, verbose=True, repo=None)¶
create a FeffRunner Group from a feff.inp file.
- Parameters:
feffinp – name (full path of) feff.inp file
verbose – flag controlling screen output from Feff [True]
repo – full path of the location of the Feff8l repository [None]
- Returns:
a FeffRunner Group.
- feffrunner.run(exe)¶
run Feff for FeffRunner Group.
- Parameters:
exe – the name of the Feff program to be run [run all of Feff8l]
- Returns:
None when Feff is run successfully or an Exception when a problem in encoiuntered
The simplest example of its use is
feff = feffrunner('path/to/feff.inp')
feff.run()
The feff.inp file is specified when the Group is created, then feff85exafs is run in the same folder as the feff.inp file. In this case, since no argument is given to the run() method, the various modules of feff85exafs are run in sequence. This behaves much like the monolithic Feff executables of yore.
The feff85exafs modules (rdinp, pot, xsph, pathfinder, genfmt, and ff2x) can be be run individually
feff = feffrunner('path/to/feff.inp')
feff.run('rdinp')
feff.run('pot')
## and so on ...
To specifically use the feff85exafs modules from a local copy of the feff8l repository, do
feff = feffrunner('path/to/feff.inp')
feff.repo = '/home/bruce/git/feff85exafs'
feff.run()
The repo
attribute is used when working on feff85exafs itself.
For example, the feff85exafs unit tests set the repo
attribute
so that the just-compiled versions of the programs get used.
If you have an executable for some other version of Feff in a location that in your shell’s execution path and it is called something like feff6, feff7, or any other name than begins with feff, that can be run as
feff = feffrunner('path/to/feff.inp')
feff.run('feff6') # or whatever your executable is called
If the _xafs._feff_executable symbol in Larch’s symbol table is set to a valid executable, then you can use that by doing
feff = feffrunner('path/to/feff.inp')
feff.run(None)
The feff.inp file need not be called by that name. FeffRunner will copy the specified file to feff.inp in the specified folder – taking care not to clobber an existing feff.inp file – before running Feff. Once finished, it will copy files back to their original names.
A log file called f85e.log is written in the same folder as the feff.inp. This log file captures all of the screen output (both STDOUT and STDERR) from Feff.
The full structure of the FeffRunner group looks something like this:
== External Feff Group: Copper/testrun/feff.inp: 5 symbols ==
feffinp: 'Copper/testrun/feff.inp'
repo: None
resolved: '/usr/local/bin/ff2x'
run: <bound method FeffRunner.run of <External Feff Group: Copper/testrun/feff.inp>>
verbose: True
The resolved
attribute has the fully resolved path to the most
recently run executable. This can be used to verify that the
logic for executable resolution described above worked as intended.
13.7.2. feffpath()
and FeffPath Groups¶
The outputs from Feff for each path are complicated enough to need a
structured organization of data. This is accomplished by providing a
special kind of a Larch Group – a FeffPath Group which holds all the
information about a Feff Path, including the photo-electron scattering
amplitudes and phase-shifts needed to describe and calculate the EXAFS for
that Path. A FeffPath Group is created with the feffpath()
group. For many uses a Feff Path can be treated as a “black box”, and
simply setting the adjustable Path Parameters and passing around these
Groups is sufficient for simulating and fitting EXAFS spectra.
At times it can be helpful to inspect and study the detailed components of the Feff Path. Since a FeffPath Group is a regular Larch Group, all the data can be read and viewed. A FeffPath Group has the components listed in the Table of Feff Path Parameters. This includes the Adjustable Numerical Path Parameters – the values of which can be changed to affect the calculated EXAFS for the Path – as well as the arrays for \(k\) and \(\chi\) and several other attributes. Since this Group is used to calculate \(\chi(k)\) for the path, many of the components need to be in place and holding the expected values so that the calculation can be done correctly, Due to Larch’s flexibility, it is possible to delete, overwrite, or put inappropriate values into the components of a FeffPath Group, and care must be taken to avoid this.
Table of FeffPath Parameters, including the Path Parameters used in the EXAFS equation. The attributes here are arranged by category. The Info attributes are informational only. The two Numerical attributes
reff
andnleg
are used in the EXAFS equation but are meant to be constants and their values should not be changed. The Adjustable attributes are the standard Adjustable, Numerical Path Parameters that can be changed to affect the resulting EXAFS \(\chi(k)\). These can be set either as constant values or fitting Parameters as defined by_math.param()
. The Output array attributes are the arrays output frompath2chi()
. Finally, the sub-group_feffdat
contains the low-level data as read directly from the feffNNNN.dat file, which is detailed in the next section, The _feffdat Group: Full Details of the Feff.Dat File.
attribute name
category
description
filename
Info
name of feffNNNN.dat file
label
Info
path description
geom
Info
path geometry: list of (symbol, ipot, x, y, z)
reff
Numerical
\(R_{\rm eff}\), nominal path length
nleg
Numerical
number of path legs (1+number of scatterers)
degen
Adjustable
\(N\), path degeneracy
s02
Adjustable
\(S_0^2\), amplitude reduction factor
e0
Adjustable
\(E_0\), energy origin
deltar
Adjustable
\(\Delta R\), shift in path length
sigma2
Adjustable
\(\sigma^2\), mean-square displacement
third
Adjustable
\(c_3\), third cumulant
fourth
Adjustable
\(c_4\), the fourth cumulant
ei
Adjustable
\(E_i\), imaginary energy shift.
k
Output array
\(k\), photo-electron wavenumber
chi
Output array
\(\chi\), the EXAFS
chi_imag
Output array
\(\rm{Im}(\chi)\), imaginary EXAFS
p
Output array
\(p\), complex photo-electron wavenumber
_feffdat
Group
a Group containing raw data from feffNNNN.dat
- feffpath(filename, label=None, s02=None, degen=None, e0=None, deltar=None, sigma2=None, ...)¶
create a FeffPath Group from a feffNNNN.dat file.
- Parameters:
filename – name (full path of) feffNNNN.dat file
label – label for path [file name]
degen – path degeneracy, \(N\) [taken from file]
s02 – \(S_0^2\) value or parameter [1.0]
e0 – \(E_0\) value or parameter [0.0]
deltar – \(\Delta R\) value or parameter [0.0]
sigma2 – \(\sigma^2\) value or parameter [0.0]
third – \(c_3\) value or parameter [0.0]
fourth – \(c_4\) value or parameter [0.0]
ei – \(E_i\) value or parameter [0.0]
- Returns:
a FeffPath Group.
For all the options described above with value or parameter either a
numerical value or a Parameter (as created by _math.param()
) can be given.
13.7.3. path2chi()
and ff2chi()
: Generating \(\chi(k)\) for a FeffPath¶
- path2chi(path, paramgroup=None, kmax=None, kstep=0.05, k=None)¶
calculate \(\chi(k)\) for a single Feff Path.
- Parameters:
path – a FeffPath Group
paramgroup – a Parameter Group for calculating Path Parameters [
None
]kmax – maximum \(k\) value for \(\chi\) calculation [20].
kstep – step in \(k\) value for \(\chi\) calculation [0.05].
k – explicit array of \(k\) values to calculate \(\chi\).
- Returns:
None
If k
is specified, that will be used as the set of \(k\) values at which
to calculate \(\chi\). If not given, the values of kstep
and kmax
will be used to construct a uniformly-spaced array of \(k\) values starting
at 0 and extending to (and including) kmax
.
The calculated \(\chi\) array is placed in the Feff Path Group path
as
path.chi
. In addition calculated arrays for \(k\), \(p\), and
\(\rm{Im}(\chi)\) are placed in the variables path.k
, path.p
, and
path.chi_imag
, respectively. See The EXAFS Equation using Feff and FeffPath Groups for the
detailed definitions of the quantities.
If specified, paramgroup
is used as the Parameter Group – the group
used for evaluating parameter expressions (ie, constraints using named
variables). This is similar to the use for _math.minimize()
as discussed
in Parameters.
- ff2chi(pathlist, paramgroup=None, group=None, k=None, kmax=None, kstep=0.05)¶
sum the \(\chi(k)\) for a list of FeffPath Groups.
- Parameters:
pathlist – a list of FeffPath Groups
paramgroup – a Parameter Group for calculating Path Parameters [
None
]group – a Group to which the outputs are written [
None
]kmax – maximum \(k\) value for \(\chi\) calculation [20].
kstep – step in \(k\) value for \(\chi\) calculation [0.05].
k – explicit array of \(k\) values to calculate \(\chi\).
- Returns:
None
This essentially calls path2chi()
for each of the paths in the
pathlist
and writes the resulting arrays for \(k\) and \(\chi\) the
sum of \(\chi\) for all the paths) to group.k
and group.chi
.
13.7.4. The _feffdat Group: Full Details of the Feff.Dat File¶
Each FeffPath Group will have a _feffdat
sub-group which contains the
data from the underlying feffNNNN.dat file for the results of the Feff
calculation. Many of the components of this group are used for the
calculations of \(\chi(k)\) for that Path, though some (such as
exch
and edge
) are kept only for informational purposes. Some
components from this sub-group (notably as geom
and nleg
) are
copied into the FeffPath Group. As with the FeffPath Group, this Group has
an expected set of components that should be treated as read-only unless
you really know what you’re doing.
Table of Feff.dat components. Listed here is the component read from the Feff.dat file and stored in the
_feffdat
group for each FeffPath.
attribute
description
amp
array: total amplitude, \(F_{\rm eff}(k)\)
degen
path degeneracy (coordination number)
edge
energy threshold relative to atomic valu (a poor estimate)
exch
string describing electronic exchange model
filename
File name
gam_ch
core level energy width
geom
path geometry: list of (Symbol, Z, ipot, x, y, z)
k
array: k values, \(k_{\rm feff}\)
kf
k value at Fermi level
lam
array: mean-free path, \(\lambda(k)\)
mag_feff
array: magnitude of Feff
mu
Fermi level, eV
pha
array: total phase shift, \(\delta(k)\)
pha_feff
array: scattring phase shift
potentials
path potentials: list of (ipot, z, r_MuffinTin, r_Norman)
real_phc
array: central atom phase shift
red_fact
array: amplitude reduction factor
rep
array: real part of p, \(p_{\rm real}(k)\)
rnorman
Norman radius
rs_int
interstitial radius
title
user title
version
Feff version
vint
interstitial potential
The arrays from the data columns of the Feff data file break up the
amplitude and phase into two components (essentially as one for the central
atom and one for the scattering atoms) that are simply added together.
Thus amp
= red_fact
+ mag_feff
and the sum is used as
\(F_{\rm eff}(k)\). Similarly, pha
= real_phc
+ pha_feff
and the sum is used as \(\delta(k)\).
13.7.5. The EXAFS Equation using Feff and FeffPath Groups¶
Now we are ready to write down the full EXAFS equation used for a Feff Path using the terms defined above in the Table of Feff Path Parameters and the Table of Feff.Dat Components. One of the trickier concepts is that we are evaluating at experimental values of \(k\) while the Feff calculation is tabulated on its own set of \(k\) values and we may need to apply an energy shift of \(E_0\) to the Feff calculation. Thus, first we find \(k\) as
where \(E_0\) is taken from the e0
parameter and \(k_{\rm
feff}\) are the \(k\) values from Feff (_feffdat.k
). This shifted
\(k\) will be used to access the \(k\) dependent values from the
Feff arrays. Next, we note that we need the complex wavenumber, defined as
where \(p_{\rm real}\) and \(\lambda\) are the values from Feff
(_feffdat.rep
and _feffdat.lam
) and \(E_i\) is the complex energy
shift from the parameter ei
. Note that \(i\) is used as the complex
number following the physics literature, while within Larch 1j
is used.
The complex wavenumber \(p\) includes a self-energy term (due to the
presence of multiple electrons in the system) and is meant to be referenced
to the absorption threshod while \(k\) is meant to be referenced to the
Fermi level. Thus \(p_{\rm real} \approx \Sigma + k\), where
\(\Sigma\) is a small but usually positive offset. Within the EXAFS
equation, \(k\) is used to restore the calculation of \(\chi(k)\) as
done by Feff, while \(p\) is used to apply alterations to \(\chi(k)\)
as for disorder terms.
The EXAFS equation used for constructing \(\chi(k)\) from a Feff calculation is then
where the terms are all defined above. Again, note that \(k\) is used to reconstruct the unaltered EXAFS from the Feff.dat file, and the complex \(p\) is used for the terms adding the effects of disorder. Also note that \(p''\) becomes \(\lambda(k)\) for \(E_i = 0\), and is the generalization of the mean-free-path contribution. The terms \(\Delta R\), \(\sigma^2\), \(c_3\), and \(c_4\) are the first four cumulants of the atomic pair distribution for the selected path. The additional term \(-2p(2\sigma^2/R_{\rm eff})\) in the phase is a correction to the cumulant expansion due to the averaging over the \(1/R^2\) term in the EXAFS equation.
The use of the cumulant expansion here does not necessarily imply that systems must be ordered enough for their atomic distributios to modeled by the cumulant expansion. All that is required is that contribution from each path be ordered enough for the cumulant expansion to work. A highly disordered system can be modeled by applying a more complex weighting to a set of paths – that is, a histogram of paths.
13.7.6. Models for Calculating \(\sigma^2\)¶
The value for \(\sigma^2\) in the EXAFS equation gets a lot of
attention in the EXAFS literature, as it is often the only term used to
account for thermal and static disorder in an ensemble of Paths that makes
up a full EXAFS spectra. Borrowing from Feff (see [Rehr et al. (1991)],
[Sevillano, Meuth, and Rehr (1979)] and [Rehr and Albers (2000)]) Larch provides two functions
that use simple models to calculate \(\sigma^2\) for a Path. Both
functions, sigma2_eins()
and sigma2_debye()
take arguments of
sample temperature, a characteristic temperature, and a FeffPath, and
return a value of \(\sigma^2\). These are known to appy reasonably
well to very simple systems (such as metals and solids with few atomic
components), and less well to complex systems, including anything with
organic ligands.
- ..versionchanged:: 0.9.34
removed _sys.paramGroup, now using fiteval
- sigma2_eins(t, theta)¶
calculate \(\sigma^2\) in the Einstein model.
- Parameters:
t – sample temperature (in K)
theta – Einstein temperature (in K)
path – a FeffPath Group [
None
]
The path argument can be left None
. This will try to use the
‘’current FeffData group”, (_sys.fiteval.symtable._feffdat), which is
updated during fits with feffit()
and when summing paths with
ff2chi()
.
- sigma2_debye(t, theta, path=None)¶
calculate \(\sigma^2\) in the Debye model.
- Parameters:
t – sample temperature (in K)
theta – Debye temperature (in K)
path – a FeffPath Group [
None
]
As with sigma2_eins, the `path()
argument can be left None
, and the
‘’current FeffData group”, (_sys.fiteval.symtable._feffdat), will be used.
13.7.7. Example: Reading a Feff file¶
Here we simply read a feffNNNN.dat file and display its components, and calculate \(\chi\) for this path with two different values of \(\sigma^2\).
## examples/feffit/doc_feffdat1.lar
fname = 'feff0001.dat'
path1 = feffpath(fname)
path2chi(path1)
show(path1)
newplot(path1.k, path1.chi*path1.k**2, xlabel=r' $ k \rm\, (\AA^{-1})$',
ylabel=r'$ k^2\chi(k)$', label = r'$\sigma^2 = 0$', show_legend=True,
title=r'$\chi(k)$ from %s' % fname)
path1.sigma2 = 0.002
path2chi(path1)
plot(path1.k, path1.chi*path1.k**2, label = r'$\sigma^2 = 0.002$')
## end examples/feffit/doc_feffdat1.lar
The output of this looks like this:
== FeffPath Group feff0001.dat: 16 symbols ==
_feffdat: <Feff.dat File Group: feff0001.dat>
chi: array<shape=(401,), type=dtype('float64')>
chi_imag: array<shape=(401,), type=dtype('float64')>
degen: 12.0
deltar: 0
e0: 0
ei: 0
filename: 'feff0001.dat'
fourth: 0
geom: [('Cu', 29, 0, 0.0, 0.0, 0.0), ('Cu', 29, 1, 0.0, -1.8016, 1.8016)]
k: array<shape=(401,), type=dtype('float64')>
label: 'feff0001.dat'
p: array<shape=(401,), type=dtype('complex128')>
s02: 1
sigma2: 0
third: 0
After the initial read, the values of k
, p
, chi
, and
chi_imag
are set to None
, and are not calculated until
path2chi()
is called.
We can also use the data from the _feffdat
group to look at the
individual scattering components. Thus to look at the scattering amplitude
and mean-free-path for a particular scattering path, you could use a script
like this:
## examples/feffit/doc_feffdat2.lar
fname = 'feff0001.dat'
path1 = feffpath(fname)
newplot(path1._feffdat.k, path1._feffdat.amp, xlabel=r' $ k \rm\, (\AA^{-1})$',
ylabel=r'$ |F_{\rm eff}(k)|$', label = r'amp', show_legend=True,
title=r'components of _feffdat for %s' % fname,
marker='o', markersize=4)
plot(path1._feffdat.k, path1._feffdat.lam, side='right',
marker='o', markersize=4,
label = r'lam', y2label=r'$ \lambda(k) \rm\, (\AA)$')
## end examples/feffit/doc_feffdat2.lar
which will produce a plot like this:
You can see here that the arrays in the _feffdat
group are sampled at
varying \(k\) spacing, and that this spacing becomes fairly large at
high \(k\).
13.7.8. Example: Adding Feff files¶
Now, we add some Feff files together, applying some path parameters. The
example is actually very similar to the one above except that we use
ff2chi()
to create a \(\chi(k)\) from a list of paths, and put
the result into its own group. Thus:
## examples/feffit/doc_feffdat3.lar
# read some paths
path1 = feffpath('feff_feo01.dat')
path2 = feffpath('feff_feo02.dat')
path3 = feffpath('feff_feo03.dat')
path4 = feffpath('feff_feo04.dat')
path5 = feffpath('feff_feo05.dat')
# apply an e0 shift and s02 to all paths:
for p in (path1, path2, path3, path4, path5):
p.e0 = -0.5
p.s02 = 0.9
endfor
path1.sigma2 = 0.003
path2.sigma2 = 0.004
path3.sigma2 = 0.006
path4.sigma2 = 0.008
path5.sigma2 = 0.008
mysum = group(label='FeO sum of paths 1,2,3,4,5')
ff2chi([path1, path2, path3, path4, path5], group=mysum)
## now, we can also simply sum paths 3,4,5...
mysum.chi345 = path3.chi + path4.chi + path5.chi
newplot(mysum.k, mysum.chi*mysum.k**2, label='sum(1,2,3,4,5)', show_legend=True,
xlabel=r' $ k \rm\, (\AA^{-1})$',
ylabel=r'$ k^2\chi(k)$', title=mysum.label)
plot(path1.k, -2.+path1.chi*path1.k**2, label='path1')
plot(path2.k, -4+path2.chi*path2.k**2, label='path2')
plot(path3.k, -6+mysum.chi345*path3.k**2, label='sum(3,4,5)')
## end examples/feffit/doc_feffdat3.lar
With the result as shown below. Note that we can also make a simple sum of
a set of paths, which was done in this example to add the contributions of
paths 3, 4, and 5. This works because ff2chi()
runs path2chi()
for each path to be summed, so that the chi
component of the FeffPath
group is up to date.
13.7.9. Example: Using Path Parameters when adding Feff files¶
Using Parameters for modelling data is a key feature of Larch, and if you are modelling XAFS data with Feff, you will want to parameterize Path Parameters, apply them to a set of Paths, and investigate the resulting sum of Paths. This is similar to the examples above, but combines the Parameter concept from the Fitting chapter. In Larch, this looks like:
## examples/feffit/doc_feffdat4.lar
# read some paths
path1 = feffpath('feff_feo01.dat')
path2 = feffpath('feff_feo02.dat')
# create a group containing parameters
pars = group(del_e0 = param(-4.0, min=-10, max=10),
amp = param(0.8, min=0.3, max=1.5))
for p in (path1, path2):
p.e0 = 'del_e0'
p.s02 = 'amp'
p.sigma2 = 0.003
if p == path2: p.sigma2 = 0.005
endfor
mysum = group(label='FeO sum of paths')
ff2chi([path1, path2], group=mysum, paramgroup=pars)
label='E0=%.1f, S02=%.1f' % (pars.del_e0.value, pars.amp.value)
newplot(mysum.k, mysum.chi*mysum.k**2,
label=label, show_legend=True,
xlabel=r'$ k \rm\, (\AA^{-1})$',
ylabel=r'$ k^2\chi(k)$', title=mysum.label)
# now change parameter values, re-do sum
pars.del_e0.value = 3.5
pars.amp.value = 1.0
# re-calculate chi for each path with paramgroup set
# then sum the paths ourselves
path2chi(path1, paramgroup=pars)
path2chi(path2, paramgroup=pars)
mysum.chi_alt = path1.chi + path2.chi
label='E0=%.1f, S02=%.1f' % (pars.del_e0.value, pars.amp.value)
plot(mysum.k, mysum.chi_alt*mysum.k**2, label=label)
## end examples/feffit/doc_feffdat4.lar
After reading in the Feff data files, we have created a group pars
of
Parameters with _math.param()
, specifically pars.del_e0
and
pars.amp
. Then we set the e0
path parameter for each path to the
string 'del_e0'
, and the amp
path parameter to 'amp'
. We set
the sigma2
values to simple numbers, as above.
Now, when running ff2chi()
, we give not only a group
to put the
results in, but also a paramgroup
to use as the parameters for
evaluating any mathematical expressions we’ve defined for the path
parameters. At this point, the strings del_e0
and amp
for the
path parameters for path 1 and 2 are converted into Parameters and
evaluated.
- ..versionchanged:: 0.9.34
removed _sys.paramGroup, now using fiteval
After plotting the results, we then change the values of the parameters.
We could re-run ff2chi()
, but we can also just run path2chi()
on the paths for which we want to recalculate \(\chi\). Note that we
specify the paramgroup
to path2chi()
here.
The resulting plot shows the effect of changing \(E_0\) and \(S_0^2\) for a sum of paths. The same result could be shown by just setting the path parameters to the appropriate numerical values, but the use of parameters makes this somewhat more general. As we will see in the next section, the use of parameters also allows us to easily refine their values in a fit of XAFS data to such a sum of paths.
Footnotes