def FT_R(self, rmin=0, rmax=20, with_phase=False, dr=1, dr2=None, rw=0, window='kaiser', qmax_out=None, nfft=2048, kstep=0.05, **kws): """reverse XAFS Fourier transform, from chi(R) to chi(q). calculate reverse XAFS Fourier transform This assumes that chir_re and (optional chir_im are on a uniform r-grid given by r. Parameters: ------------ r: 1-d array of distance, or group. chir: 1-d array of chi(R) group: output Group qmax_out: highest *k* for output data (30 Ang^-1) rweight: exponent for weighting spectra by r^rweight (0) rmin: starting *R* for FT Window rmax: ending *R* for FT Window dr: tapering parameter for FT Window dr2: second tapering parameter for FT Window window: name of window type nfft: value to use for N_fft (2048). kstep: value to use for delta_k (0.05). with_phase: output the phase as well as magnitude, real, imag [False] Returns: --------- None -- outputs are written to supplied group. Notes: ------- Arrays written to output group: rwin window Omega(R) (length of input chi(R)). q uniform array of k, out to qmax_out. chiq complex array of chi(k). chiq_mag magnitude of chi(k). chiq_re real part of chi(k). chiq_im imaginary part of chi(k). chiq_pha phase of chi(k) if with_phase=True (a noticable performance hit) Supports First Argument Group convention (with group member names 'r' and 'chir')""" args = dict(locals()) args.update(kws) del args["self"], args["kws"] xafs.xftr(self, _larch=self._larch, **args) return
def calc_rFT(r, chir, r_min, r_max, q_max, wind, dr_wind): chiq = larch_builtins._group(mylarch) xftr(r, chir, group=chiq, qmax_out=q_max, rmin=r_min, rmax=r_max, window=wind, dr=dr_wind, _larch=mylarch) return chiq.q, chiq.chiq_re
def FT_R(self, rmin=0, rmax=20, with_phase=False, dr=1, dr2=None, rw=0, window='kaiser', qmax_out=None, nfft=2048, kstep=0.05, **kws): """reverse XAFS Fourier transform, from chi(R) to chi(q). calculate reverse XAFS Fourier transform This assumes that chir_re and (optional chir_im are on a uniform r-grid given by r. Parameters: ------------ r: 1-d array of distance, or group. chir: 1-d array of chi(R) group: output Group qmax_out: highest *k* for output data (30 Ang^-1) rweight: exponent for weighting spectra by r^rweight (0) rmin: starting *R* for FT Window rmax: ending *R* for FT Window dr: tapering parameter for FT Window dr2: second tapering parameter for FT Window window: name of window type nfft: value to use for N_fft (2048). kstep: value to use for delta_k (0.05). with_phase: output the phase as well as magnitude, real, imag [False] Returns: --------- None -- outputs are written to supplied group. Notes: ------- Arrays written to output group: rwin window Omega(R) (length of input chi(R)). q uniform array of k, out to qmax_out. chiq complex array of chi(k). chiq_mag magnitude of chi(k). chiq_re real part of chi(k). chiq_im imaginary part of chi(k). chiq_pha phase of chi(k) if with_phase=True (a noticable performance hit) Supports First Argument Group convention (with group member names 'r' and 'chir')""" args=dict(locals()); args.update(kws) del args["self"],args["kws"] xafs.xftr(self, _larch=self._larch, **args) return
10067.28 120488.7 89110.0998902 0.30168329 10073.72 118833.7 88265.1000656 0.29738025 10080.18 118434.7 88372.1004302 0.29280544 10086.66 117995.7 88449.0998063 0.28822094 10093.17 118435.7 89180.0997098 0.28371228 10099.69 117303.7 88720.0998253 0.27927983 10106.22 117929.7 89581.1003571 0.27494432 10112.78 116857.7 89144.1003332 0.27070279 10119.36 115791.7 88718.1000129 0.26632896 10125.96 111467.7 85797.099695 0.26174966 10132.57 110079.7 85128.099834 0.25704747 10139.21 104190.7 80953.0999403 0.2523529 10145.86 93726.7 73074.0996945 0.24890911''' raw_data_lines = raw_data.split('\n') raw_data_table = [] for line in raw_data_lines: raw_data_table.append(list(map(lambda x: float(x), line.strip().split()))) table = np.array(raw_data_table) group.energy = table[:, 0] group.mu = table[:, 3] e0 = find_e0(group, _larch=mylarch) pre_edge(group, _larch=mylarch) autobk(group, _larch=mylarch) xftf(group, _larch=mylarch) xftr(group, _larch=mylarch)
def estimate_noise(k, chi=None, group=None, rmin=15.0, rmax=30.0, kweight=1, kmin=0, kmax=20, dk=4, dk2=None, kstep=0.05, kwindow='kaiser', nfft=2048, _larch=None, **kws): """ estimate noise levels in EXAFS spectrum and estimate highest k where data is above the noise level Parameters: ----------- k: 1-d array of photo-electron wavenumber in Ang^-1 (or group) chi: 1-d array of chi group: output Group [see Note below] rmin: minimum R value for high-R region of chi(R) rmax: maximum R value for high-R region of chi(R) kweight: exponent for weighting spectra by k**kweight [1] kmin: starting k for FT Window [0] kmax: ending k for FT Window [20] dk: tapering parameter for FT Window [4] dk2: second tapering parameter for FT Window [None] kstep: value to use for delta_k ( Ang^-1) [0.05] window: name of window type ['kaiser'] nfft: value to use for N_fft [2048]. Returns: --------- None -- outputs are written to supplied group. Values (scalars) written to output group: epsilon_k estimated noise in chi(k) epsilon_r estimated noise in chi(R) kmax_suggest highest estimated k value where |chi(k)| > epsilon_k Notes: ------- 1. This method uses the high-R portion of chi(R) as a measure of the noise level in the chi(R) data and uses Parseval's theorem to convert this noise level to that in chi(k). This method implicitly assumes that there is no signal in the high-R portion of the spectrum, and that the noise in the spectrum s "white" (independent of R) . Each of these assumptions can be questioned. 2. The estimate for 'kmax_suggest' has a tendency to be fair but pessimistic in how far out the chi(k) data goes before being dominated by noise. 3. Follows the 'First Argument Group' convention, so that you can either specifiy all of (an array for 'k', an array for 'chi', option output Group) OR pass a group with 'k' and 'chi' as the first argument """ k, chi, group = parse_group_args(k, members=('k', 'chi'), defaults=(chi, ), group=group, fcn_name='esitmate_noise') # save _sys.xafsGroup -- we want to NOT write to it here! savgroup = set_xafsGroup(None, _larch=_larch) tmpgroup = Group() rmax_out = min(10 * pi, rmax + 2) xftf(k, chi, kmin=kmin, kmax=kmax, rmax_out=rmax_out, kweight=kweight, dk=dk, dk2=dk2, kwindow=kwindow, nfft=nfft, kstep=kstep, group=tmpgroup, _larch=_larch) chir = tmpgroup.chir rstep = tmpgroup.r[1] - tmpgroup.r[0] irmin = int(0.01 + rmin / rstep) irmax = min(nfft / 2, int(1.01 + rmax / rstep)) highr = realimag(chir[irmin:irmax]) # get average of window function value, scale eps_r scale by this # this is imperfect, but improves the result. kwin_ave = tmpgroup.kwin.sum() * kstep / (kmax - kmin) eps_r = sqrt((highr * highr).sum() / len(highr)) / kwin_ave # use Parseval's theorem to convert epsilon_r to epsilon_k, # compensating for kweight w = 2 * kweight + 1 scale = sqrt((2 * pi * w) / (kstep * (kmax**w - kmin**w))) eps_k = scale * eps_r # do reverse FT to get chiq array xftr(tmpgroup.r, tmpgroup.chir, group=tmpgroup, rmin=0.5, rmax=9.5, dr=1.0, window='parzen', nfft=nfft, kstep=kstep, _larch=_larch) # sets kmax_suggest to the largest k value for which # | chi(q) / k**kweight| > epsilon_k iq0 = index_of(tmpgroup.q, (kmax + kmin) / 2.0) tst = tmpgroup.chiq_mag[iq0:] / (tmpgroup.q[iq0:])**kweight kmax_suggest = tmpgroup.q[iq0 + where(tst < eps_k)[0][0]] # restore original _sys.xafsGroup, set output variables _larch.symtable._sys.xafsGroup = savgroup group = set_xafsGroup(group, _larch=_larch) group.epsilon_k = eps_k group.epsilon_r = eps_r group.kmax_suggest = kmax_suggest
def estimate_noise(k, chi=None, group=None, rmin=15.0, rmax=30.0, kweight=1, kmin=0, kmax=20, dk=4, dk2=None, kstep=0.05, kwindow='kaiser', nfft=2048, _larch=None, **kws): """ estimate noise levels in EXAFS spectrum and estimate highest k where data is above the noise level Parameters: ----------- k: 1-d array of photo-electron wavenumber in Ang^-1 (or group) chi: 1-d array of chi group: output Group [see Note below] rmin: minimum R value for high-R region of chi(R) rmax: maximum R value for high-R region of chi(R) kweight: exponent for weighting spectra by k**kweight [1] kmin: starting k for FT Window [0] kmax: ending k for FT Window [20] dk: tapering parameter for FT Window [4] dk2: second tapering parameter for FT Window [None] kstep: value to use for delta_k ( Ang^-1) [0.05] window: name of window type ['kaiser'] nfft: value to use for N_fft [2048]. Returns: --------- None -- outputs are written to supplied group. Values (scalars) written to output group: epsilon_k estimated noise in chi(k) epsilon_r estimated noise in chi(R) kmax_suggest highest estimated k value where |chi(k)| > epsilon_k Notes: ------- 1. This method uses the high-R portion of chi(R) as a measure of the noise level in the chi(R) data and uses Parseval's theorem to convert this noise level to that in chi(k). This method implicitly assumes that there is no signal in the high-R portion of the spectrum, and that the noise in the spectrum s "white" (independent of R) . Each of these assumptions can be questioned. 2. The estimate for 'kmax_suggest' has a tendency to be fair but pessimistic in how far out the chi(k) data goes before being dominated by noise. 3. Follows the 'First Argument Group' convention, so that you can either specifiy all of (an array for 'k', an array for 'chi', option output Group) OR pass a group with 'k' and 'chi' as the first argument """ k, chi, group = parse_group_args(k, members=('k', 'chi'), defaults=(chi,), group=group, fcn_name='esitmate_noise') # save _sys.xafsGroup -- we want to NOT write to it here! savgroup = set_xafsGroup(None, _larch=_larch) tmpgroup = Group() rmax_out = min(10*pi, rmax+2) xftf(k, chi, kmin=kmin, kmax=kmax, rmax_out=rmax_out, kweight=kweight, dk=dk, dk2=dk2, kwindow=kwindow, nfft=nfft, kstep=kstep, group=tmpgroup, _larch=_larch) chir = tmpgroup.chir rstep = tmpgroup.r[1] - tmpgroup.r[0] irmin = int(0.01 + rmin/rstep) irmax = min(nfft/2, int(1.01 + rmax/rstep)) highr = realimag(chir[irmin:irmax]) # get average of window function value, scale eps_r scale by this # this is imperfect, but improves the result. kwin_ave = tmpgroup.kwin.sum()*kstep/(kmax-kmin) eps_r = sqrt((highr*highr).sum() / len(highr)) / kwin_ave # use Parseval's theorem to convert epsilon_r to epsilon_k, # compensating for kweight w = 2 * kweight + 1 scale = sqrt((2*pi*w)/(kstep*(kmax**w - kmin**w))) eps_k = scale*eps_r # do reverse FT to get chiq array xftr(tmpgroup.r, tmpgroup.chir, group=tmpgroup, rmin=0.5, rmax=9.5, dr=1.0, window='parzen', nfft=nfft, kstep=kstep, _larch=_larch) # sets kmax_suggest to the largest k value for which # | chi(q) / k**kweight| > epsilon_k iq0 = index_of(tmpgroup.q, (kmax+kmin)/2.0) tst = tmpgroup.chiq_mag[iq0:] / ( tmpgroup.q[iq0:])**kweight kmax_suggest = tmpgroup.q[iq0 + where(tst < eps_k)[0][0]] # restore original _sys.xafsGroup, set output variables _larch.symtable._sys.xafsGroup = savgroup group = set_xafsGroup(group, _larch=_larch) group.epsilon_k = eps_k group.epsilon_r = eps_r group.kmax_suggest = kmax_suggest