def acquisition(x,
settings,
plot_graphs=False,
plot_3d_graphs=False,
performance_counter=PerformanceCounter()):
# Calculate number of samples per spreading code (corresponding to 1ms of data)
samples_per_code = int(
round(settings['sampling_frequency'] * settings['code_length'] /
settings['code_frequency']))
print 'samples_per_code = %s' % repr(samples_per_code)
assert samples_per_code % settings['sfft_subsampling_factor'] == 0
aliased_samples_per_code = int(samples_per_code /
settings['sfft_subsampling_factor'])
# Calculate sampling period
sampling_period = 1.0 / settings['sampling_frequency']
print 'sampling_period = %s' % repr(sampling_period)
# Generate phase points of the local carrier
phases = np.arange(0,
aliased_samples_per_code) * 2 * np.pi * sampling_period
print 'phases(%s) = %s' % (repr(phases.shape), repr(phases))
# Calculate number of frequency bins depending on search frequency band and frequency step
assert settings['acquisition_search_frequency_band'] % settings['acquisition_search_frequency_step'] == 0, \
'acquisition_search_frequency_band should be divisible by acquisition_search_frequency_step'
n_frequency_bins = int(settings['acquisition_search_frequency_band'] /
settings['acquisition_search_frequency_step']) + 1
print 'n_frequency_bins = %s' % repr(n_frequency_bins)
# Generate and store C/A lookup table
ca_codes__time = ca_code.generate_table(settings)
# SFFT
# ca_codes__freq = np.conjugate(fft(ca_codes__time))
# print 'ca_codes__time(%s) = %s' % (repr(ca_codes__time.shape), repr(ca_codes__time))
# Allocate memory for the 2D search
all_results = np.empty(shape=(n_frequency_bins, aliased_samples_per_code))
# Generate all frequency bins
frequency_bins = (
settings['intermediate_frequency'] - \
(settings['acquisition_search_frequency_band'] / 2) + \
settings['acquisition_search_frequency_step'] * np.arange(n_frequency_bins)
).astype(int)
print 'frequency_bins(%s) = %s' % (repr(
frequency_bins.shape), repr(frequency_bins))
# Allocate memory for output dictionary
satellites_to_search__shape = settings['satellites_to_search'].shape
output = {
'frequency_shifts': np.zeros(satellites_to_search__shape),
'code_shifts': np.zeros(satellites_to_search__shape),
'peak_ratios': np.zeros(satellites_to_search__shape),
'found': np.zeros(satellites_to_search__shape, dtype=np.bool),
}
for idx, prn in enumerate(settings['satellites_to_search']):
print '* searching PRN = %s' % (repr(prn), )
result_summation = np.zeros(aliased_samples_per_code)
for sum_idx in xrange(settings['sfft_sum_results']):
# Get data
x_1 = x[sum_idx * samples_per_code:sum_idx * samples_per_code +
samples_per_code]
assert x_1.size == samples_per_code
x_1 = sfft_aliasing.execute(x_1,
settings['sfft_subsampling_factor'])
assert x_1.size == aliased_samples_per_code
x_2 = x[sum_idx * samples_per_code +
samples_per_code:sum_idx * samples_per_code +
2 * samples_per_code]
assert x_2.size == samples_per_code
x_2 = sfft_aliasing.execute(x_2,
settings['sfft_subsampling_factor'])
assert x_2.size == aliased_samples_per_code
#
# Scan all Doppler shifts
#
for freq_bin_i in xrange(n_frequency_bins):
# Generate local sine and cosine carriers
carrier_sin = np.sin(frequency_bins[freq_bin_i] * phases)
carrier_cos = np.cos(frequency_bins[freq_bin_i] * phases)
# Demodulation
I1 = carrier_sin * x_1
Q1 = carrier_cos * x_1
I2 = carrier_sin * x_2
Q2 = carrier_cos * x_2
# Reconstruct baseband signal
IQ1 = I1 + 1j * Q1
IQ2 = I2 + 1j * Q2
# if settings['use_sfft']:
# IQ1 = sfft_aliasing.execute(IQ1, settings['sfft_subsampling_factor'])
# IQ2 = sfft_aliasing.execute(IQ2, settings['sfft_subsampling_factor'])
# performance_counter.increase(additions=IQ1.size * settings['sfft_subsampling_factor'])
# performance_counter.increase(additions=IQ2.size * settings['sfft_subsampling_factor'])
# Convert to frequency domain
IQ1_freq = fft(IQ1)
IQ2_freq = fft(IQ2)
performance_counter.fft(IQ1.size)
performance_counter.fft(IQ2.size)
# Multiplication in the frequency domain corresponds to convolution in the time domain
aliased_ca_code__time = sfft_aliasing.execute(
ca_codes__time[prn - 1],
settings['sfft_subsampling_factor'])
assert aliased_ca_code__time.size == aliased_samples_per_code
aliased_ca_code__freq = fft(aliased_ca_code__time)
conv_code_IQ1 = IQ1_freq * aliased_ca_code__freq
conv_code_IQ2 = IQ2_freq * aliased_ca_code__freq
performance_counter.increase(multiplications=IQ1_freq.size)
performance_counter.increase(multiplications=IQ2_freq.size)
# IFFT to obtain correlation
corr_result_1 = np.abs(ifft(conv_code_IQ1))**2
corr_result_2 = np.abs(ifft(conv_code_IQ2))**2
# assert all_results[freq_bin_i, :].shape == corr_result_1.shape == corr_result_2.shape
if np.max(corr_result_1) > np.max(corr_result_2):
all_results[freq_bin_i, :] = corr_result_1
else:
all_results[freq_bin_i, :] = corr_result_2
# Get the peak location for every frequency bins
peak_values = all_results.max(axis=1)
assert all_results.max() in peak_values
# Find the Doppler shift index
frequency_shift_idx = peak_values.argmax()
print 'frequency_shift_idx = %s' % repr(frequency_shift_idx)
# Select the frequency bin that corresponds to this frequency shift index
located_frequency_bin = all_results[frequency_shift_idx]
result_summation += located_frequency_bin
plt.figure()
plt.plot(result_summation / result_summation.max())
plt.ylabel('Normalised magnitude')
plt.xlabel('Code shift (chips)')
plt.title('Summing %d results' % settings['sfft_sum_results'])
plt.show()
exit()
# Find the code shift in the correct frequency bin
code_shift = result_summation.argmax()
output['code_shifts'][idx] = code_shift
print 'code_shift = %s' % repr(code_shift)
peak_value = result_summation[code_shift]
assert result_summation.max() == peak_value
print 'peak_value = %s' % repr(peak_value)
if plot_3d_graphs:
fig = plt.figure()
doppler_shifts__khz = (
(settings['acquisition_search_frequency_step'] *
np.arange(n_frequency_bins)) -
(settings['acquisition_search_frequency_band'] / 2)) / 1000
ax = fig.gca(projection='3d')
surf = ax.plot_surface(
X=np.arange(samples_per_code).reshape((1, -1)),
Y=doppler_shifts__khz.reshape((-1, 1)),
Z=all_results,
rstride=1,
cstride=1,
cmap=matplotlib.cm.coolwarm,
linewidth=0,
antialiased=False,
)
ax.set_xlabel('Code shift')
ax.set_ylabel('Doppler shift (kHz)')
# Calculate code phase range
samples_per_code_chip = int(
round(settings['sampling_frequency'] / settings['code_frequency']))
print 'samples_per_code_chip = %s' % repr(samples_per_code_chip)
#
# Get second largest peak value outside the chip where the maximum peak is located
#
# Calculate excluded range
excluded_range_1 = code_shift - samples_per_code_chip
excluded_range_2 = code_shift + samples_per_code_chip
print 'excluded_range_1 = %s' % repr(excluded_range_1)
print 'excluded_range_2 = %s' % repr(excluded_range_2)
# Excluded range boundary correction
if excluded_range_1 < 1:
print 'excluded_range_1 < 1'
code_phase_range = np.arange(
excluded_range_2, aliased_samples_per_code + excluded_range_1)
elif excluded_range_2 >= aliased_samples_per_code:
print 'excluded_range_2 >= samples_per_code'
code_phase_range = np.arange(
excluded_range_2 - aliased_samples_per_code, excluded_range_1)
else:
code_phase_range = np.concatenate(
(np.arange(0, excluded_range_1),
np.arange(excluded_range_2, aliased_samples_per_code)))
assert code_shift not in code_phase_range
print 'code_phase_range(%s) = %s' % (repr(
code_phase_range.shape), repr(code_phase_range))
# Get second largest peak value
second_peak_value = all_results[frequency_shift_idx,
code_phase_range].max()
print 'second_peak_value = %s' % repr(second_peak_value)
# Calculate ratio between the largest peak value and the second largest peak value
peak_ratio = peak_value / second_peak_value
print 'peak_ratio = %s' % repr(peak_ratio)
output['peak_ratios'][idx] = peak_ratio
#
# Thresholding
#
if peak_ratio > settings['acquisition_threshold']:
output['found'][idx] = True
print '-> %s FOUND' % repr(prn)
else:
output['found'][idx] = False
print '-> %s NOT FOUND' % repr(prn)
if plot_graphs:
plt.figure()
colors = ['r' if found else 'b' for found in output['found']]
plt.bar(settings['satellites_to_search'],
output['peak_ratios'],
color=colors,
align='center')
plt.ylabel('Acquisition quality')
plt.xlabel('PRN number')
artist__not_acquired = plt.Rectangle((0, 0), 1, 1, fc='b')
artist__acquired = plt.Rectangle((0, 0), 1, 1, fc='r')
plt.legend((artist__not_acquired, artist__acquired),
('Not acquired', 'Acquired'))
plt.xlim(0, settings['satellites_total'] + 1)
plt.grid()
plt.tight_layout()
return output, performance_counter
def acquisition(x,
settings,
plot_graphs=False,
plot_3d_graphs=False,
performance_counter=PerformanceCounter()):
# Calculate number of samples per spreading code (corresponding to 1ms of data)
samples_per_code = int(
round(settings['sampling_frequency'] * settings['code_length'] /
settings['code_frequency']))
# print 'samples_per_code = %s' % repr(samples_per_code)
# SFFT
aliased_samples_per_code = int(samples_per_code /
settings['sfft_subsampling_factor'])
if settings['use_sfft']:
actual_samples_per_code = aliased_samples_per_code
else:
actual_samples_per_code = samples_per_code
# Calculate sampling period
sampling_period = 1.0 / settings['sampling_frequency']
# print 'sampling_period = %s' % repr(sampling_period)
# Generate phase points of the local carrier
phases = np.arange(0, samples_per_code) * 2 * np.pi * sampling_period
# print 'phases(%s) = %s' % (repr(phases.shape), repr(phases))
# Calculate number of frequency bins depending on search frequency band and frequency step
assert settings['acquisition_search_frequency_band'] % settings['acquisition_search_frequency_step'] == 0, \
'acquisition_search_frequency_band should be divisible by acquisition_search_frequency_step'
n_frequency_bins = int(settings['acquisition_search_frequency_band'] /
settings['acquisition_search_frequency_step']) + 1
# print 'n_frequency_bins = %s' % repr(n_frequency_bins)
# Generate and store C/A lookup table
ca_codes__time = ca_code.generate_table(settings)
# SFFT
if settings['use_sfft']:
aliased_ca_codes__time = np.empty(shape=(settings['satellites_total'],
aliased_samples_per_code))
for i in xrange(ca_codes__time.shape[0]):
aliased_ca_codes__time[i] = sfft_aliasing.execute(
ca_codes__time[i], settings['sfft_subsampling_factor'])
ca_codes__time = aliased_ca_codes__time
ca_codes__freq = np.conjugate(fft(ca_codes__time))
# print 'ca_codes__time(%s) = %s' % (repr(ca_codes__time.shape), repr(ca_codes__time))
# Allocate memory for the 2D search
all_results = np.empty(shape=(n_frequency_bins, actual_samples_per_code))
# Generate all frequency bins
frequency_bins = (
settings['intermediate_frequency'] - \
(settings['acquisition_search_frequency_band'] / 2) + \
settings['acquisition_search_frequency_step'] * np.arange(n_frequency_bins)
).astype(int)
# print 'frequency_bins(%s) = %s' % (repr(frequency_bins.shape), repr(frequency_bins))
# Allocate memory for output dictionary
satellites_to_search__shape = settings['satellites_to_search'].shape
output = {
'frequency_shifts': np.zeros(satellites_to_search__shape, dtype=int),
'code_shifts': np.zeros(satellites_to_search__shape, dtype=int),
'peak_ratios': np.zeros(satellites_to_search__shape),
'found': np.zeros(satellites_to_search__shape, dtype=np.bool),
}
correct_runs = 0
run_number = 0
for idx, prn in enumerate(settings['satellites_to_search']):
print '* searching PRN = %s' % (repr(prn), )
# correct_runs = 0
# run_number = 0
summed_corr_result_magnitudes = np.zeros(actual_samples_per_code)
counter = 10
while counter > 0:
counter -= 1
# Two consecutive 2ms reading
# x_1 = x[(settings['code_offset']*samples_per_code):(settings['code_offset']*samples_per_code + samples_per_code)]
# x_2 = x[(settings['code_offset']*samples_per_code + samples_per_code):(settings['code_offset']*samples_per_code + 2*samples_per_code)]
x_1 = x[run_number *
samples_per_code:(run_number * samples_per_code +
samples_per_code)]
# print 'x_1.shape = %s' % repr(x_1.shape)
run_number += 1
print 'run_number = %s' % repr(run_number)
#
# Scan all Doppler shifts
#
for freq_bin_i in xrange(n_frequency_bins):
# Generate local sine and cosine carriers
carrier_sin = np.sin(frequency_bins[freq_bin_i] * phases)
carrier_cos = np.cos(frequency_bins[freq_bin_i] * phases)
# Demodulation
I1 = carrier_sin * x_1
Q1 = carrier_cos * x_1
# I2 = carrier_sin * x_2
# Q2 = carrier_cos * x_2
# Reconstruct baseband signal
IQ1 = I1 + 1j * Q1
# IQ2 = I2 + 1j*Q2
if settings['use_sfft']:
IQ1 = sfft_aliasing.execute(
IQ1, settings['sfft_subsampling_factor'])
# IQ2 = sfft_aliasing.execute(IQ2, settings['sfft_subsampling_factor'])
performance_counter.increase(
additions=IQ1.size *
settings['sfft_subsampling_factor'])
# performance_counter.increase(additions=IQ2.size * settings['sfft_subsampling_factor'])
# Convert to frequency domain
IQ1_freq = fft(IQ1)
# IQ2_freq = fft(IQ2)
performance_counter.fft(IQ1.size)
# performance_counter.fft(IQ2.size)
# Multiplication in the frequency domain corresponds to convolution in the time domain
conv_code_IQ1 = IQ1_freq * ca_codes__freq[prn - 1]
# conv_code_IQ2 = IQ2_freq * ca_codes__freq[prn-1]
performance_counter.increase(multiplications=IQ1_freq.size)
# performance_counter.increase(multiplications=IQ2_freq.size)
# IFFT to obtain correlation
corr_result = np.abs(ifft(conv_code_IQ1))**2
# corr_result_2 = np.abs(ifft(conv_code_IQ2)) ** 2
# assert all_results[freq_bin_i, :].shape == corr_result_1.shape == corr_result_2.shape
# if np.max(corr_result_1) > np.max(corr_result_2):
all_results[freq_bin_i, :] = corr_result
# else:
# all_results[freq_bin_i, :] = corr_result_2
# Get the peak location for every frequency bins
peak_values = all_results.max(axis=1)
assert all_results.max() in peak_values
# Find the Doppler shift index
frequency_shift_idx = peak_values.argmax()
# print 'frequency_shift_idx = %s' % repr(frequency_shift_idx)
# Select the frequency bin that corresponds to this frequency shift index
located_frequency_bin = all_results[frequency_shift_idx]
# Find the code shift in the correct frequency bin
code_shift = located_frequency_bin.argmax()
# output['code_shifts'][idx] = code_shift
# print 'code_shift = %s' % repr(code_shift)
peak_value = located_frequency_bin[code_shift]
assert all_results.max() == peak_value
# print 'peak_value = %s' % repr(peak_value)
print np.abs(code_shift - settings['actual_satellite_shifts'][idx])
if np.abs(code_shift -
settings['actual_satellite_shifts'][idx]) < 40:
correct_runs += 1
print 'CORRECT RUN!'
# # New Threshold calculation
# summed_corr_result_magnitudes += np.abs(located_frequency_bin)
# # print 'here', summed_corr_result_magnitudes.argmax()
# snr = get_snr(summed_corr_result_magnitudes)
# print 'snr', snr
# if snr > settings['snr_threshold']:
# output['found'][idx] = True
# print 'summed_corr_result_magnitudes', summed_corr_result_magnitudes
# output['code_shifts'][idx] = summed_corr_result_magnitudes.argmax()
# break
#
# if plot_3d_graphs:
# fig = plt.figure()
# doppler_shifts__khz = (
# (settings['acquisition_search_frequency_step'] * np.arange(n_frequency_bins)) -
# (settings['acquisition_search_frequency_band'] / 2)
# ) / 1000
#
# ax = fig.gca(projection='3d')
# surf = ax.plot_surface(
# X=np.arange(actual_samples_per_code).reshape((1, -1)),
# Y=doppler_shifts__khz.reshape((-1, 1)),
# Z=all_results,
# rstride=1,
# cstride=1,
# cmap=matplotlib.cm.coolwarm,
# linewidth=0,
# antialiased=False,
# )
# ax.set_xlabel('Code shift')
# ax.set_ylabel('Doppler shift (kHz)')
#
# # Calculate code phase range
# samples_per_code_chip = int(round(settings['sampling_frequency'] / settings['code_frequency']))
#
# # SFFT
# if settings['use_sfft']:
# samples_per_code_chip = int(samples_per_code_chip / settings['sfft_subsampling_factor'])
#
# print 'samples_per_code_chip = %s' % repr(samples_per_code_chip)
#
# #
# # Get second largest peak value outside the chip where the maximum peak is located
# #
#
# # Calculate excluded range
# excluded_range_1 = code_shift - samples_per_code_chip
# excluded_range_2 = code_shift + samples_per_code_chip
# print 'excluded_range_1 = %s' % repr(excluded_range_1)
# print 'excluded_range_2 = %s' % repr(excluded_range_2)
#
# # Excluded range boundary correction
# if excluded_range_1 < 1:
# print 'excluded_range_1 < 1'
# code_phase_range = np.arange(excluded_range_2, actual_samples_per_code + excluded_range_1)
# elif excluded_range_2 >= actual_samples_per_code:
# print 'excluded_range_2 >= samples_per_code'
# code_phase_range = np.arange(excluded_range_2 - actual_samples_per_code, excluded_range_1)
# else:
# code_phase_range = np.concatenate((
# np.arange(0, excluded_range_1),
# np.arange(excluded_range_2, actual_samples_per_code)
# ))
#
# assert code_shift not in code_phase_range
# print 'code_phase_range(%s) = %s' % (repr(code_phase_range.shape), repr(code_phase_range))
#
# # Get second largest peak value
# second_peak_value = all_results[frequency_shift_idx, code_phase_range].max()
# print 'second_peak_value = %s' % repr(second_peak_value)
#
# # Calculate ratio between the largest peak value and the second largest peak value
# peak_ratio = peak_value / second_peak_value
# print 'peak_ratio = %s' % repr(peak_ratio)
# output['peak_ratios'][idx] = peak_ratio
#
# #
# # Thresholding
# #
#
# if peak_ratio > settings['acquisition_threshold']:
# output['found'][idx] = True
# print '-> %s FOUND' % repr(prn)
# else:
# output['found'][idx] = False
# print '-> %s NOT FOUND' % repr(prn)
if plot_graphs:
plt.figure()
colors = ['r' if found else 'b' for found in output['found']]
plt.bar(settings['satellites_to_search'],
output['peak_ratios'],
color=colors,
align='center')
plt.ylabel('Acquisition quality')
plt.xlabel('PRN number')
artist__not_acquired = plt.Rectangle((0, 0), 1, 1, fc='b')
artist__acquired = plt.Rectangle((0, 0), 1, 1, fc='r')
plt.legend((artist__not_acquired, artist__acquired),
('Signal not acquired', 'Signal acquired'))
plt.xlim(0, settings['satellites_total'] + 1)
plt.tight_layout()
if run_number == 0:
output['success_probability'] = 0
else:
output['success_probability'] = correct_runs / run_number
print output['success_probability']
return output, performance_counter
def single_acquisition(x,
prn,
settings,
plot_3d_graphs=False,
performance_counter=PerformanceCounter()):
# Calculate number of samples per spreading code (corresponding to 1ms of data)
samples_per_code = int(
round(settings['sampling_frequency'] * settings['code_length'] /
settings['code_frequency']))
print 'samples_per_code = %s' % repr(samples_per_code)
# SFFT
aliased_samples_per_code = int(samples_per_code /
settings['sfft_subsampling_factor'])
if settings['use_sfft']:
actual_samples_per_code = aliased_samples_per_code
else:
actual_samples_per_code = samples_per_code
# Two consecutive 2ms reading
x_1 = x[(settings['code_offset'] *
samples_per_code):((settings['code_offset'] * samples_per_code) +
samples_per_code)]
x_2 = x[(settings['code_offset'] * samples_per_code +
samples_per_code):(settings['code_offset'] * samples_per_code +
2 * samples_per_code)]
if x_1.size != samples_per_code:
return False, performance_counter
print 'x_1.shape = %s' % repr(x_1.shape)
print 'x_2.shape = %s' % repr(x_2.shape)
# Calculate sampling period
sampling_period = 1.0 / settings['sampling_frequency']
print 'sampling_period = %s' % repr(sampling_period)
# Generate phase points of the local carrier
phases = np.arange(0, samples_per_code) * 2 * np.pi * sampling_period
print 'phases(%s) = %s' % (repr(phases.shape), repr(phases))
# Calculate number of frequency bins depending on search frequency band and frequency step
assert settings['acquisition_search_frequency_band'] % settings['acquisition_search_frequency_step'] == 0, \
'acquisition_search_frequency_band should be divisible by acquisition_search_frequency_step'
n_frequency_bins = int(settings['acquisition_search_frequency_band'] /
settings['acquisition_search_frequency_step']) + 1
print 'n_frequency_bins = %s' % repr(n_frequency_bins)
# Generate C/A code
ca_code__time = ca_code.generate_from_settings(settings, prn=prn)
# SFFT
if settings['use_sfft']:
ca_code__time = sfft_aliasing.execute(
ca_code__time, settings['sfft_subsampling_factor'])
ca_codes__freq = np.conjugate(fft(ca_code__time))
print 'ca_codes__time(%s) = %s' % (repr(
ca_code__time.shape), repr(ca_code__time))
# Allocate memory for the 2D search
all_results = np.empty(shape=(n_frequency_bins, actual_samples_per_code))
# Generate all frequency bins
frequency_bins = (
settings['intermediate_frequency'] - \
(settings['acquisition_search_frequency_band'] / 2) + \
settings['acquisition_search_frequency_step'] * np.arange(n_frequency_bins)
).astype(int)
print 'frequency_bins(%s) = %s' % (repr(
frequency_bins.shape), repr(frequency_bins))
# Allocate memory for output dictionary
output = {
'frequency_shift': None,
'code_shift': None,
'peak_value': None,
'peak_ratio': None,
'corr_result': None,
'found': None,
}
print '* searching PRN = %s' % (repr(prn), )
#
# Scan all Doppler shifts
#
for freq_bin_i in xrange(n_frequency_bins):
# Generate local sine and cosine carriers
carrier_sin = np.sin(frequency_bins[freq_bin_i] * phases)
carrier_cos = np.cos(frequency_bins[freq_bin_i] * phases)
# Demodulation
I1 = carrier_sin * x_1
Q1 = carrier_cos * x_1
# I2 = carrier_sin * x_2
# Q2 = carrier_cos * x_2
# Reconstruct baseband signal
IQ1 = I1 + 1j * Q1
# IQ2 = I2 + 1j*Q2
if settings['use_sfft']:
IQ1 = sfft_aliasing.execute(IQ1,
settings['sfft_subsampling_factor'])
# IQ2 = sfft_aliasing.execute(IQ2, settings['sfft_subsampling_factor'])
performance_counter.increase(additions=IQ1.size *
settings['sfft_subsampling_factor'])
# performance_counter.increase(additions=IQ2.size * settings['sfft_subsampling_factor'])
# Convert to frequency domain
IQ1_freq = fft(IQ1)
# IQ2_freq = fft(IQ2)
performance_counter.fft(IQ1.size)
# performance_counter.fft(IQ2.size)
# Multiplication in the frequency domain corresponds to convolution in the time domain
conv_code_IQ1 = IQ1_freq * ca_codes__freq
# conv_code_IQ2 = IQ2_freq * ca_codes__freq[prn-1]
performance_counter.increase(multiplications=IQ1_freq.size)
# performance_counter.increase(multiplications=IQ2_freq.size)
# IFFT to obtain correlation
corr_result_1 = np.abs(ifft(conv_code_IQ1))**2
# corr_result_2 = np.abs(ifft(conv_code_IQ2)) ** 2
# assert all_results[freq_bin_i, :].shape == corr_result_1.shape == corr_result_2.shape
# if np.max(corr_result_1) > np.max(corr_result_2):
all_results[freq_bin_i, :] = corr_result_1
# else:
# all_results[freq_bin_i, :] = corr_result_2
# Get the peak location for every frequency bins
peak_values = all_results.max(axis=1)
assert all_results.max() in peak_values
# Find the Doppler shift index
frequency_shift_idx = peak_values.argmax()
print 'frequency_shift_idx = %s' % repr(frequency_shift_idx)
# Select the frequency bin that corresponds to this frequency shift index
located_frequency_bin = all_results[frequency_shift_idx]
output['corr_result'] = located_frequency_bin
# Find the code shift in the correct frequency bin
code_shift = located_frequency_bin.argmax()
output['code_shift'] = code_shift
print 'code_shift = %s' % repr(code_shift)
peak_value = all_results[frequency_shift_idx][code_shift]
output['peak_value'] = peak_value
assert all_results.max() == peak_value
print 'peak_value = %s' % repr(peak_value)
if plot_3d_graphs:
fig = plt.figure()
doppler_shifts__khz = (
(settings['acquisition_search_frequency_step'] *
np.arange(n_frequency_bins)) -
(settings['acquisition_search_frequency_band'] / 2)) / 1000
ax = fig.gca(projection='3d')
surf = ax.plot_surface(
X=np.arange(samples_per_code).reshape((1, -1)),
Y=doppler_shifts__khz.reshape((-1, 1)),
Z=all_results,
rstride=1,
cstride=1,
cmap=matplotlib.cm.coolwarm,
linewidth=0,
antialiased=False,
)
ax.set_xlabel('Code shift')
ax.set_ylabel('Doppler shift (kHz)')
# Calculate code phase range
samples_per_code_chip = int(
round(settings['sampling_frequency'] / settings['code_frequency']))
# SFFT
if settings['use_sfft']:
samples_per_code_chip = int(samples_per_code_chip /
settings['sfft_subsampling_factor'])
print 'samples_per_code_chip = %s' % repr(samples_per_code_chip)
#
# Threshold calculation 2
#
# located_frequency_bin__without_peak = np.delete(located_frequency_bin, code_shift)
# assert peak_value.max() not in located_frequency_bin__without_peak
# output['noise_var'] = (located_frequency_bin__without_peak - located_frequency_bin__without_peak.mean()).var()
# output['snr'] = peak_value**2 / output['noise_var']
#
# Get second largest peak value outside the chip where the maximum peak is located
#
# Calculate excluded range
excluded_range_1 = code_shift - samples_per_code_chip
excluded_range_2 = code_shift + samples_per_code_chip
print 'excluded_range_1 = %s' % repr(excluded_range_1)
print 'excluded_range_2 = %s' % repr(excluded_range_2)
# Excluded range boundary correction
if excluded_range_1 < 1:
print 'excluded_range_1 < 1'
code_phase_range = np.arange(
excluded_range_2, actual_samples_per_code + excluded_range_1)
elif excluded_range_2 >= actual_samples_per_code:
print 'excluded_range_2 >= samples_per_code'
code_phase_range = np.arange(
excluded_range_2 - actual_samples_per_code, excluded_range_1)
else:
code_phase_range = np.concatenate((np.arange(0, excluded_range_1),
np.arange(excluded_range_2,
actual_samples_per_code)))
assert code_shift not in code_phase_range
print 'code_phase_range(%s) = %s' % (repr(
code_phase_range.shape), repr(code_phase_range))
# Get second largest peak value
second_peak_value = all_results[frequency_shift_idx,
code_phase_range].max()
print 'second_peak_value = %s' % repr(second_peak_value)
# # TEST
# sorted = np.sort(located_frequency_bin)[::-1]
# assert sorted[0] == peak_value
# assert sorted[1] == second_peak_value
# Calculate ratio between the largest peak value and the second largest peak value
peak_ratio = peak_value / second_peak_value
print 'peak_ratio = %s' % repr(peak_ratio)
output['peak_ratio'] = peak_ratio
#
# Thresholding
#
if peak_ratio > settings['acquisition_threshold']:
output['found'] = True
print '-> %s FOUND' % repr(prn)
else:
output['found'] = False
print '-> %s NOT FOUND' % repr(prn)
return output, performance_counter