def test_AmplitudeSine_SNR0(): ''' Test AmplitudeSine SNR_0 computation (1.+2.*sin(2.*pi*t/1.)) ''' noiseParams = NoiseParameters(1e6, 1.) ampl = AmplitudeSine(AmplitudeBase.UNITS_AMPLITUDE, 1., 2., 1.) SNR = 10. * numpy.log10(noiseParams.getFreqTimesTau() / 4.) assert numpy.abs(SNR - ampl.computeSNR(noiseParams)) < EPSILON
def test_AmplitudePoly_SNR1(): ''' Test AmplitudePoly SNR_0 computation (first order polynomial) ''' noiseParams = NoiseParameters(1e6, 1.) ampl = AmplitudePoly(AmplitudeBase.UNITS_AMPLITUDE, (1.,)) SNR = 10. * numpy.log10(noiseParams.getFreqTimesTau() / 4.) assert SNR == ampl.computeSNR(noiseParams)
def test_AmplitudeSine_SNR0():
'''
Test AmplitudeSine SNR_0 computation (1.+2.*sin(2.*pi*t/1.))
'''
noiseParams = NoiseParameters(1e6, 1.)
ampl = AmplitudeSine(AmplitudeBase.UNITS_AMPLITUDE, 1., 2., 1.)
SNR = 10. * numpy.log10(noiseParams.getFreqTimesTau() / 4.)
assert numpy.abs(SNR - ampl.computeSNR(noiseParams)) < EPSILON
def test_AmplitudePoly_SNR3():
'''
Test AmplitudePoly SNR_0 computation (second order polynomial, power units)
'''
noiseParams = NoiseParameters(1e6, 1.)
ampl = AmplitudePoly(AmplitudeBase.UNITS_POWER, (1., 1.))
SNR = 10. * numpy.log10(noiseParams.getFreqTimesTau() / 4.)
assert SNR == ampl.computeSNR(noiseParams)
def test_AmplitudePoly_SNR3(): ''' Test AmplitudePoly SNR_0 computation (second order polynomial, power units) ''' noiseParams = NoiseParameters(1e6, 1.) ampl = AmplitudePoly(AmplitudeBase.UNITS_POWER, (1., 1.)) SNR = 10. * numpy.log10(noiseParams.getFreqTimesTau() / 4.) assert SNR == ampl.computeSNR(noiseParams)
def test_AmplitudePoly_SNR1():
'''
Test AmplitudePoly SNR_0 computation (first order polynomial)
'''
noiseParams = NoiseParameters(1e6, 1.)
ampl = AmplitudePoly(AmplitudeBase.UNITS_AMPLITUDE, (1., ))
SNR = 10. * numpy.log10(noiseParams.getFreqTimesTau() / 4.)
assert SNR == ampl.computeSNR(noiseParams)
def test_NoiseParameters(): ''' Generic tests for NoiseParameters ''' noiseParams = NoiseParameters(1e6, 1.) assert 1e6 == noiseParams.getSamplingFreqHz() assert 1. == noiseParams.getNoiseSigma() assert 1. == noiseParams.getFreqTimesTau() assert 2. == noiseParams.getSignalK()
def test_Task_computeTcxoVector2():
'''
Task object TCXO helper test
'''
outputConfig = NormalRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = TCXOPoly((1., ))
signalFilters = [None] * 4
groupDelays = False
bands = [outputConfig.GPS.L1]
generateDebug = False
task = Task(outputConfig, signalSources, noiseParams, tcxo, signalFilters,
groupDelays, bands, generateDebug)
userTime0_s = 123.
nSamples = 1024
firstSampleIndex = 1
task.update(userTime0_s, nSamples, firstSampleIndex)
tcxoVector = task.computeTcxoVector()
assert isinstance(tcxoVector, numpy.ndarray)
assert tcxoVector.shape == (1024, )
assert (tcxoVector != 0.).all()
def test_Task_computeTcxoVector1():
'''
Task object TCXO helper test
'''
outputConfig = NormalRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = None
signalFilters = [None] * 4
groupDelays = False
bands = [outputConfig.GPS.L1]
generateDebug = False
task = Task(outputConfig, signalSources, noiseParams, tcxo, signalFilters,
groupDelays, bands, generateDebug)
userTime0_s = 123.
nSamples = 1024
firstSampleIndex = 1
task.update(userTime0_s, nSamples, firstSampleIndex)
tcxo = task.computeTcxoVector()
# TCXO object is None because TCXO function is not provided
assert tcxo is None
def test_Task_init():
'''
Task object initialization test
'''
outputConfig = NormalRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = TCXOPoly(())
signalFilters = [None] * 4
groupDelays = False
bands = [outputConfig.GPS.L1]
generateDebug = False
task = Task(outputConfig, signalSources, noiseParams, tcxo, signalFilters,
groupDelays, bands, generateDebug)
assert task.outputConfig == outputConfig
assert task.bands == bands
assert task.generateDebug == generateDebug
assert task.groupDelays == groupDelays
assert task.noiseParams == noiseParams
assert task.signalFilters == signalFilters
assert task.signalSources == signalSources
assert task.tcxo == tcxo
assert isinstance(task.noise, numpy.ndarray)
assert task.noise.shape == (outputConfig.N_GROUPS,
outputConfig.SAMPLE_BATCH_SIZE)
assert isinstance(task.signals, numpy.ndarray)
assert task.signals.shape == (outputConfig.N_GROUPS,
outputConfig.SAMPLE_BATCH_SIZE)
def test_Task_computeGroupTimeVectors1():
'''
Task object group time vector test
'''
outputConfig = NormalRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = TCXOPoly((1., ))
signalFilters = [None] * 4
groupDelays = True
bands = [outputConfig.GPS.L1]
generateDebug = False
task = Task(outputConfig, signalSources, noiseParams, tcxo, signalFilters,
groupDelays, bands, generateDebug)
nSamples = 1024
userTime0_s = 0.
firstSampleIndex = 1
task.update(userTime0_s, nSamples, firstSampleIndex)
userTimeAll_s = task.computeTimeVector()
result = task.computeGroupTimeVectors(userTimeAll_s)
assert isinstance(result, list)
for i in range(outputConfig.N_GROUPS):
assert (result[i] == userTimeAll_s +
outputConfig.GROUP_DELAYS[i]).all()
def test_Task_generate0():
'''
Task object generation test
'''
outputConfig = HighRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = TCXOPoly((1., ))
signalFilters = [
LowPassFilter(outputConfig,
outputConfig.GPS.L1.INTERMEDIATE_FREQUENCY_HZ), None,
None, None
]
groupDelays = True
bands = [outputConfig.GPS.L1]
generateDebug = False
task = Task(outputConfig, signalSources, noiseParams, tcxo, signalFilters,
groupDelays, bands, generateDebug)
nSamples = 1024
userTime0_s = 0.
firstSampleIndex = 1
task.update(userTime0_s, nSamples, firstSampleIndex)
inputParams, sigs, debugData = task.perform()
assert inputParams[0] == userTime0_s
assert inputParams[1] == nSamples
assert inputParams[2] == firstSampleIndex
assert debugData is None
assert sigs.shape == (outputConfig.N_GROUPS, nSamples)
def test_Worker_init():
'''
Worker object initialization
'''
outputConfig = NormalRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = None
signalFilters = [None] * 4
groupDelays = False
bands = [outputConfig.GPS.L1]
generateDebug = False
worker = Worker(outputConfig, signalSources, noiseParams, tcxo,
signalFilters, groupDelays, bands, generateDebug)
assert worker.totalWaitTime_s == 0.
assert worker.totalExecTime_s == 0.
assert worker.outputConfig == outputConfig
assert worker.signalSources == signalSources
assert worker.noiseParams == noiseParams
assert worker.tcxo == tcxo
assert worker.signalFilters == signalFilters
assert worker.groupDelays == groupDelays
assert worker.bands == bands
assert worker.generateDebug == generateDebug
def test_Task_createNoise():
'''
Task object noise helper test
'''
outputConfig = NormalRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = TCXOPoly((1., ))
signalFilters = [None] * 4
groupDelays = False
bands = [outputConfig.GPS.L1]
generateDebug = False
task = Task(outputConfig, signalSources, noiseParams, tcxo, signalFilters,
groupDelays, bands, generateDebug)
userTime0_s = 123.
nSamples = outputConfig.SAMPLE_BATCH_SIZE
firstSampleIndex = 1
task.update(userTime0_s, nSamples, firstSampleIndex)
noiseMatrix = task.createNoise()
assert isinstance(noiseMatrix, numpy.ndarray)
assert noiseMatrix.shape == (outputConfig.N_GROUPS, nSamples)
assert numpy.mean(noiseMatrix) < 0.1
assert (noiseMatrix != 0.).sum() > 1000
def test_GLOSv_getBatchSignals3():
'''
GLONASS SV signal generation: L2
'''
sv = GLOSatellite(1)
start = 0.
stop = start + (100. / float(NormalRateConfig.SAMPLE_RATE_HZ))
userTimeAll_s = numpy.linspace(start,
stop,
100,
endpoint=False,
dtype=numpy.float)
samples = numpy.zeros((4, 100))
noiseParams = NoiseParameters(NormalRateConfig.SAMPLE_RATE_HZ, 1.0)
sv.setL2Enabled(True)
result = sv.getBatchSignals(userTimeAll_s, samples, NormalRateConfig,
noiseParams, NormalRateConfig.GLONASS.L2,
False)
assert len(result) == 1
assert result[0]['type'] == 'GLOL2'
assert result[0]['doppler'] is None
assert (samples[0] == 0).all()
assert (samples[1] == 0).all()
assert (samples[2] == 0).all()
assert (samples[3] != 0).any()
def test_Task_update1():
'''
Task object parameter update test
'''
outputConfig = NormalRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = TCXOPoly(())
signalFilters = [None] * 4
groupDelays = False
bands = [outputConfig.GPS.L1]
generateDebug = False
task = Task(outputConfig, signalSources, noiseParams, tcxo, signalFilters,
groupDelays, bands, generateDebug)
userTime0_s = 123.
nSamples = 1024
firstSampleIndex = 1
task.update(userTime0_s, nSamples, firstSampleIndex)
assert task.nSamples == nSamples
assert task.firstSampleIndex == firstSampleIndex
assert task.userTime0_s == userTime0_s
assert task.noise.shape == (outputConfig.N_GROUPS, nSamples)
assert isinstance(task.signals, numpy.ndarray)
assert task.signals.shape == (outputConfig.N_GROUPS, nSamples)
def test_Task_generate1():
'''
Task object generation test
'''
outputConfig = HighRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = None
signalFilters = [None] * 4
groupDelays = True
bands = [outputConfig.GPS.L1]
generateDebug = True
task = Task(outputConfig, signalSources, noiseParams, tcxo, signalFilters,
groupDelays, bands, generateDebug)
nSamples = 1024
userTime0_s = 0.
firstSampleIndex = 1
task.update(userTime0_s, nSamples, firstSampleIndex)
inputParams, sigs, debugData = task.perform()
assert inputParams[0] == userTime0_s
assert inputParams[1] == nSamples
assert inputParams[2] == firstSampleIndex
assert isinstance(debugData, dict)
assert sigs.shape == (outputConfig.N_GROUPS, nSamples)
def test_AmplitudePoly_SNR5():
'''
Test AmplitudePoly SNR_0 computation (second order polynomial, SNR dB units)
'''
noiseParams = NoiseParameters(1e6, 1.)
ampl = AmplitudePoly(AmplitudeBase.UNITS_SNR_DB, (1., 1.))
SNR = 1.
assert SNR == ampl.computeSNR(noiseParams)
def test_AmplitudeSine_apply0():
'''
Test AmplitudeSine computation (1.+2.*sin(2.*pi*t/4.))
'''
noiseParams = NoiseParameters(1e6, 1.)
ampl = AmplitudeSine(AmplitudeBase.UNITS_AMPLITUDE, 1., 2., 4.)
userTimeAll_s = numpy.asarray([0., 1., 2.], dtype=numpy.float)
signal = numpy.asarray([0., 1., 1.], dtype=numpy.float)
signal = ampl.applyAmplitude(signal, userTimeAll_s, noiseParams)
assert (numpy.abs(signal - numpy.asarray([0., 3., 1.], dtype=numpy.float))
< EPSILON).all()
def test_AmplitudePoly_apply2():
'''
Test AmplitudePoly computation (first order polynomial: 1.0*t+1.0)
'''
noiseParams = NoiseParameters(1e6, 1.)
ampl = AmplitudePoly(AmplitudeBase.UNITS_AMPLITUDE, (1., 1.))
userTimeAll_s = numpy.asarray([0., 1.], dtype=numpy.float)
signal = numpy.asarray([0., 1.], dtype=numpy.float)
signal = ampl.applyAmplitude(signal, userTimeAll_s, noiseParams)
assert (numpy.abs(signal - numpy.asarray([0., 2.], dtype=numpy.float)) <
EPSILON).all()
def test_SVBase_getBatchSignals():
'''
Base SV class: abstract method test
'''
sv = SVBase("TEST_SV")
userTimeAll_s = numpy.zeros(1)
samples = numpy.zeros(1)
noiseParams = NoiseParameters(NormalRateConfig.SAMPLE_RATE_HZ, 1.0)
try:
sv.getBatchSignals(userTimeAll_s, samples, NormalRateConfig,
noiseParams, NormalRateConfig.GPS.L1, False)
assert False
except NotImplementedError:
pass
def test_AmplitudeBase_convertVolts():
'''
Generic tests for AmplitudeBase conversion to volts
'''
noiseParams = NoiseParameters(1e6, 1.)
assert 4. == AmplitudeBase.convertUnits2Amp(4.,
AmplitudeBase.UNITS_AMPLITUDE,
noiseParams)
assert 2. == AmplitudeBase.convertUnits2Amp(4., AmplitudeBase.UNITS_POWER,
noiseParams)
assert 20. == AmplitudeBase.convertUnits2Amp(100, AmplitudeBase.UNITS_SNR,
noiseParams)
assert 2. == AmplitudeBase.convertUnits2Amp(0., AmplitudeBase.UNITS_SNR_DB,
noiseParams)
def test_AmplitudeBase_convertSNR():
'''
Generic tests for AmplitudeBase conversion to volts
'''
noiseParams = NoiseParameters(1e6, 1.)
assert 10. * numpy.log10(4.) == AmplitudeBase.convertUnits2SNR(
4., AmplitudeBase.UNITS_AMPLITUDE, noiseParams)
assert 10. * numpy.log10(1.) == AmplitudeBase.convertUnits2SNR(
4., AmplitudeBase.UNITS_POWER, noiseParams)
assert 20. == AmplitudeBase.convertUnits2SNR(100, AmplitudeBase.UNITS_SNR,
noiseParams)
assert 15. == AmplitudeBase.convertUnits2SNR(15.,
AmplitudeBase.UNITS_SNR_DB,
noiseParams)
def test_NoiseParameters():
'''
Generic tests for NoiseParameters
'''
noiseParams = NoiseParameters(1e6, 1.)
assert 1e6 == noiseParams.getSamplingFreqHz()
assert 1. == noiseParams.getNoiseSigma()
assert 1. == noiseParams.getFreqTimesTau()
assert 2. == noiseParams.getSignalK()
def test_Task_runOnce0():
'''
Worker object loop cycle test
'''
class MyQueue(object):
def __init__(self):
self.queue = []
def get(self):
return self.queue.pop(0)
def put(self, obj):
return self.queue.append(obj)
outputConfig = NormalRateConfig
sv0 = GPSSatellite(1)
sv0.setL1CAEnabled(True)
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = None
signalFilters = [None] * 4
groupDelays = False
bands = [outputConfig.GPS.L1]
generateDebug = False
worker = Worker(outputConfig, signalSources, noiseParams, tcxo,
signalFilters, groupDelays, bands, generateDebug)
# worker.start()
worker.queueIn = MyQueue()
worker.queueOut = MyQueue()
nSamples = 1024
userTime0_s = 0.
firstSampleIndex = 1l
params = (userTime0_s, nSamples, firstSampleIndex)
worker.queueIn.put(params)
task = worker.createTask()
worker.run_once(task)
result = worker.queueOut.get()
(inputParams, signalSamples, debugData) = result
assert inputParams[0] == userTime0_s
assert inputParams[1] == nSamples
assert inputParams[2] == firstSampleIndex
assert debugData is None
assert signalSamples.shape == (outputConfig.N_GROUPS, nSamples)
worker.queueIn.put(None)
worker.run_once(task)
worker.queueOut.get()
def test_GLOSv_getBatchSignals1():
'''
GLONASS SV signal generation: not available
'''
sv = GLOSatellite(1)
start = 0.
stop = start + (100. / float(NormalRateConfig.SAMPLE_RATE_HZ))
userTimeAll_s = numpy.linspace(start,
stop,
100,
endpoint=False,
dtype=numpy.float)
samples = numpy.zeros((4, 100))
noiseParams = NoiseParameters(NormalRateConfig.SAMPLE_RATE_HZ, 1.0)
result = sv.getBatchSignals(userTimeAll_s, samples, NormalRateConfig,
noiseParams, NormalRateConfig.GPS.L1, False)
assert len(result) == 0
assert (samples == 0).all()
def test_AmplitudeBase_abstract():
'''
Generic tests for AmplitudeBase abstract methods
'''
ampl = AmplitudeBase(AmplitudeBase.UNITS_SNR_DB)
noiseParams = NoiseParameters(1e6, 1.)
userTimeAll_s = numpy.asarray([0., 1.], dtype=numpy.float)
signal = numpy.asarray([0., 1.], dtype=numpy.float)
try:
ampl.computeSNR(noiseParams)
assert False
except NotImplementedError:
pass
try:
ampl.applyAmplitude(signal, userTimeAll_s, noiseParams)
assert False
except NotImplementedError:
pass
def test_Task_runOnce1():
'''
Worker object loop cycle test. This test verifies error handling during
data generation.
'''
class MyQueue(object):
def __init__(self):
self.queue = []
def get(self):
return self.queue.pop(0)
def put(self, obj):
return self.queue.append(obj)
outputConfig = NormalRateConfig
# Wrong SV object to ensure the error is encountered
sv0 = Satellite('1')
signalSources = [sv0]
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 1.)
tcxo = None
signalFilters = [None] * 4
groupDelays = False
bands = [outputConfig.GPS.L1]
generateDebug = False
worker = Worker(outputConfig, signalSources, noiseParams, tcxo,
signalFilters, groupDelays, bands, generateDebug)
# worker.start()
worker.queueIn = MyQueue()
worker.queueOut = MyQueue()
nSamples = 1024
userTime0_s = 0.
firstSampleIndex = 1l
params = (userTime0_s, nSamples, firstSampleIndex)
worker.queueIn.put(params)
task = worker.createTask()
worker.run_once(task)
result = worker.queueOut.get()
# result is None because the run_once() catches an error during SV method
# invocation
assert result is None
def test_GPSSV_getBatchSignals0():
'''
GPS SV signal generation: not enabled
'''
sv = GPSSatellite(1)
start = 0.
stop = start + (100. / float(NormalRateConfig.SAMPLE_RATE_HZ))
userTimeAll_s = numpy.linspace(start,
stop,
100,
endpoint=False,
dtype=numpy.float)
samples = numpy.zeros((2, 100))
noiseParams = NoiseParameters(NormalRateConfig.SAMPLE_RATE_HZ, 1.0)
result = sv.getBatchSignals(userTimeAll_s, samples, NormalRateConfig,
noiseParams, NormalRateConfig.GPS.L1, False)
assert len(result) == 0
# No signals are generated because SV object doesn't have any of the bands
# enabled
assert (samples == 0).all()
def test_DopplerZero_batch():
'''
Verifies execution of the batch computation with zero doppler.
'''
doppler = zeroDoppler(1000., 50., GPS.L1CA.CENTER_FREQUENCY_HZ)
userTimeAll_s = numpy.linspace(0.,
NormalRateConfig.SAMPLE_BATCH_SIZE /
NormalRateConfig.SAMPLE_RATE_HZ,
NormalRateConfig.SAMPLE_BATCH_SIZE,
endpoint=False)
amplitude = AmplitudePoly(AmplitudeBase.UNITS_AMPLITUDE, ())
noiseParams = NoiseParameters(GPS.L1CA.CENTER_FREQUENCY_HZ, 0.)
message = Message(1)
code = PrnCode(1)
res = doppler.computeBatch(userTimeAll_s,
amplitude,
noiseParams,
GPS.L1CA,
NormalRateConfig.GPS.L1.INTERMEDIATE_FREQUENCY_HZ,
message,
code,
NormalRateConfig,
True)
signal1, doppler1 = res
doppler.setCodeDopplerIgnored(True)
res = doppler.computeBatch(userTimeAll_s,
amplitude,
noiseParams,
GPS.L1CA,
NormalRateConfig.GPS.L1.INTERMEDIATE_FREQUENCY_HZ,
message,
code,
NormalRateConfig,
True)
signal2, doppler2 = res
assert (signal1 == signal2).all()
assert (doppler1 == doppler2).all()
def test_DopplerBase_computeBatch():
'''
Test signal generation
'''
doppler = DopplerBase(distance0_m=0., tec_epm2=0.)
userTimeAll_s = numpy.asarray([0.])
amplitude = AmplitudePoly(AmplitudeBase.UNITS_AMPLITUDE, ())
noiseParams = NoiseParameters(NormalRateConfig.SAMPLE_RATE_HZ, 0.)
message = Message(1)
code = PrnCode(1)
try:
doppler.computeBatch(userTimeAll_s,
amplitude,
noiseParams,
GPS.L1CA,
NormalRateConfig.GPS.L1.INTERMEDIATE_FREQUENCY_HZ,
message,
code,
NormalRateConfig,
False)
assert False
except NotImplementedError:
pass
def generateSamples(outputFile,
sv_list,
encoder,
time0S,
nSamples,
outputConfig,
noiseSigma=None,
tcxo=None,
filterType="none",
groupDelays=None,
logFile=None,
threadCount=0,
pbar=None):
'''
Generates samples.
Parameters
----------
fileName : string
Output file name.
sv_list : list
List of configured satellite objects.
encoder : Encoder
Output encoder object.
time0S : float
Time epoch for the first sample.
nSamples : long
Total number of samples to generate.
outputConfig : object
Output parameters
noiseSigma : float, optional
When specified, adds random noise to the output.
tcxo : object, optional
When specified, controls TCXO drift
filterType : string, optional
Controls IIR/FIR signal post-processing. Disabled by default.
groupDelays : bool
Flag if group delays are enabled.
logFile : object
Debug information destination file.
threadCount : int
Number of parallel threads for multi-process computation.
pbar : object
Progress bar object
'''
#
# Print out parameters
#
logger.info(
"Generating samples, sample rate={} Hz, interval={} seconds".format(
outputConfig.SAMPLE_RATE_HZ,
nSamples / outputConfig.SAMPLE_RATE_HZ))
logger.debug("Jobs: %d" % threadCount)
_count = 0l
# Check which bands are enabled, configure band-specific parameters
bands = [
outputConfig.GPS.L1, outputConfig.GPS.L2, outputConfig.GLONASS.L1,
outputConfig.GLONASS.L2
] # Supported bands
lpf = [None] * outputConfig.N_GROUPS
lpfFA_db = [0.] * outputConfig.N_GROUPS # Filter attenuation levels
bandsEnabled = [False] * outputConfig.N_GROUPS
bandPass = filterType == 'bandpass'
lowPass = filterType == 'lowpass'
for band in bands:
for sv in sv_list:
bandsEnabled[band.INDEX] |= sv.isBandEnabled(band, outputConfig)
sv = None
filterObject = None
ifHz = 0.
if hasattr(band, "INTERMEDIATE_FREQUENCY_HZ"):
ifHz = band.INTERMEDIATE_FREQUENCY_HZ
elif hasattr(band, "INTERMEDIATE_FREQUENCIES_HZ"):
ifHz = band.INTERMEDIATE_FREQUENCIES_HZ[0]
else: # pragma: no coverage
assert False
if lowPass:
filterObject = LowPassFilter(outputConfig, ifHz)
elif bandPass:
filterObject = BandPassFilter(outputConfig, ifHz)
if filterObject:
lpf[band.INDEX] = filterObject
lpfFA_db[band.INDEX] = filterObject.getPassBandAtt()
logger.debug("Band %d filter NBW is %s" %
(band.INDEX, str(filterObject)))
if noiseSigma is not None:
noiseVariance = noiseSigma * noiseSigma
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, noiseSigma)
logger.info("Selected noise sigma %f (variance %f)" %
(noiseSigma, noiseVariance))
else:
noiseVariance = 0.
noiseSigma = 0.
noiseParams = NoiseParameters(outputConfig.SAMPLE_RATE_HZ, 0.)
logger.info("SNR is not provided, noise is not generated.")
# Print out parameters
logger.info(
"Generating samples, sample rate={} Hz, interval={} seconds".format(
outputConfig.SAMPLE_RATE_HZ,
nSamples / outputConfig.SAMPLE_RATE_HZ))
logger.debug("Jobs: %d" % threadCount)
# Print out SV parameters
printSvInfo(sv_list, outputConfig, lpfFA_db, noiseParams, encoder)
userTime_s = float(time0S)
deltaUserTime_s = (float(outputConfig.SAMPLE_BATCH_SIZE) /
float(outputConfig.SAMPLE_RATE_HZ))
debugFlag = logFile is not None
if debugFlag:
logFile.write("Index,Time")
for sv in sv_list:
svName = sv.getName()
for band in bands:
if sv.isBandEnabled(band, outputConfig):
logFile.write(",%s/%s" % (svName, band.NAME))
# End of line
logFile.write("\n")
if threadCount > 0:
# Parallel execution: create worker pool
workerPool = [
Worker(outputConfig, sv_list, noiseParams, tcxo, lpf, groupDelays,
bands, debugFlag) for _ in range(threadCount)
]
for worker in workerPool:
worker.start()
# Each worker in the pool permits 2 tasks in the queue.
maxTaskListSize = threadCount * 2
else:
# Synchronous execution: single worker
workerPool = None
task = Task(outputConfig,
sv_list,
noiseParams=noiseParams,
tcxo=tcxo,
signalFilters=lpf,
groupDelays=groupDelays,
bands=bands,
generateDebug=debugFlag)
maxTaskListSize = 1
workerPutIndex = 0 # Worker index for adding task parameters with RR policy
workerGetIndex = 0 # Worker index for getting task results with RR policy
activeTasks = 0 # Number of active generation tasks
totalSampleCounter = 0l
taskQueuedCounter = 0
taskReceivedCounter = 0
totalEncodeTime_s = 0.
totalWaitTime_s = 0.
while True:
while activeTasks < maxTaskListSize and totalSampleCounter < nSamples:
# We have space in the task backlog and not all batchIntervals are issued
userTime0_s = userTime_s
if totalSampleCounter + outputConfig.SAMPLE_BATCH_SIZE > nSamples:
# Last interval may contain less than full batch size of samples
sampleCount = nSamples - totalSampleCounter
userTimeX_s = userTime0_s + (
float(sampleCount) / float(outputConfig.SAMPLE_RATE_HZ))
else:
# Normal internal: full batch size
userTimeX_s = userTime_s + deltaUserTime_s
sampleCount = outputConfig.SAMPLE_BATCH_SIZE
# Parameters: time interval start, number of samples, sample index
# counter for debug output
params = (userTime0_s, sampleCount, totalSampleCounter)
if workerPool is not None:
# Parallel execution: add the next task parameters into the worker's
# pool queue. Worker pool uses RR policy.
workerPool[workerPutIndex].queueIn.put(params)
workerPutIndex = (workerPutIndex + 1) % threadCount
else:
# Synchronous execution: update task parameters for the next interval
task.update(userTime0_s, sampleCount, totalSampleCounter)
activeTasks += 1
# Update parameters for the next batch interval
userTime_s = userTimeX_s
totalSampleCounter += sampleCount
taskQueuedCounter += 1
# What for the data only if we have something to wait
if taskReceivedCounter == taskQueuedCounter and \
totalSampleCounter == nSamples:
# No more tasks to issue to generator
# No more tasks to wait
break
try:
if workerPool is not None:
# Parallel execution: wait for the next task result
worker = workerPool[workerGetIndex]
waitStartTime_s = time.time()
result = worker.queueOut.get()
workerGetIndex = (workerGetIndex + 1) % threadCount
waitDuration_s = time.time() - waitStartTime_s
totalWaitTime_s += waitDuration_s
else:
# Synchronous execution: execute task and get result
result = task.perform()
except:
exType, exValue, exTraceback = sys.exc_info()
traceback.print_exception(exType,
exValue,
exTraceback,
file=sys.stderr)
result = None
taskReceivedCounter += 1
activeTasks -= 1
if result is None:
logger.error("Error in processor; aborting.")
break
# Unpack result values.
(inputParams, signalSamples, debugData) = result
(_userTime0_s, _sampleCount, _firstSampleIndex) = inputParams
if logFile is not None:
# Data from all satellites is collected. Now we can dump the debug matrix
userTimeAll_s = debugData['time']
signalData = debugData['signalData']
for smpl_idx in range(_sampleCount):
logFile.write("{},{}".format(_firstSampleIndex + smpl_idx,
userTimeAll_s[smpl_idx]))
for svIdx in range(len(signalData)):
signalSourceData = signalData[svIdx]['data']
for band in signalSourceData:
doppler = band['doppler']
logFile.write(",{}".format(doppler[smpl_idx]))
# End of line
logFile.write("\n")
encodeStartTime_s = time.time()
# Feed data into encoder
encodedSamples = encoder.addSamples(signalSamples)
signalSamples = None
if len(encodedSamples) > 0:
_count += len(encodedSamples)
encodedSamples.tofile(outputFile)
encodedSamples = None
totalEncodeTime_s += time.time() - encodeStartTime_s
if pbar:
pbar.update(_firstSampleIndex + _sampleCount)
# Generation completed.
# Flush any pending data in encoder
encodedSamples = encoder.flush()
if len(encodedSamples) > 0:
encodedSamples.tofile(outputFile)
# Close debug log file
if debugFlag:
logFile.close()
# Terminate all worker processes
if workerPool is not None:
for i, worker in enumerate(workerPool):
worker.queueIn.put(None)
for worker in workerPool:
try:
statistics = worker.queueOut.get(timeout=2)
logger.info("Worker [%d] statistics: %s" %
(i, str(statistics)))
except:
exType, exValue, exTraceback = sys.exc_info()
traceback.print_exception(exType,
exValue,
exTraceback,
file=sys.stderr)
worker.queueIn.close()
worker.queueOut.close()
worker.terminate()
worker.join()
# Print some statistical debug information
logger.debug("MAIN: Encode duration: %f" % totalEncodeTime_s)
logger.debug("MAIN: wait duration: %f" % totalWaitTime_s)
