def _xafsft(self, chi, group=None, rmax_out=10, **kws): "returns " for key, val in kws: if key == 'kw': key = 'kweight' setattr(self, key, val) self.make_karrays() out = self.fftf(chi) irmax = min(self.nfft / 2, int(1.01 + rmax_out / self.rstep)) group = set_xafsGroup(group, _larch=self._larch) r = self.rstep * arange(irmax) mag = sqrt(out.real**2 + out.imag**2) group.kwin = self.kwin[:len(chi)] group.r = r[:irmax] group.chir = out[:irmax] group.chir_mag = mag[:irmax] group.chir_pha = complex_phase(out[:irmax]) group.chir_re = out.real[:irmax] group.chir_im = out.imag[:irmax]
def _xafsft(self, chi, group=None, rmax_out=10, **kws): "returns " for key, val in kws: if key == 'kw': key = 'kweight' setattr(self, key, val) self.make_karrays() out = self.fftf(chi) irmax = min(self.nfft/2, int(1.01 + rmax_out/self.rstep)) group = set_xafsGroup(group, _larch=self._larch) r = self.rstep * arange(irmax) mag = sqrt(out.real**2 + out.imag**2) group.kwin = self.kwin[:len(chi)] group.r = r[:irmax] group.chir = out[:irmax] group.chir_mag = mag[:irmax] group.chir_pha = complex_phase(out[:irmax]) group.chir_re = out.real[:irmax] group.chir_im = out.imag[:irmax]
def xftf(k, chi=None, group=None, kmin=0, kmax=20, kweight=0, dk=1, dk2=None, with_phase=False, window='kaiser', rmax_out=10, nfft=2048, kstep=0.05, _larch=None, **kws): """ forward XAFS Fourier transform, from chi(k) to chi(R), using common XAFS conventions. Parameters: ----------- k: 1-d array of photo-electron wavenumber in Ang^-1 or group chi: 1-d array of chi group: output Group rmax_out: highest R for output data (10 Ang) kweight: exponent for weighting spectra by k**kweight kmin: starting k for FT Window kmax: ending k for FT Window dk: tapering parameter for FT Window dk2: 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 Ang^-1). 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: kwin window function Omega(k) (length of input chi(k)). r uniform array of R, out to rmax_out. chir complex array of chi(R). chir_mag magnitude of chi(R). chir_re real part of chi(R). chir_im imaginary part of chi(R). chir_pha phase of chi(R) if with_phase=True (a noticable performance hit) Supports First Argument Group convention (with group member names 'k' and 'chi') """ # allow kweight keyword == kw if 'kw' in kws: kweight = kws['kw'] k, chi, group = parse_group_args(k, members=('k', 'chi'), defaults=(chi,), group=group, fcn_name='xftf') cchi, win = xftf_prep(k, chi, kmin=kmin, kmax=kmax, kweight=kweight, dk=dk, dk2=dk2, nfft=nfft, kstep=kstep, window=window, _larch=_larch) out = xftf_fast(cchi*win, kstep=kstep, nfft=nfft) rstep = pi/(kstep*nfft) irmax = min(nfft/2, int(1.01 + rmax_out/rstep)) group = set_xafsGroup(group, _larch=_larch) r = rstep * arange(irmax) mag = sqrt(out.real**2 + out.imag**2) group.kwin = win[:len(chi)] group.r = r[:irmax] group.chir = out[:irmax] group.chir_mag = mag[:irmax] group.chir_re = out.real[:irmax] group.chir_im = out.imag[:irmax] if with_phase: group.chir_pha = complex_phase(out[:irmax])
def xftr(r, chir=None, group=None, rmin=0, rmax=20, with_phase=False, dr=1, dr2=None, rw=0, window='kaiser', qmax_out=None, nfft=2048, kstep=0.05, _larch=None, **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') """ if 'rweight' in kws: rw = kws['rweight'] r, chir, group = parse_group_args(r, members=('r', 'chir'), defaults=(chir,), group=group, fcn_name='xftr') rstep = r[1] - r[0] kstep = pi/(rstep*nfft) scale = 1.0 cchir = zeros(nfft, dtype='complex128') r_ = rstep * arange(nfft, dtype='float64') cchir[0:len(chir)] = chir if chir.dtype == np.dtype('complex128'): scale = 0.5 win = ftwindow(r_, xmin=rmin, xmax=rmax, dx=dr, dx2=dr2, window=window) out = scale * xftr_fast( cchir*win * r_**rw, kstep=kstep, nfft=nfft) if qmax_out is None: qmax_out = 30.0 q = linspace(0, qmax_out, int(1.05 + qmax_out/kstep)) nkpts = len(q) group = set_xafsGroup(group, _larch=_larch) group.q = q mag = sqrt(out.real**2 + out.imag**2) group.rwin = win[:len(chir)] group.chiq = out[:nkpts] group.chiq_mag = mag[:nkpts] group.chiq_re = out.real[:nkpts] group.chiq_im = out.imag[:nkpts] if with_phase: group.chiq_pha = complex_phase(out[:nkpts])
def xftf(k, chi=None, group=None, kmin=0, kmax=20, kweight=0, dk=1, dk2=None, with_phase=False, window='kaiser', rmax_out=10, nfft=2048, kstep=0.05, _larch=None, **kws): """ forward XAFS Fourier transform, from chi(k) to chi(R), using common XAFS conventions. Parameters: ----------- k: 1-d array of photo-electron wavenumber in Ang^-1 or group chi: 1-d array of chi group: output Group rmax_out: highest R for output data (10 Ang) kweight: exponent for weighting spectra by k**kweight kmin: starting k for FT Window kmax: ending k for FT Window dk: tapering parameter for FT Window dk2: 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 Ang^-1). 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: kwin window function Omega(k) (length of input chi(k)). r uniform array of R, out to rmax_out. chir complex array of chi(R). chir_mag magnitude of chi(R). chir_re real part of chi(R). chir_im imaginary part of chi(R). chir_pha phase of chi(R) if with_phase=True (a noticable performance hit) Supports First Argument Group convention (with group member names 'k' and 'chi') """ # allow kweight keyword == kw if 'kw' in kws: kweight = kws['kw'] k, chi, group = parse_group_args(k, members=('k', 'chi'), defaults=(chi, ), group=group, fcn_name='xftf') cchi, win = xftf_prep(k, chi, kmin=kmin, kmax=kmax, kweight=kweight, dk=dk, dk2=dk2, nfft=nfft, kstep=kstep, window=window, _larch=_larch) out = xftf_fast(cchi * win, kstep=kstep, nfft=nfft) rstep = pi / (kstep * nfft) irmax = min(nfft / 2, int(1.01 + rmax_out / rstep)) group = set_xafsGroup(group, _larch=_larch) r = rstep * arange(irmax) mag = sqrt(out.real**2 + out.imag**2) group.kwin = win[:len(chi)] group.r = r[:irmax] group.chir = out[:irmax] group.chir_mag = mag[:irmax] group.chir_re = out.real[:irmax] group.chir_im = out.imag[:irmax] if with_phase: group.chir_pha = complex_phase(out[:irmax])
def xftr(r, chir=None, group=None, rmin=0, rmax=20, with_phase=False, dr=1, dr2=None, rw=0, window='kaiser', qmax_out=None, nfft=2048, kstep=0.05, _larch=None, **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') """ if 'rweight' in kws: rw = kws['rweight'] r, chir, group = parse_group_args(r, members=('r', 'chir'), defaults=(chir, ), group=group, fcn_name='xftr') rstep = r[1] - r[0] kstep = pi / (rstep * nfft) scale = 1.0 cchir = zeros(nfft, dtype='complex128') r_ = rstep * arange(nfft, dtype='float64') cchir[0:len(chir)] = chir if chir.dtype == np.dtype('complex128'): scale = 0.5 win = ftwindow(r_, xmin=rmin, xmax=rmax, dx=dr, dx2=dr2, window=window) out = scale * xftr_fast(cchir * win * r_**rw, kstep=kstep, nfft=nfft) if qmax_out is None: qmax_out = 30.0 q = linspace(0, qmax_out, int(1.05 + qmax_out / kstep)) nkpts = len(q) group = set_xafsGroup(group, _larch=_larch) group.q = q mag = sqrt(out.real**2 + out.imag**2) group.rwin = win[:len(chir)] group.chiq = out[:nkpts] group.chiq_mag = mag[:nkpts] group.chiq_re = out.real[:nkpts] group.chiq_im = out.imag[:nkpts] if with_phase: group.chiq_pha = complex_phase(out[:nkpts])