128 lines
3.4 KiB
Python
128 lines
3.4 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: UTF_8 -*-
|
|
|
|
from math import pow
|
|
|
|
APF06_RECEPTION_CHAIN_CONSTANT_GAIN = 14.6 # dB
|
|
APF06_GAIN_CODE_RATIO = 1.5e-3 # dB/quantum
|
|
|
|
APF06_CODE_MAX_APPLIED = 32767
|
|
APF06_CODE_MAX_USER = 65535
|
|
APF06_CODE_MIN_USER = -65535
|
|
APF06_CODE_MIN_APPLIED = 1280
|
|
|
|
|
|
def convert_dB_m2code(_gain_dB, _r_dvol):
|
|
"""Conversion of gain slope a1 (in dB) to code ca1.
|
|
(difference with APF04 : 4 bits shift is not used)
|
|
|
|
Args:
|
|
_gain_dB(float): gain slope in dB/m
|
|
_r_dvol(float): inter-volume size in m
|
|
|
|
Returns:
|
|
code (int)
|
|
"""
|
|
code = int(round((_gain_dB * _r_dvol) / APF06_GAIN_CODE_RATIO, 1))
|
|
code = _truncate(code, APF06_CODE_MAX_USER, APF06_CODE_MIN_USER)
|
|
return code
|
|
|
|
|
|
def convert_code2dB_m(_code, _r_dvol):
|
|
"""Conversion of any code ca1 to gain slope a1 (in dB)
|
|
(difference with APF04 : 4 bits shift is not used)
|
|
|
|
Args:
|
|
_code(int): gain code
|
|
_r_dvol(float): inter-volume size in m
|
|
|
|
Returns:
|
|
gain slope in dB/m (float)
|
|
"""
|
|
gain_dB = (APF06_GAIN_CODE_RATIO / _r_dvol) * _code
|
|
return gain_dB
|
|
|
|
|
|
def convert_dB2code(_gain_dB):
|
|
"""Conversion of gain (in dB) to code.
|
|
The code is truncated in the available range.
|
|
|
|
Args:
|
|
_gain_dB(float): gain intercept in dB
|
|
|
|
Returns:
|
|
gain code (int)
|
|
"""
|
|
code = int(round((_gain_dB - APF06_RECEPTION_CHAIN_CONSTANT_GAIN) / APF06_GAIN_CODE_RATIO, 1))
|
|
code = _truncate(code, APF06_CODE_MAX_APPLIED, APF06_CODE_MIN_USER)
|
|
return code
|
|
|
|
|
|
def convert_code2dB(_code):
|
|
"""Conversion of any code to a theoretical gain (in dB)
|
|
|
|
Args:
|
|
_code(int): gain code
|
|
|
|
Returns:
|
|
gain intercept in dB (float)
|
|
"""
|
|
gain_dB = (_code * APF06_GAIN_CODE_RATIO) + APF06_RECEPTION_CHAIN_CONSTANT_GAIN
|
|
return gain_dB
|
|
|
|
|
|
def _convert_code2dB_trunc(_code):
|
|
"""Conversion of code to the effective (truncated) gain (in dB) applied in a cell
|
|
|
|
Args :
|
|
_code (int) : gain code
|
|
|
|
Returns :
|
|
gain in dB applied in a cell
|
|
"""
|
|
_code = _truncate(_code, APF06_CODE_MAX_APPLIED, APF06_CODE_MIN_APPLIED)
|
|
gain_dB = convert_code2dB(_code)
|
|
return gain_dB
|
|
|
|
|
|
def calc_gain(_n_vol, _gain_ca0, _gain_ca1, _gain_max_ca0, _gain_max_ca1):
|
|
"""Compute the table of the gains in dB applied to each cell of the profile
|
|
(difference with APF04 : 4 bits shift is not used)
|
|
|
|
Args:
|
|
_n_vol(int): number of cells in the profile
|
|
_gain_ca0(int): code of the gain intercept
|
|
_gain_ca1(int): code of the gain slope
|
|
_gain_max_ca0(int): code of the blind zone gain limit intercept
|
|
_gain_max_ca1(int): code of the blind zone gain limit slope
|
|
|
|
Returns:
|
|
list of gains in dB to apply to each cell of the profile
|
|
|
|
"""
|
|
tab_gain = []
|
|
i = 0
|
|
while i <= (_n_vol - 1):
|
|
G = _convert_code2dB_trunc(_gain_ca0 + i * _gain_ca1)
|
|
G_max = _convert_code2dB_trunc(_gain_max_ca0 + i * _gain_max_ca1)
|
|
if (G >= G_max):
|
|
tab_gain.append(pow(10, G_max / 20.))
|
|
else:
|
|
tab_gain.append(pow(10, G / 20.))
|
|
i = i + 1
|
|
return tab_gain
|
|
|
|
|
|
def _truncate(value, limit_max, limit_min):
|
|
"""Troncate value with min/max limit
|
|
|
|
Args:
|
|
value: value to troncate
|
|
limit_max: max limit
|
|
limit_min: min limit
|
|
|
|
Returns:
|
|
the truncated value
|
|
"""
|
|
return max(min(value, limit_max), limit_min)
|