643 lines
27 KiB
Python
643 lines
27 KiB
Python
import numpy as np
|
|
import copy
|
|
try:
|
|
from .filtering_utils import buttmat
|
|
except ImportError:
|
|
from filtering_utils import buttmat
|
|
|
|
|
|
def digfilt(B, A, Bst, Ast, x, xstat, avgmem, init):
|
|
y = np.array([])
|
|
ystat = 0
|
|
|
|
if x.ndim > 1 and min(x.shape) > 1:
|
|
raise ValueError('digfilt.m: min(size(x)) > 1!')
|
|
else:
|
|
x = x.ravel()
|
|
|
|
if len(A) < 3 or len(B) < 3:
|
|
raise ValueError('digfilt.m: (length(A) < 3) || (length(B) < 3)')
|
|
|
|
if init.get('st', False) or avgmem is None or not avgmem:
|
|
old_startup = avgmem.get('startup_percent') if isinstance(avgmem, dict) else None
|
|
old_loop = avgmem.get('loop') if isinstance(avgmem, dict) else None
|
|
avgmem = {}
|
|
if old_startup is not None:
|
|
avgmem['startup_percent'] = old_startup
|
|
if old_loop is not None:
|
|
avgmem['loop'] = old_loop
|
|
avgmem['xold'] = np.array([])
|
|
avgmem['yold'] = np.array([])
|
|
avgmem['xstold'] = np.array([])
|
|
avgmem['ystold'] = np.array([])
|
|
avgmem['true_st'] = np.array([])
|
|
avgmem['oldsinglestatus'] = np.array([])
|
|
|
|
if xstat.ndim > 1 and min(xstat.shape) > 1:
|
|
raise ValueError('digfilt.m: min(size(xstat)) > 1')
|
|
else:
|
|
xstat = xstat.ravel()
|
|
ystat = np.zeros(len(xstat))
|
|
|
|
if len(x) == 0:
|
|
xstat = np.zeros(len(xstat))
|
|
|
|
memempty = (len(avgmem.get('xold', [])) == 0 or len(avgmem.get('xstold', [])) == 0 or len(avgmem.get('true_st', [])) == 0)
|
|
mememptyst = (len(avgmem.get('xold', [])) == 0 or len(avgmem.get('xstold', [])) == 0)
|
|
|
|
if not (memempty and len(x) == 0):
|
|
rowx = len(x) if x.ndim == 1 else x.shape[0]
|
|
|
|
init_Filt = (init.get('st', False) or memempty or
|
|
(len(x) > 0 and rowx != len(avgmem.get('yold', []))))
|
|
|
|
init_Filtst = (init.get('st', False) or mememptyst or
|
|
(len(x) > 0 and rowx != len(avgmem.get('yold', []))))
|
|
|
|
if init_Filt:
|
|
if init.get('typ', 1) == 2:
|
|
avgmem['xold'] = init.get('val', 0) * np.ones((rowx, 2))
|
|
avgmem['yold'] = init.get('val', 0) * np.ones((rowx, 2))
|
|
else:
|
|
avgmem['xold'] = np.zeros((rowx, 2))
|
|
avgmem['yold'] = np.zeros((rowx, 2))
|
|
avgmem['xold'][:, 0] = x[0] * xstat[0] * np.ones(rowx)
|
|
avgmem['yold'][:, 0] = x[0] * xstat[0] * np.ones(rowx)
|
|
avgmem['xold'][:, 1] = avgmem['xold'][:, 0]
|
|
avgmem['yold'][:, 1] = avgmem['yold'][:, 0]
|
|
if xstat[0]:
|
|
avgmem['true_st'] = np.array([1])
|
|
else:
|
|
avgmem['true_st'] = np.array([])
|
|
|
|
if not xstat[0]:
|
|
x = avgmem['yold'][:, 0].copy()
|
|
|
|
y = B[0] * x + B[1] * avgmem['xold'][:, 0] + B[2] * avgmem['xold'][:, 1] - A[1] * avgmem['yold'][:, 0] - A[2] * avgmem['yold'][:, 1]
|
|
|
|
avgmem['xold'] = np.column_stack([x, avgmem['xold'][:, 0]])
|
|
avgmem['yold'] = np.column_stack([y, avgmem['yold'][:, 0]])
|
|
|
|
if init_Filtst:
|
|
stval = init.get('stval', [0, 1])
|
|
if len(stval) == 2 and len(xstat) == 2:
|
|
avgmem['xstold'] = np.zeros((len(xstat), 2))
|
|
avgmem['ystold'] = np.zeros((len(xstat), 2))
|
|
avgmem['xstold'][0, :] = xstat[0] * stval[0] * np.ones(2)
|
|
avgmem['ystold'][0, :] = xstat[0] * stval[0] * np.ones(2)
|
|
avgmem['xstold'][1, :] = stval[1] * np.ones(2)
|
|
avgmem['ystold'][1, :] = stval[1] * np.ones(2)
|
|
else:
|
|
avgmem['xstold'] = xstat[0] * stval[0] * np.ones((len(xstat), 2))
|
|
avgmem['ystold'] = xstat[0] * stval[0] * np.ones((len(xstat), 2))
|
|
|
|
ystat = Bst[0] * xstat + Bst[1] * avgmem['xstold'][:, 0] + Bst[2] * avgmem['xstold'][:, 1] - Ast[1] * avgmem['ystold'][:, 0] - Ast[2] * avgmem['ystold'][:, 1]
|
|
|
|
avgmem['xstold'] = np.column_stack([xstat, avgmem['xstold'][:, 0]])
|
|
avgmem['ystold'] = np.column_stack([ystat, avgmem['ystold'][:, 0]])
|
|
|
|
return y, ystat, avgmem
|
|
|
|
|
|
def fpara(Status, initin, avgn, avgmem, xray8k):
|
|
errorl = np.zeros(2)
|
|
|
|
if avgmem is None or not avgmem or initin:
|
|
old_startup = avgmem.get('startup_percent') if isinstance(avgmem, dict) else None
|
|
avgmem = {}
|
|
if old_startup is not None:
|
|
avgmem['startup_percent'] = old_startup
|
|
avgmem['loop'] = np.array([])
|
|
avgmem['xold'] = np.array([])
|
|
avgmem['yold'] = np.array([])
|
|
avgmem['xstold'] = np.array([])
|
|
avgmem['ystold'] = np.array([])
|
|
avgmem['true_st'] = np.array([])
|
|
avgmem['oldsinglestatus'] = np.array([])
|
|
|
|
if initin or len(avgmem.get('loop', [])) == 0:
|
|
avgmem['loop'] = np.array([1])
|
|
elif Status:
|
|
if avgmem['loop'][0] != 65535:
|
|
avgmem['loop'][0] = avgmem['loop'][0] + 1
|
|
|
|
if avgmem['loop'][0] < avgn:
|
|
fgn = 1 / avgmem['loop'][0]
|
|
else:
|
|
fgn = 1 / avgn
|
|
|
|
B, A, errorl[1] = buttmat(fgn)
|
|
filterr = errorl[1] > 0
|
|
|
|
if xray8k:
|
|
Bst = B.copy()
|
|
Ast = A.copy()
|
|
else:
|
|
Bst, Ast, _ = buttmat(1 / avgn)
|
|
|
|
return B, A, Bst, Ast, avgmem, filterr
|
|
|
|
|
|
def statuscheck2(avgvalue, avgstatus, singlestatus, insens,
|
|
filterr, startup_percent, warninginsens, setupfailure, avgmem):
|
|
StWait = 249
|
|
StDefault = 255
|
|
StFilterr = 70
|
|
avgoutvalue = np.zeros_like(avgvalue)
|
|
avgoutstatus = np.zeros(3)
|
|
avgoutstatus[2] = (1 - avgstatus[0]) * 100
|
|
if avgoutstatus[2] < 0:
|
|
avgoutstatus[2] = 0
|
|
if avgoutstatus[2] > 100:
|
|
avgoutstatus[2] = 100
|
|
|
|
if warninginsens is None or (isinstance(warninginsens, (list, np.ndarray)) and len(warninginsens) == 0):
|
|
warninginsens = insens
|
|
|
|
if avgmem is None or len(avgmem.get('oldsinglestatus', [])) == 0:
|
|
avgmem['oldsinglestatus'] = np.array(singlestatus, dtype=float)
|
|
|
|
if singlestatus[0]:
|
|
avgmem['oldsinglestatus'][0] = singlestatus[0]
|
|
if len(singlestatus) == 2 and singlestatus[1]:
|
|
avgmem['oldsinglestatus'][1] = singlestatus[1]
|
|
|
|
if avgstatus[0] > (1 - insens / 100):
|
|
avgoutvalue = avgvalue.copy()
|
|
avgoutstatus[0] = 0
|
|
else:
|
|
avgoutvalue = avgvalue.copy()
|
|
if setupfailure:
|
|
avgoutstatus[0] = avgmem['oldsinglestatus'][0]
|
|
elif startup_percent < 100:
|
|
avgoutstatus[0] = StWait
|
|
else:
|
|
if avgmem['oldsinglestatus'][0]:
|
|
avgoutstatus[0] = avgmem['oldsinglestatus'][0]
|
|
else:
|
|
avgoutstatus[0] = StDefault
|
|
|
|
avgoutstatus[1] = 0
|
|
length2 = (len(avgstatus) == 2 and len(avgmem.get('oldsinglestatus', [])) == 2)
|
|
|
|
if startup_percent > 98:
|
|
if avgstatus[0] < (1 - warninginsens / 100) and not avgoutstatus[0]:
|
|
avgoutstatus[1] = avgmem['oldsinglestatus'][0]
|
|
elif length2 and avgstatus[1] < (1 - warninginsens / 100) and avgmem['oldsinglestatus'][1]:
|
|
avgoutstatus[1] = -avgmem['oldsinglestatus'][1]
|
|
elif filterr:
|
|
avgoutstatus[1] = -StFilterr
|
|
|
|
return avgoutvalue, avgoutstatus, avgmem
|
|
|
|
|
|
def _avg_result_pair(result_a, result_b):
|
|
result_a = np.asarray(result_a, dtype=np.float64).ravel()
|
|
result_b = np.asarray(result_b, dtype=np.float64).ravel()
|
|
out = np.ones(3) * 255
|
|
if len(result_a) >= 3 and len(result_b) >= 3:
|
|
if not result_a[1] and not result_b[1]:
|
|
out[0] = (result_a[0] + result_b[0]) / 2
|
|
out[1] = 0
|
|
out[2] = result_a[2]
|
|
elif not result_a[1] and result_b[1]:
|
|
out[0] = result_a[0]
|
|
out[1] = 0
|
|
out[2] = result_a[2]
|
|
elif result_a[1] and not result_b[1]:
|
|
out[0] = result_b[0]
|
|
out[1] = 0
|
|
out[2] = result_b[2]
|
|
else:
|
|
out[0] = 0
|
|
out[1] = result_a[1]
|
|
out[2] = result_a[2]
|
|
return out
|
|
|
|
|
|
def avg_ab(tmp, conf):
|
|
dmOut = _avg_result_pair(tmp['results']['dmOut']['a'], tmp['results']['dmOut']['b'])
|
|
|
|
oscL = _avg_result_pair(tmp['results']['left']['osc']['a'], tmp['results']['left']['osc']['b'])
|
|
oscR = _avg_result_pair(tmp['results']['right']['osc']['a'], tmp['results']['right']['osc']['b'])
|
|
|
|
isoL = _avg_result_pair(tmp['results']['left']['iso']['a'], tmp['results']['left']['iso']['b'])
|
|
isoR = _avg_result_pair(tmp['results']['right']['iso']['a'], tmp['results']['right']['iso']['b'])
|
|
|
|
iscL = _avg_result_pair(tmp['results']['left']['isc']['a'], tmp['results']['left']['isc']['b'])
|
|
iscR = _avg_result_pair(tmp['results']['right']['isc']['a'], tmp['results']['right']['isc']['b'])
|
|
|
|
coreDm = _avg_result_pair(tmp['results']['coreDm']['a'], tmp['results']['coreDm']['b'])
|
|
|
|
wthL = _avg_result_pair(tmp['results']['left']['wth']['a'], tmp['results']['left']['wth']['b'])
|
|
wthR = _avg_result_pair(tmp['results']['right']['wth']['a'], tmp['results']['right']['wth']['b'])
|
|
|
|
axis = {'a': tmp['results']['a'], 'b': tmp['results']['b']}
|
|
|
|
return dmOut, oscL, oscR, isoL, isoR, iscL, iscR, coreDm, wthL, wthR, axis
|
|
|
|
|
|
def avg_mval_sub(in_dict, skip_startup=False):
|
|
if in_dict.get('status') is None or len(in_dict.get('status', [])) == 0:
|
|
results_arr = np.atleast_1d(np.asarray(in_dict['results'], dtype=float))
|
|
value = np.array([results_arr[0]])
|
|
status = results_arr[1:] if len(results_arr) > 1 else np.array([0.0])
|
|
else:
|
|
value = np.atleast_1d(np.asarray(in_dict['results'], dtype=float)).ravel()
|
|
status = in_dict['status']
|
|
|
|
status = np.atleast_1d(np.asarray(status, dtype=float))
|
|
setupfailure = ((status[0] >= 180 and status[0] <= 220) or (status[0] == 45))
|
|
|
|
avgmem = in_dict.get('avgmem', None)
|
|
if in_dict.get('init', {}).get('st', False) or avgmem is None or not avgmem:
|
|
avgmem = {}
|
|
if skip_startup:
|
|
avgmem['startup_percent'] = 100
|
|
else:
|
|
avgmem['startup_percent'] = 0
|
|
avgmem['loop'] = np.array([])
|
|
avgmem['xold'] = np.array([])
|
|
avgmem['yold'] = np.array([])
|
|
avgmem['xstold'] = np.array([])
|
|
avgmem['ystold'] = np.array([])
|
|
avgmem['true_st'] = np.array([])
|
|
avgmem['oldsinglestatus'] = np.array([])
|
|
|
|
if skip_startup:
|
|
avgmem['startup_percent'] = 100
|
|
|
|
if avgmem.get('startup_percent', 0) < 100 and not setupfailure:
|
|
avgmem['startup_percent'] = avgmem.get('startup_percent', 0) + 100 * in_dict['video_req_time'] / in_dict['meantime']
|
|
|
|
statusd = np.zeros(2)
|
|
statusd[0] = (status[0] == 0)
|
|
if len(status) > 1:
|
|
statusd[1] = (status[1] == 0)
|
|
|
|
B, A, Bst, Ast, avgmem, filterr = fpara(
|
|
statusd[0], in_dict['init']['st'],
|
|
(in_dict['meantime'] / in_dict['video_req_time']),
|
|
avgmem, in_dict['xray8k']
|
|
)
|
|
|
|
y, ystat, avgmem = digfilt(B, A, Bst, Ast, value, statusd, avgmem, in_dict['init'])
|
|
|
|
avgoutvalue, avgoutstatus, avgmem = statuscheck2(
|
|
y, ystat, status, in_dict['insens'], filterr,
|
|
avgmem.get('startup_percent', 0), in_dict.get('warninsens', in_dict['insens']),
|
|
setupfailure, avgmem
|
|
)
|
|
|
|
if in_dict.get('status') is None or len(in_dict.get('status', [])) == 0:
|
|
avgresults = np.concatenate([np.atleast_1d(avgoutvalue).ravel(), avgoutstatus.ravel()])
|
|
avgstatus_out = np.array([])
|
|
else:
|
|
avgresults = avgoutvalue
|
|
avgstatus_out = avgoutstatus
|
|
|
|
return avgresults, avgmem, avgstatus_out
|
|
|
|
|
|
def avg_mval(results, avgsettings, avgmem, eval_axis=2, cableType=0, err_meas_head=None):
|
|
if err_meas_head is None:
|
|
err_meas_head = np.zeros(2)
|
|
|
|
BOTH = 2
|
|
EVALX = 1
|
|
EVALY = 0
|
|
|
|
if avgsettings.get('init', 0) or avgmem is None or len(avgmem) == 0:
|
|
avgmem = {}
|
|
avgmem['dm'] = {'x': None, 'y': None}
|
|
for layer in ['osc', 'isc', 'iso', 'wth']:
|
|
avgmem['left'] = avgmem.get('left', {})
|
|
avgmem['right'] = avgmem.get('right', {})
|
|
avgmem['left'][layer] = {'x': None, 'y': None}
|
|
avgmem['right'][layer] = {'x': None, 'y': None}
|
|
avgmem['eightPT'] = copy.deepcopy(avgmem)
|
|
|
|
avgresults = {}
|
|
avgresults['dmOut'] = np.zeros((4, 2))
|
|
avgresults['coreDm'] = np.zeros((4, 2))
|
|
for layer in ['osc', 'isc', 'iso', 'wth']:
|
|
avgresults['left'] = avgresults.get('left', {})
|
|
avgresults['right'] = avgresults.get('right', {})
|
|
avgresults['left'][layer] = np.zeros((4, 2))
|
|
avgresults['right'][layer] = np.zeros((4, 2))
|
|
avgresults['eightPT'] = copy.deepcopy(avgresults)
|
|
|
|
StWait = 249
|
|
|
|
in_dict = {}
|
|
in_dict['init'] = {
|
|
'val': 0,
|
|
'stval': np.array([0, 1]),
|
|
'st': avgsettings.get('init', 0),
|
|
'typ': 1
|
|
}
|
|
in_dict['status'] = None
|
|
in_dict['err_meas_head'] = err_meas_head
|
|
in_dict['xray8k'] = avgsettings.get('xray8k', 0)
|
|
in_dict['meantime'] = avgsettings.get('mean_time_dm', 1.0)
|
|
in_dict['video_req_time'] = avgsettings.get('video_req_time', 0.04)
|
|
in_dict['insens'] = avgsettings.get('dia_insens', 5.0)
|
|
in_dict['warninsens'] = avgsettings.get('dia_warninsens', None)
|
|
|
|
if eval_axis == EVALX or eval_axis == BOTH:
|
|
in_dict['results'] = results['dmOut'][:, 0]
|
|
in_dict['avgmem'] = avgmem.get('dm', {}).get('x')
|
|
res, avgmem_dm_x, _ = avg_mval_sub(in_dict)
|
|
avgresults['dmOut'][:, 0] = res[:4] if len(res) >= 4 else res
|
|
avgmem['dm']['x'] = avgmem_dm_x
|
|
|
|
if eval_axis == EVALY or eval_axis == BOTH:
|
|
in_dict['results'] = results['dmOut'][:, 1]
|
|
in_dict['avgmem'] = avgmem.get('dm', {}).get('y')
|
|
res, avgmem_dm_y, _ = avg_mval_sub(in_dict)
|
|
avgresults['dmOut'][:, 1] = res[:4] if len(res) >= 4 else res
|
|
avgmem['dm']['y'] = avgmem_dm_y
|
|
|
|
in_dict['meantime'] = avgsettings.get('mean_time_lay', 1.0)
|
|
in_dict['insens'] = avgsettings.get('lay_insens', 5.0)
|
|
in_dict['warninsens'] = avgsettings.get('lay_warninsens', None)
|
|
|
|
for layer in ['osc', 'isc', 'iso']:
|
|
if eval_axis == EVALX or eval_axis == BOTH:
|
|
in_dict['results'] = results['left'][layer][:, 0]
|
|
in_dict['avgmem'] = avgmem['left'][layer].get('x')
|
|
res, new_mem, _ = avg_mval_sub(in_dict)
|
|
avgresults['left'][layer][:, 0] = res[:4] if len(res) >= 4 else res
|
|
avgmem['left'][layer]['x'] = new_mem
|
|
|
|
in_dict['results'] = results['right'][layer][:, 0]
|
|
in_dict['avgmem'] = avgmem['right'][layer].get('x')
|
|
res, new_mem, _ = avg_mval_sub(in_dict)
|
|
avgresults['right'][layer][:, 0] = res[:4] if len(res) >= 4 else res
|
|
avgmem['right'][layer]['x'] = new_mem
|
|
|
|
if eval_axis == EVALY or eval_axis == BOTH:
|
|
in_dict['results'] = results['left'][layer][:, 1]
|
|
in_dict['avgmem'] = avgmem['left'][layer].get('y')
|
|
res, new_mem, _ = avg_mval_sub(in_dict)
|
|
avgresults['left'][layer][:, 1] = res[:4] if len(res) >= 4 else res
|
|
avgmem['left'][layer]['y'] = new_mem
|
|
|
|
in_dict['results'] = results['right'][layer][:, 1]
|
|
in_dict['avgmem'] = avgmem['right'][layer].get('y')
|
|
res, new_mem, _ = avg_mval_sub(in_dict)
|
|
avgresults['right'][layer][:, 1] = res[:4] if len(res) >= 4 else res
|
|
avgmem['right'][layer]['y'] = new_mem
|
|
|
|
in_dict['meantime'] = avgsettings.get('mean_time_dm', 1.0)
|
|
in_dict['insens'] = avgsettings.get('dia_insens', 5.0)
|
|
in_dict['warninsens'] = avgsettings.get('dia_warninsens', None)
|
|
|
|
for side in ['left', 'right']:
|
|
if eval_axis == EVALX or eval_axis == BOTH:
|
|
in_dict['results'] = results[side]['wth'][:, 0]
|
|
in_dict['avgmem'] = avgmem[side]['wth'].get('x')
|
|
res, new_mem, _ = avg_mval_sub(in_dict)
|
|
avgresults[side]['wth'][:, 0] = res[:4] if len(res) >= 4 else res
|
|
avgmem[side]['wth']['x'] = new_mem
|
|
|
|
if eval_axis == EVALY or eval_axis == BOTH:
|
|
in_dict['results'] = results[side]['wth'][:, 1]
|
|
in_dict['avgmem'] = avgmem[side]['wth'].get('y')
|
|
res, new_mem, _ = avg_mval_sub(in_dict)
|
|
avgresults[side]['wth'][:, 1] = res[:4] if len(res) >= 4 else res
|
|
avgmem[side]['wth']['y'] = new_mem
|
|
|
|
avgresults['coreDm'] = np.zeros((4, 2))
|
|
|
|
if (eval_axis == EVALX or eval_axis == BOTH) and cableType not in [62, 63]:
|
|
measvek = np.array([avgresults['dmOut'][0, 0], avgresults['left']['wth'][0, 0], avgresults['right']['wth'][0, 0]])
|
|
errvek = np.array([avgresults['dmOut'][1, 0], avgresults['left']['wth'][1, 0], avgresults['right']['wth'][1, 0]])
|
|
warnvek = np.array([avgresults['dmOut'][2, 0], avgresults['left']['wth'][2, 0], avgresults['right']['wth'][2, 0]])
|
|
|
|
core_wait = np.where(errvek == StWait)[0]
|
|
core_err = np.where(errvek != 0)[0]
|
|
core_warn = np.where(warnvek != 0)[0]
|
|
|
|
if len(core_err) == 0:
|
|
avgresults['coreDm'][0, 0] = avgresults['dmOut'][0, 0] - avgresults['left']['wth'][0, 0] - avgresults['right']['wth'][0, 0]
|
|
avgresults['coreDm'][1, 0] = 0
|
|
elif len(core_wait) > 0:
|
|
avgresults['coreDm'][0, 0] = measvek[core_wait[0]]
|
|
avgresults['coreDm'][1, 0] = errvek[core_wait[0]]
|
|
else:
|
|
avgresults['coreDm'][0, 0] = 0
|
|
avgresults['coreDm'][1, 0] = errvek[core_err[0]]
|
|
|
|
if len(core_warn) == 0:
|
|
avgresults['coreDm'][2, 0] = 0
|
|
else:
|
|
avgresults['coreDm'][2, 0] = warnvek[core_warn[0]]
|
|
|
|
avgresults['coreDm'][3, 0] = max([avgresults['dmOut'][3, 0], avgresults['left']['wth'][3, 0], avgresults['right']['wth'][3, 0]])
|
|
else:
|
|
avgresults['coreDm'][0:2, 0] = results['coreDm'][0:2, 0]
|
|
|
|
if (eval_axis == EVALY or eval_axis == BOTH) and cableType not in [62, 63]:
|
|
measvek = np.array([avgresults['dmOut'][0, 1], avgresults['left']['wth'][0, 1], avgresults['right']['wth'][0, 1]])
|
|
errvek = np.array([avgresults['dmOut'][1, 1], avgresults['left']['wth'][1, 1], avgresults['right']['wth'][1, 1]])
|
|
warnvek = np.array([avgresults['dmOut'][2, 1], avgresults['left']['wth'][2, 1], avgresults['right']['wth'][2, 1]])
|
|
|
|
core_wait = np.where(errvek == StWait)[0]
|
|
core_err = np.where(errvek != 0)[0]
|
|
core_warn = np.where(warnvek != 0)[0]
|
|
|
|
if len(core_err) == 0:
|
|
avgresults['coreDm'][0, 1] = avgresults['dmOut'][0, 1] - avgresults['left']['wth'][0, 1] - avgresults['right']['wth'][0, 1]
|
|
avgresults['coreDm'][1, 1] = 0
|
|
elif len(core_wait) > 0:
|
|
avgresults['coreDm'][0, 1] = measvek[core_wait[0]]
|
|
avgresults['coreDm'][1, 1] = errvek[core_wait[0]]
|
|
else:
|
|
avgresults['coreDm'][0, 1] = 0
|
|
avgresults['coreDm'][1, 1] = errvek[core_err[0]]
|
|
|
|
if len(core_warn) == 0:
|
|
avgresults['coreDm'][2, 1] = 0
|
|
else:
|
|
avgresults['coreDm'][2, 1] = warnvek[core_warn[0]]
|
|
|
|
avgresults['coreDm'][3, 1] = max([avgresults['dmOut'][3, 1], avgresults['left']['wth'][3, 1], avgresults['right']['wth'][3, 1]])
|
|
else:
|
|
avgresults['coreDm'][0:2, 1] = results['coreDm'][0:2, 1]
|
|
|
|
return avgresults, avgmem
|
|
|
|
|
|
def avg_mval_8pt(results, avgsettings, avgmem, eval_axis=2, cableType=0, err_meas_head=None):
|
|
if err_meas_head is None:
|
|
err_meas_head = np.zeros(2)
|
|
|
|
avgsettings = dict(avgsettings)
|
|
avgsettings['mean_time_dm'] = avgsettings.get('mean_time_lay', 1.0)
|
|
avgsettings['dia_insens'] = avgsettings.get('lay_insens', 5.0)
|
|
avgsettings['dia_warninsens'] = avgsettings.get('lay_warninsens', None)
|
|
|
|
BOTH = 2
|
|
EVALX = 1
|
|
EVALY = 0
|
|
|
|
if avgsettings.get('init', 0) or avgmem is None or len(avgmem) == 0:
|
|
avgmem = {}
|
|
avgmem['dm'] = {'x': None, 'y': None}
|
|
for layer in ['osc', 'isc', 'iso', 'wth']:
|
|
avgmem['left'] = avgmem.get('left', {})
|
|
avgmem['right'] = avgmem.get('right', {})
|
|
avgmem['left'][layer] = {'x': None, 'y': None}
|
|
avgmem['right'][layer] = {'x': None, 'y': None}
|
|
|
|
avgresults = {}
|
|
avgresults['dmOut'] = np.zeros((4, 2))
|
|
avgresults['coreDm'] = np.zeros((4, 2))
|
|
for layer in ['osc', 'isc', 'iso', 'wth']:
|
|
avgresults['left'] = avgresults.get('left', {})
|
|
avgresults['right'] = avgresults.get('right', {})
|
|
avgresults['left'][layer] = np.zeros((4, 2))
|
|
avgresults['right'][layer] = np.zeros((4, 2))
|
|
|
|
StWait = 249
|
|
|
|
in_dict = {}
|
|
in_dict['init'] = {
|
|
'val': 0,
|
|
'stval': np.array([0, 1]),
|
|
'st': avgsettings.get('init', 0),
|
|
'typ': 1
|
|
}
|
|
in_dict['status'] = None
|
|
in_dict['err_meas_head'] = err_meas_head
|
|
in_dict['xray8k'] = avgsettings.get('xray8k', 0)
|
|
in_dict['meantime'] = avgsettings.get('mean_time_dm', 1.0)
|
|
in_dict['video_req_time'] = avgsettings.get('video_req_time', 0.04)
|
|
in_dict['insens'] = avgsettings.get('dia_insens', 5.0)
|
|
in_dict['warninsens'] = avgsettings.get('dia_warninsens', None)
|
|
|
|
if eval_axis == EVALX or eval_axis == BOTH:
|
|
in_dict['results'] = results['dmOut'][:, 0]
|
|
in_dict['avgmem'] = avgmem.get('dm', {}).get('x')
|
|
res, avgmem_dm_x, _ = avg_mval_sub(in_dict, skip_startup=True)
|
|
avgresults['dmOut'][:, 0] = res[:4] if len(res) >= 4 else res
|
|
avgmem['dm']['x'] = avgmem_dm_x
|
|
|
|
if eval_axis == EVALY or eval_axis == BOTH:
|
|
in_dict['results'] = results['dmOut'][:, 1]
|
|
in_dict['avgmem'] = avgmem.get('dm', {}).get('y')
|
|
res, avgmem_dm_y, _ = avg_mval_sub(in_dict, skip_startup=True)
|
|
avgresults['dmOut'][:, 1] = res[:4] if len(res) >= 4 else res
|
|
avgmem['dm']['y'] = avgmem_dm_y
|
|
|
|
in_dict['meantime'] = avgsettings.get('mean_time_lay', 1.0)
|
|
in_dict['insens'] = avgsettings.get('lay_insens', 5.0)
|
|
in_dict['warninsens'] = avgsettings.get('lay_warninsens', None)
|
|
|
|
for layer in ['osc', 'isc', 'iso']:
|
|
if eval_axis == EVALX or eval_axis == BOTH:
|
|
in_dict['results'] = results['left'][layer][:, 0]
|
|
in_dict['avgmem'] = avgmem['left'][layer].get('x')
|
|
res, new_mem, _ = avg_mval_sub(in_dict, skip_startup=True)
|
|
avgresults['left'][layer][:, 0] = res[:4] if len(res) >= 4 else res
|
|
avgmem['left'][layer]['x'] = new_mem
|
|
|
|
in_dict['results'] = results['right'][layer][:, 0]
|
|
in_dict['avgmem'] = avgmem['right'][layer].get('x')
|
|
res, new_mem, _ = avg_mval_sub(in_dict, skip_startup=True)
|
|
avgresults['right'][layer][:, 0] = res[:4] if len(res) >= 4 else res
|
|
avgmem['right'][layer]['x'] = new_mem
|
|
|
|
if eval_axis == EVALY or eval_axis == BOTH:
|
|
in_dict['results'] = results['left'][layer][:, 1]
|
|
in_dict['avgmem'] = avgmem['left'][layer].get('y')
|
|
res, new_mem, _ = avg_mval_sub(in_dict, skip_startup=True)
|
|
avgresults['left'][layer][:, 1] = res[:4] if len(res) >= 4 else res
|
|
avgmem['left'][layer]['y'] = new_mem
|
|
|
|
in_dict['results'] = results['right'][layer][:, 1]
|
|
in_dict['avgmem'] = avgmem['right'][layer].get('y')
|
|
res, new_mem, _ = avg_mval_sub(in_dict, skip_startup=True)
|
|
avgresults['right'][layer][:, 1] = res[:4] if len(res) >= 4 else res
|
|
avgmem['right'][layer]['y'] = new_mem
|
|
|
|
in_dict['meantime'] = avgsettings.get('mean_time_dm', 1.0)
|
|
in_dict['insens'] = avgsettings.get('dia_insens', 5.0)
|
|
in_dict['warninsens'] = avgsettings.get('dia_warninsens', None)
|
|
|
|
for side in ['left', 'right']:
|
|
if eval_axis == EVALX or eval_axis == BOTH:
|
|
in_dict['results'] = results[side]['wth'][:, 0]
|
|
in_dict['avgmem'] = avgmem[side]['wth'].get('x')
|
|
res, new_mem, _ = avg_mval_sub(in_dict, skip_startup=True)
|
|
avgresults[side]['wth'][:, 0] = res[:4] if len(res) >= 4 else res
|
|
avgmem[side]['wth']['x'] = new_mem
|
|
|
|
if eval_axis == EVALY or eval_axis == BOTH:
|
|
in_dict['results'] = results[side]['wth'][:, 1]
|
|
in_dict['avgmem'] = avgmem[side]['wth'].get('y')
|
|
res, new_mem, _ = avg_mval_sub(in_dict, skip_startup=True)
|
|
avgresults[side]['wth'][:, 1] = res[:4] if len(res) >= 4 else res
|
|
avgmem[side]['wth']['y'] = new_mem
|
|
|
|
avgresults['coreDm'] = np.zeros((4, 2))
|
|
|
|
if (eval_axis == EVALX or eval_axis == BOTH) and cableType not in [62, 63]:
|
|
measvek = np.array([avgresults['dmOut'][0, 0], avgresults['left']['wth'][0, 0], avgresults['right']['wth'][0, 0]])
|
|
errvek = np.array([avgresults['dmOut'][1, 0], avgresults['left']['wth'][1, 0], avgresults['right']['wth'][1, 0]])
|
|
warnvek = np.array([avgresults['dmOut'][2, 0], avgresults['left']['wth'][2, 0], avgresults['right']['wth'][2, 0]])
|
|
|
|
core_wait = np.where(errvek == StWait)[0]
|
|
core_err = np.where(errvek != 0)[0]
|
|
core_warn = np.where(warnvek != 0)[0]
|
|
|
|
if len(core_err) == 0:
|
|
avgresults['coreDm'][0, 0] = avgresults['dmOut'][0, 0] - avgresults['left']['wth'][0, 0] - avgresults['right']['wth'][0, 0]
|
|
avgresults['coreDm'][1, 0] = 0
|
|
elif len(core_wait) > 0:
|
|
avgresults['coreDm'][0, 0] = measvek[core_wait[0]]
|
|
avgresults['coreDm'][1, 0] = errvek[core_wait[0]]
|
|
else:
|
|
avgresults['coreDm'][0, 0] = 0
|
|
avgresults['coreDm'][1, 0] = errvek[core_err[0]]
|
|
|
|
if len(core_warn) == 0:
|
|
avgresults['coreDm'][2, 0] = 0
|
|
else:
|
|
avgresults['coreDm'][2, 0] = warnvek[core_warn[0]]
|
|
|
|
avgresults['coreDm'][3, 0] = max([avgresults['dmOut'][3, 0], avgresults['left']['wth'][3, 0], avgresults['right']['wth'][3, 0]])
|
|
else:
|
|
avgresults['coreDm'][0:2, 0] = results['coreDm'][0:2, 0]
|
|
|
|
if (eval_axis == EVALY or eval_axis == BOTH) and cableType not in [62, 63]:
|
|
measvek = np.array([avgresults['dmOut'][0, 1], avgresults['left']['wth'][0, 1], avgresults['right']['wth'][0, 1]])
|
|
errvek = np.array([avgresults['dmOut'][1, 1], avgresults['left']['wth'][1, 1], avgresults['right']['wth'][1, 1]])
|
|
warnvek = np.array([avgresults['dmOut'][2, 1], avgresults['left']['wth'][2, 1], avgresults['right']['wth'][2, 1]])
|
|
|
|
core_wait = np.where(errvek == StWait)[0]
|
|
core_err = np.where(errvek != 0)[0]
|
|
core_warn = np.where(warnvek != 0)[0]
|
|
|
|
if len(core_err) == 0:
|
|
avgresults['coreDm'][0, 1] = avgresults['dmOut'][0, 1] - avgresults['left']['wth'][0, 1] - avgresults['right']['wth'][0, 1]
|
|
avgresults['coreDm'][1, 1] = 0
|
|
elif len(core_wait) > 0:
|
|
avgresults['coreDm'][0, 1] = measvek[core_wait[0]]
|
|
avgresults['coreDm'][1, 1] = errvek[core_wait[0]]
|
|
else:
|
|
avgresults['coreDm'][0, 1] = 0
|
|
avgresults['coreDm'][1, 1] = errvek[core_err[0]]
|
|
|
|
if len(core_warn) == 0:
|
|
avgresults['coreDm'][2, 1] = 0
|
|
else:
|
|
avgresults['coreDm'][2, 1] = warnvek[core_warn[0]]
|
|
|
|
avgresults['coreDm'][3, 1] = max([avgresults['dmOut'][3, 1], avgresults['left']['wth'][3, 1], avgresults['right']['wth'][3, 1]])
|
|
else:
|
|
avgresults['coreDm'][0:2, 1] = results['coreDm'][0:2, 1]
|
|
|
|
return avgresults, avgmem
|