def test_nfft_direct(self):
a = numpy.random.random(self._size)
coordinates = -0.5 + numpy.random.random(100)
ft_nfft = nfft.nfft(a, 1., coordinates, use_direct=False)
ft_nfft_direct = nfft.nfft(a, 1., coordinates, use_direct=True)
numpy.testing.assert_almost_equal(ft_nfft,
ft_nfft_direct,
decimal=self._decimals)
def test_nfft_1d(self):
a = numpy.random.random(self._size)
ft_nfft = nfft.nfft(a, 1., self._coord_1d)
ft_fftw = numpy.fft.fftshift(numpy.fft.fft(numpy.fft.fftshift(a)))
numpy.testing.assert_almost_equal(ft_nfft,
ft_fftw,
decimal=self._decimals)
def serie_single_processor(serie):
id_datalist = list(
filter((lambda dat: dat['designator'] == 'Id'), serie['data']))
t_datalist = list(
filter((lambda dat: dat['designator'] == 'T(s)'), serie['data']))
id_arr = np.array(id_datalist[0]['data'][0])
t_arr = np.array(t_datalist[0]['data'][0])
if (len(id_arr) % 2) != 0:
sys.stdout.writelines(strip_non_ascii(serie['title']) + '\n\n')
sys.stdout.flush()
fs = 1 / np.average(np.diff(t_arr))
N = len(t_arr)
if N % 2 == 0:
dft_two_sided = np.real(nfft.nfft(np.arange(-0.5, 0.5, 1 / N), id_arr))
else:
dft_two_sided = np.real(nfft.ndft(t_arr, id_arr))
dft_one_sided = 2 * dft_two_sided[1:math.ceil(N / 2)]
psd = (1 / (2 * math.pi * N)) * np.square(dft_one_sided)
f = np.arange(0, math.pi * fs, (2 * math.pi * fs) / N)[1:]
logpsd = 10 * np.log10(psd)
plt.semilogx(f, logpsd)
plt.title("Power Spectral Density of: " + serie['title'])
plt.autoscale('both', tight=True)
plt.ylabel('PSD(A^2/Hz)')
plt.xlabel('f(Hz)')
outputdir = PureWindowsPath(sys.argv[2])
filename = Path(outputdir /
PureWindowsPath("psd\\" + serie['title'] + ".png"))
plt.savefig(filename, dpi=600)
plt.close()
def calculate_diffraction(scattering_factor_density, density_pixel_size, rotation,
image_shape, wavelength, detector_distance, pixel_size):
base_coordinates = ewald_coordinates(image_shape, wavelength, detector_distance, pixel_size)
rotated_coordinates = _rotations.rotate_array(rotation, base_coordinates)
largest_distance_in_fourier_space = 1./(2.*density_pixel_size)
scaled_coordinates = rotated_coordinates * 0.5 / largest_distance_in_fourier_space
diffraction = _nfft.nfft(scattering_factor_density, scaled_coordinates)
return diffraction.reshape(image_shape)
def apply_nfft(t, x):
ids = np.logical_not(np.isnan(x))
if np.sum(ids)%2 != 0:
ids[np.where(ids)[-1]] = False
try:
f = nfft(t[ids], x[ids])
except:
f = np.fft.rfft(x[ids], norm='ortho')
return(t[ids], x[ids], f)
def calculate_diffraction(scattering_factor_density, density_pixel_size,
rotation, image_shape, wavelength, detector_distance,
pixel_size):
import nfft as _nfft
base_coordinates = ewald_coordinates(image_shape, wavelength,
detector_distance, pixel_size)
rotated_coordinates = _rotmodule.rotate_array(rotation, base_coordinates)
diffraction = _nfft.nfft(scattering_factor_density, density_pixel_size,
rotated_coordinates)
return diffraction.reshape(image_shape)
def math_ops(time_array_epoch, temp_array, humi_array):
ret_dict = {}
# Derivative (C/minute)
ret_dict['derivative_temp'] = 3600 * np.gradient(
temp_array, time_array_epoch) #degs/hour
# Fourier (Only on the last p=2^k samples)
k = int(np.log(len(time_array_epoch)) / np.log(2))
t_window = time_array_epoch[-2**k:] - time_array_epoch[-2**k]
t_hat = nfft.nfft(temp_array[-2**k:], t_window)
#freqHz = (0:1:length(X_mag)-1)*Fs/N; Fs=sampling rate, N = sample size
# freq = np.arange(2**k)*(time_array_epoch[-1] - time_array_epoch[-2**k])/(60*60*24)
ret_dict['fourier'] = t_hat.real
return ret_dict
def compute_nfft(sample_instants, sample_values):
'''
Following the procedure from the linked stackoverflow, compute a
nonuniform fft.
'''
N = len(sample_instants)
T = sample_instants[-1] - sample_instants[0]
x = numpy.linspace(0.0, 1.0 / (2.0 * T), N // 2)
y = nfft.nfft(sample_instants, sample_values)
y = 2.0 / N * numpy.abs(y[0:N // 2])
#plt.plot(x, y)
#plt.show()
return (x, y)
def test_nfft_2d(self):
a = numpy.random.random((self._size, ) * 2)
ft_nfft = nfft.nfft(a, 1., [[
self._coord_1d[self._2d_coord[0][0]],
self._coord_1d[self._2d_coord[0][1]]
],
[
self._coord_1d[self._2d_coord[1][0]],
self._coord_1d[self._2d_coord[1][1]]
]])
ft_fftw = numpy.fft.fftshift(numpy.fft.fft2(numpy.fft.fftshift(a)))
numpy.testing.assert_almost_equal(
ft_nfft, ft_fftw[(self._2d_coord[0][0], self._2d_coord[1][0]),
(self._2d_coord[0][1], self._2d_coord[1][1])])
def get_slice_and_rot(self, rot=None, output_type="complex"):
"""Calculate the slice of the specified rot or if no rot is given
use a random rotation. Both the slice and the rotation in returned.
The output type can be either "complex" or "intensity". "Complex"
returns the wave field and "intensity" returns the absolute square
of the wave field."""
if rot is None:
rot = rotations.random_quaternion()
coordinates = self._rotated_coordinates(rot)
pattern_flat = _nfft.nfft(self._real_volume, coordinates)
pattern = pattern_flat.reshape((self._image_side, )*2)
if output_type == "complex":
return pattern, rot
elif output_type == "intensity":
return abs(pattern**2), rot
def get_slice_and_rot(self, rot=None, output_type="complex"):
"""Calculate the slice of the specified rot or if no rot is given
use a random rotation. Both the slice and the rotation in returned.
The output type can be either "complex" or "intensity". "Complex"
returns the wave field and "intensity" returns the absolute square
of the wave field."""
if rot is None:
rot = rotmodule.random_quaternion()
coordinates = self._rotated_coordinates(rot)
pattern_flat = _nfft.nfft(self._real_volume,
self._real_pixel_size,
coordinates)
pattern = pattern_flat.reshape(self._image_shape)
if output_type == "complex":
return pattern, rot
elif output_type == "intensity":
return abs(pattern**2), rot
def test_nfft_2d(self):
a = numpy.random.random((self._size, )*2)
ft_nfft = nfft.nfft(a, [[self._coord_1d[self._2d_coord[0][0]], self._coord_1d[self._2d_coord[0][1]]],
[self._coord_1d[self._2d_coord[1][0]], self._coord_1d[self._2d_coord[1][1]]]])
ft_fftw = numpy.fft.fftshift(numpy.fft.fft2(numpy.fft.fftshift(a)))
numpy.testing.assert_almost_equal(ft_nfft, ft_fftw[(self._2d_coord[0][0], self._2d_coord[1][0]), (self._2d_coord[0][1], self._2d_coord[1][1])])
def test_nfft_1d(self):
a = numpy.random.random(self._size)
ft_nfft = nfft.nfft(a, self._coord_1d)
ft_fftw = numpy.fft.fftshift(numpy.fft.fft(numpy.fft.fftshift(a)))
numpy.testing.assert_almost_equal(ft_nfft, ft_fftw, decimal=self._decimals)
def test_nfft_direct(self):
a = numpy.random.random(self._size)
coordinates = -0.5+numpy.random.random(100)
ft_nfft = nfft.nfft(a, coordinates, use_direct=False)
ft_nfft_direct = nfft.nfft(a, coordinates, use_direct=True)
numpy.testing.assert_almost_equal(ft_nfft, ft_nfft_direct, decimal=self._decimals)
