def FFT(x, y, fs, nufft=False): if nufft: return nufft.nufft3(x, y, fs * 2 * np.pi) pgram = np.fft.fft(y) plt.clf() plt.plot(np.real(pgram[100:-100])**2 + np.imag(pgram[:-100])**2) plt.savefig("test") assert 0 return pgram
def make_pgram(kid, x, y, yerr, ivar, nm, dn, fft=False): # compute spg or fft fs = np.arange(nm-(10*dn), nm+(10*dn), 1e-2) * 1e-6 if fft: comp_pgram = nufft.nufft3(x, y, fs*2*np.pi) pgram = np.imag(comp_pgram)**2 + np.real(comp_pgram)**2 else: starts, stops, centres = real_footprint_sc(x) pgram = spg.superpgram(starts, stops, y, ivar, fs*2*np.pi) # save spg np.savetxt("pgram_%s.txt" % str(int(kid)), np.transpose((fs, pgram))) plt.clf() plt.plot(fs, pgram) plt.savefig("pgram_%s" % str(int(kid))) return fs, pgram
def dofft(time,flux, over): """Take a fourier transform using nufft """ dt=(time[3]-time[1])/2.0; n=len(time) endf=1/(dt*2.0); #Nyquist Frequency step=endf/(n*over); freq=np.arange(0,endf,step) freq.size fft=nu.nufft3(time,flux,freq) amp=2*np.sqrt(fft.real**2 + fft.imag**2) return(freq,amp)
plt.subplot(3, 1, 1) print ("calculating superpgram for long cadence data") x, y, yerr, ivar = load_data(kid, kepler_lc_dir, sc=False) starts, stops, centres = real_footprint(x) amp2s = spg.superpgram(starts, stops, y, ivar, ws) plt.plot((fs-fs0)*1e6, amp2s, "k", alpha=.7) if len(truths): for truth in truths: plt.axvline(truth*1e-6, color="r", linestyle="-.") plt.ylabel("$\mathrm{SuperPgram}$") plt.xlabel("$\mathrm{Frequency-%s~(uHz)}$" % (fs0*1e6)) # fft long cadence data plt.subplot(3, 1, 2) print ("calculating fft for long cadence data") pgram = nufft.nufft3(stops, y, ws) plt.plot((fs-fs0)*1e6, pgram, "k", alpha=.7) if len(truths): for truth in truths: plt.axvline(truth*1e-6, color="r", linestyle="-.") plt.ylabel("$\mathrm{FFT}$") plt.xlabel("$\mathrm{Frequency-%s~(uHz)}$" % (fs0*1e6)) # LombScargle long cadence data plt.subplot(3, 1, 3) print ("calculating LombScargle for long cadence data") periods = 1./fs model = LombScargle().fit(x, y, yerr) power = model.periodogram(periods) plt.plot((fs-fs0)*1e6, power, "k", alpha=.7) if len(truths):
def forward(x, u_initial, psi, f, T, R): """Solves advection-diffusion equation forward in time using the FFT. The equation is $$ u_t - u_{xx} - \psi u_x - f(x) = 0 \:, $$ with initial condition $u(x,0) = u_initial$. We assume that the support of f(x) is a subset of [-R/2, R/2]. Args: x: grid in physical space u_initial: initial field value psi: advection coefficient f: time independent source T: final time R: The support of the source is a subset of $[-R / 2, R / 2]$ Returns: u_final: final field value """ # add $R / 2$ to the grid, and evaluate Riemann sums on the right endpoint x = np.append(x, R / 2.0) u_initial = np.append(u_initial, 0.0) f = np.append(f, 0.0) N = len(x) dx = np.zeros(N) dx[0] = x[0] - (- R / 2.0) dx[1 : N] = x[1 : N] - x[0 : N - 1] # nufft frecuencies xi = (np.arange(-N // 2, N // 2) + N % 2) zero_freq_index = N // 2 # Fourier transform, NOTICE that nufft3 calculates the normalized # sum: line 71 in https://github.com/dfm/python-nufft/blob/master/nufft/nufft.py u_hat_initial = N * nufft3(x, u_initial * dx, xi) f_hat = N * nufft3(x, f * dx, xi) # solve ODE's analitically in Fourier space a = (-1j * psi - xi) * xi u_hat_final = np.zeros(N) u_hat_final = np.array(u_hat_final, dtype=complex) for n in range (0, zero_freq_index): u_hat_final[n] = ( u_hat_initial[n] * np.exp(a[n] * T) - (f_hat[n] / a[n]) * (1.0 - np.exp(a[n] * T))) for n in range (zero_freq_index + 1, N): u_hat_final[n] = ( u_hat_initial[n] * np.exp(a[n] * T) - (f_hat[n] / a[n]) * (1.0 - np.exp(a[n] * T))) u_hat_final[zero_freq_index] = ( u_hat_initial[zero_freq_index] + (T + 0j) * f_hat[zero_freq_index]) # inverse Fourier transform, NOTICE that nufft3 calculates the normalized # sum: line 71 in https://github.com/dfm/python-nufft/blob/master/nufft/nufft.py u_final = ( (1.0 / (2 * np.pi)) * N * nufft3(xi, u_hat_final, x, iflag=-1)) return np.real(u_final[0 : N - 1])
def forwardGradient(x, u_initial, psi, f, T, R): """Solves for u_{x} in the advection-diffusion equation, forward in time using the FFT. The equation is $$ u_t - u_{xx} - \psi u_x - f(x) = 0 \:, $$ with initial condition $u(x,0) = u_initial$. We assume that the support of f(x) is a subset of [-R/2, R/2]. Args: x: grid in physical space. u_initial: initial field value psi: advection coefficient f: time independent source T: final time R: The support of the source is a subset of $[-R,R]$ Returns: u_final: final field value """ # add $R / 2$ to the grid, and evaluate Riemann sums on the right endpoint x = np.append(x, R / 2.0) u_initial = np.append(u_initial, 0.0) f = np.append(f, 0.0) N = len(x) dx = np.zeros(N) dx[0] = x[0] - (- R / 2.0) dx[1 : N] = x[1 : N] - x[0 : N - 1] # nufft frecuencies xi = (np.arange(-N // 2, N // 2) + N % 2) zero_freq_index = N // 2 # Fourier transform u_hat_initial = N * nufft3(x, u_initial * dx, xi) f_hat = N * nufft3(x, f * dx, xi) # Solve ODE's analitically in Fourier space a = (-1j * psi - xi) * xi u_hat_final_x = np.zeros(N) u_hat_final_x = np.array(u_hat_final_x, dtype=complex) # $u_x$ in Fourier space is equivalent to multiplication by $-i * \xi$ u_hat_initial_x = u_hat_initial * (-1j * xi) f_hat_x = f_hat * (-1j * xi) for n in range (0, zero_freq_index): u_hat_final_x[n] = ( u_hat_initial_x[n] * np.exp(a[n] * T) - (f_hat_x[n] / a[n]) * (1.0 - np.exp(a[n] * T))) for n in range (zero_freq_index + 1, N): u_hat_final_x[n] = ( u_hat_initial_x[n] * np.exp(a[n] * T) - (f_hat_x[n]/a[n]) * (1.0 - np.exp(a[n] * T))) u_hat_final_x[zero_freq_index] = ( u_hat_initial_x[zero_freq_index] + (T + 0j) * f_hat_x[zero_freq_index]) # inverse Fourier transform u_final_x = ( (1.0 / (2.0 * np.pi)) * N * nufft3(xi, u_hat_final_x, x, iflag=-1)) return np.real(u_final_x[0 : N - 1])