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_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_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)