iqgen: reworked signal SNR control

Refactored GPS/GLONASS SNR control, added possibility to define signal power
in amplitude, power, SNR and SNR(dB) units. Updates SNR estimation due to
encoder attenuation. Fixed minor parameter handling issues.
New parameters added: '--amplitude-units', '--noise-sigma'.
Parameters removed: '--snr'

Author: valeri-atamaniouk

peregrine/iqgen/bits/amplitude_base.py

@@ -14,19 +14,130 @@
 
 """
 
+import numpy
+
+
+class NoiseParameters(object):
+  '''
+  Container class for holding noise generation parameters.
+  '''
+
+  def __init__(self, samplingFreqHz, noiseSigma):
+    '''
+    Parameters
+    ----------
+    samplingFreqHz : float or long
+      Sampling frequency in Hz
+    noiseSigma : float
+      Noise Sigma value
+    '''
+    super(NoiseParameters, self).__init__()
+    self.samplingFreqHz = samplingFreqHz
+    self.noiseSigma = noiseSigma
+
+    # Compute coefficient for 1ms integration
+    self.signalK = noiseSigma * 2. * \
+        numpy.sqrt(1000000. / float(samplingFreqHz))
+
+    self.freqTimeTau = 1e-6 * float(samplingFreqHz)
+
+  def getSamplingFreqHz(self):
+    '''
+    Get sampling frequency.
+
+    Returns
+    -------
+    float or long
+      Sampling frequency in Hz
+    '''
+    return self.samplingFreqHz
+
+  def getNoiseSigma(self):
+    '''
+    Get noise Sigma.
+
+    Returns
+    -------
+    float
+      Noise sigma value
+    '''
+    return self.noiseSigma
+
+  def getFreqTimesTau(self):
+    '''
+    Get sampling integration parameter.
+
+    Returns
+    -------
+    float
+      Integration parameter of the sampling frequency times integration time.
+    '''
+    return self.freqTimeTau
+
+  def getSignalK(self):
+    '''
+    Get amplification coefficient for SNR at 0 dB.
+
+    Returns
+    -------
+    float
+      Signal amplification coefficient for SNR at 0 dB.
+    '''
+    return self.signalK
+
 
 class AmplitudeBase(object):
   '''
   Amplitude control for a signal source.
+
+  Attributes
+  ----------
+  UNITS_AMPLITUDE : string
+    Type of object for measuring signal in amplitude. SNR is dependent on
+    amplitude square.
+  UNITS_POWER : string
+    Type of object for measuring signal in power. SNR is linearly dependent on
+    power.
+  UNITS_SNR : string
+    Type of object for measuring signal in SNR.
+  UNITS_SNR_DB : string
+    Type of object for measuring signal in SNR dB.
+
   '''
 
-  def __init__(self):
+  UNITS_AMPLITUDE = 'AMP'
+  UNITS_POWER = 'PWR'
+  UNITS_SNR = 'SNR'
+  UNITS_SNR_DB = 'SNR_DB'
+
+  def __init__(self, units):
     '''
     Constructs base object for amplitude control.
+
+    Parameters
+    ----------
+    units : string
+      Object units. Can be one of the supported values:
+      - AmplitudeBase::UNITS_AMPLITUDE -- Amplitude units
+      - AmplitudeBase::UNITS_SNR_DB -- SNR in dB
+      - AmplitudeBase::UNITS_SNR -- SNR
+      - AmplitudeBase::UNITS_POWER -- Power units
     '''
     super(AmplitudeBase, self).__init__()
+    self.units = units
+
+  def getUnits(self):
+    '''
+    Provides access to units.
+
+    Returns
+    -------
+    string
+      Amplitude units
+    '''
+    return self.units
 
-  def applyAmplitude(self, signal, userTimeAll_s):
+  def applyAmplitude(self, signal, userTimeAll_s, noiseParams=None):
     '''
     Applies amplitude modulation to signal.
 
@@ -37,6 +148,8 @@ def applyAmplitude(self, signal, userTimeAll_s):
       [-1; +1]. This vector is modified in place.
     userTimeAll_s : numpy.ndarray
       Sample time vector. Each element defines sample time in seconds.
+    noiseParams : NoiseParameters
+      Noise parameters to adjust signal amplitude level.
 
     Returns
     -------
@@ -45,13 +158,88 @@ def applyAmplitude(self, signal, userTimeAll_s):
     '''
     raise NotImplementedError()
 
-  def computeMeanPower(self):
+  def computeSNR(self, noiseParams):
     '''
-    Computes mean signal power.
+    Computes signal to noise ratio in dB.
+
+    Parameters
+    ----------
+    noiseParams : NoiseParameters
+      Noise parameter container
 
     Returns
     -------
     float
-      Mean signal power for the configured amplitude
+      SNR in dB
     '''
     raise NotImplementedError()
+
+  @staticmethod
+  def convertUnits2SNR(value, units, noiseParams):
+    '''
+    Converts signal units to SNR in dB
+
+    Parameters
+    ----------
+    noiseParams : NoiseParameters
+      Noise parameter container
+
+    Returns
+    -------
+    float
+      SNR in dB
+    '''
+
+    noiseSigma = noiseParams.getNoiseSigma()
+    freqTimesTau = noiseParams.getFreqTimesTau()
+
+    if units == AmplitudeBase.UNITS_AMPLITUDE:
+      power = numpy.square(value)
+      snr = freqTimesTau * power / (4. * noiseSigma * noiseSigma)
+      snrDb = 10 * numpy.log10(snr)
+    elif units == AmplitudeBase.UNITS_POWER:
+      power = value
+      snr = freqTimesTau * power / (4. * noiseSigma * noiseSigma)
+      snrDb = 10 * numpy.log10(snr)
+    elif units == AmplitudeBase.UNITS_SNR:
+      snr = value
+      snrDb = 10 * numpy.log10(snr)
+    elif units == AmplitudeBase.UNITS_SNR_DB:
+      snrDb = value
+    else:
+      assert False
+    return snrDb
+
+  @staticmethod
+  def convertUnits2Amp(value, units, noiseParams):
+    '''
+    Converts signal units to amplitude
+
+    Parameters
+    ----------
+    noiseParams : NoiseParameters
+      Noise parameter container
+
+    Returns
+    -------
+    float
+      SNR in dB
+    '''
+
+    noiseSigma = noiseParams.getNoiseSigma()
+    freqTimesTau = noiseParams.getFreqTimesTau()
+
+    if units == AmplitudeBase.UNITS_AMPLITUDE:
+      amp = value
+    elif units == AmplitudeBase.UNITS_POWER:
+      amp = numpy.sqrt(value)
+    elif units == AmplitudeBase.UNITS_SNR:
+      snr = value
+      amp = numpy.sqrt(4. * snr / freqTimesTau) * noiseSigma
+    elif units == AmplitudeBase.UNITS_SNR_DB:
+      snrDb = value
+      snr = 10. ** (0.1 * snrDb)
+      amp = numpy.sqrt(4. * snr / freqTimesTau) * noiseSigma
+    else:
+      assert False
+    return amp

peregrine/iqgen/bits/amplitude_factory.py

@@ -45,24 +45,29 @@ def fromMapForm(self, data):
       raise ValueError("Invalid object type")
 
   def __PolyAmplitude_ToMap(self, obj):
-    data = {'type': 'PolyAmplitude', 'coeffs': obj.coeffs}
+    data = {'type': 'PolyAmplitude',
+            'coeffs': obj.coeffs,
+            'units': obj.units}
     return data
 
   def __SineAmplitude_ToMap(self, obj):
     data = {'type': 'SineAmplitude',
             'initial': obj.initial,
             'amplitude': obj.amplitude,
-            'period': obj.period_s}
+            'period': obj.period_s,
+            'units': obj.units}
     return data
 
   def __MapTo_PolyAmplitude(self, data):
     coeffs = data['coeffs']
-    return PolyAmplitude(coeffs)
+    units = data['units']
+    return PolyAmplitude(units, coeffs)
 
   def __MapTo_SineAmplitude(self, data):
     initial = data['initial']
     amplitude = data['amplitude']
     period = data['period']
-    return SineAmplitude(initial, amplitude, period)
+    units = data['units']
+    return SineAmplitude(units, initial, amplitude, period)
 
 factoryObject = ObjectFactory()

peregrine/iqgen/bits/amplitude_poly.py

@@ -24,15 +24,15 @@ class AmplitudePoly(AmplitudeBase):
   Amplitude control with polynomial dependency over time.
   '''
 
-  def __init__(self, coeffs):
+  def __init__(self, units, coeffs):
     '''
     Constructs polynomial amplitude control object.
 
     Parameters
     coeffs : array-like
       Polynomial coefficients
     '''
-    super(AmplitudePoly, self).__init__()
+    super(AmplitudePoly, self).__init__(units)
 
     self.coeffs = tuple([x for x in coeffs])
     if len(coeffs) > 0:
@@ -49,9 +49,9 @@ def __str__(self):
     string
       Literal presentation of object
     '''
-    return "AmplitudePoly(c={})".format(self.coeffs)
+    return "AmplitudePoly(units={}, c={})".format(self.units, self.coeffs)
 
-  def applyAmplitude(self, signal, userTimeAll_s):
+  def applyAmplitude(self, signal, userTimeAll_s, noiseParams):
     '''
     Applies amplitude modulation to signal.
 
@@ -64,6 +64,8 @@ def applyAmplitude(self, signal, userTimeAll_s):
       [-1; +1]. This vector is modified in place.
     userTimeAll_s : numpy.ndarray
       Sample time vector. Each element defines sample time in seconds.
+    noiseParams : NoiseParameters
+      Noise parameters to adjust signal amplitude level.
 
     Returns
     -------
@@ -74,22 +76,34 @@ def applyAmplitude(self, signal, userTimeAll_s):
     poly = self.poly
     if poly is not None:
       amplitudeVector = poly(userTimeAll_s)
+      amplitudeVector = AmplitudeBase.convertUnits2Amp(amplitudeVector,
+                                                       self.units,
+                                                       noiseParams)
       signal *= amplitudeVector
+    else:
+      amplitude = AmplitudeBase.convertUnits2Amp(1.,
+                                                 self.units,
+                                                 noiseParams)
+      signal *= amplitude
 
     return signal
 
-  def computeMeanPower(self):
+  def computeSNR(self, noiseParams):
     '''
-    Computes mean signal power.
+    Computes signal to noise ratio in dB.
+
+    noiseParams : NoiseParameters
+      Noise parameter container
 
     Returns
     -------
     float
-      Mean signal power for the configured amplitude
+      SNR in dB
     '''
     poly = self.poly
     if poly is not None:
-      result = numpy.square(poly(0.))
+      value = poly(0.)
     else:
-      result = 1.
-    return result
+      value = 1.
+
+    return AmplitudeBase.convertUnits2SNR(value, self.units, noiseParams)