Files
2026-07-30 18:46:32 +08:00

661 lines
23 KiB
Python

import numpy as np
import copy
try:
from .math_utils import ind, polyfit2
from .geometry_utils import strng2
except ImportError:
from math_utils import ind, polyfit2
from geometry_utils import strng2
try:
from .layer_calibration_utils import isofit, corefit
except ImportError:
from layer_calibration_utils import isofit, corefit
def statuscheck2(avgvalue, avgstatus, singlestatus, insens,
filterr, startup_percent, warninginsens, setupfailure, avgmem):
StWait = 249
StDefault = 255
StFilterr = 70
avgvalue = np.asarray(avgvalue, dtype=np.float64)
avgstatus = np.atleast_1d(np.asarray(avgstatus, dtype=np.float64)).ravel()
singlestatus = np.atleast_1d(np.asarray(singlestatus, dtype=np.float64)).ravel()
avgoutvalue = np.zeros_like(avgvalue)
avgoutstatus = np.zeros(3, dtype=np.float64)
if len(avgstatus) >= 1:
pct = (1.0 - avgstatus[0]) * 100.0
avgoutstatus[2] = max(0.0, min(100.0, pct))
if warninginsens is None or (isinstance(warninginsens, (list, np.ndarray)) and len(warninginsens) == 0):
warninginsens = insens
if 'oldsinglestatus' not in avgmem or avgmem['oldsinglestatus'] is None or (
isinstance(avgmem['oldsinglestatus'], (list, np.ndarray)) and len(avgmem['oldsinglestatus']) == 0):
avgmem['oldsinglestatus'] = singlestatus.copy()
if len(singlestatus) >= 1 and singlestatus[0]:
avgmem['oldsinglestatus'][0] = singlestatus[0]
if len(singlestatus) >= 2 and singlestatus[1]:
if len(avgmem['oldsinglestatus']) < 2:
avgmem['oldsinglestatus'] = np.pad(avgmem['oldsinglestatus'], (0, 1))
avgmem['oldsinglestatus'][1] = singlestatus[1]
if avgstatus[0] > (1.0 - insens / 100.0):
avgoutvalue = avgvalue.copy()
avgoutstatus[0] = 0
else:
if setupfailure:
avgoutstatus[0] = avgmem['oldsinglestatus'][0]
elif startup_percent < 100:
avgoutvalue[:] = np.round(startup_percent)
avgoutstatus[0] = StWait
else:
if avgmem['oldsinglestatus'][0]:
avgoutstatus[0] = avgmem['oldsinglestatus'][0]
else:
avgoutstatus[0] = StDefault
avgoutstatus[1] = 0
has_two = (len(avgstatus) == 2) and (len(avgmem['oldsinglestatus']) == 2)
if startup_percent > 98:
if avgstatus[0] < (1.0 - warninginsens / 100.0) and not avgoutstatus[0]:
avgoutstatus[1] = avgmem['oldsinglestatus'][0]
elif has_two and avgstatus[1] < (1.0 - warninginsens / 100.0) and avgmem['oldsinglestatus'][1]:
avgoutstatus[1] = -avgmem['oldsinglestatus'][1]
elif filterr:
avgoutstatus[1] = -StFilterr
return avgoutvalue, avgoutstatus, avgmem
def symlimit(symj, symj2, NOMJACK1, NOMJACK2):
if NOMJACK1 > 0 and NOMJACK2 > 0:
NOMJACK = min(NOMJACK1, NOMJACK2)
elif NOMJACK1 > 0:
NOMJACK = NOMJACK1
elif NOMJACK2 > 0:
NOMJACK = NOMJACK2
else:
NOMJACK = 0
if NOMJACK > 0:
if symj > NOMJACK:
symj = NOMJACK
if symj2 > NOMJACK:
symj2 = NOMJACK
return symj, symj2
def kcheck(IN, x0, x0r, xmeas, Dl, Dr, dx, Anzpara, Typ):
IN = np.asarray(IN, dtype=np.float64).ravel()
d0 = x0r - x0
if Typ == 'OSCL':
rr = int(ind(xmeas, dx))
ll = rr - 1
else:
rr = int(ind(xmeas, dx))
ll = int(ind(Dl, dx))
kl = 0.0
if Typ == 'DIAM':
if rr >= ll and ll >= 1 and rr <= len(IN):
seg = IN[ll - 1:rr]
seg = seg[seg > 0]
if len(seg) > 0:
kl = np.mean(-np.log(seg))
else:
x = (np.arange(ll - 1, rr) - 0) * dx
if len(x) >= 2 and x[0] > x0 and x[0] < x0r and x[-1] > x0 and x[-1] < x0r:
s1 = strng2(x, x0, x0r, 1)
seg = IN[ll - 1:rr]
valid = (seg > 0) & (s1 > 0)
if np.any(valid):
kl = np.mean(-np.log(seg[valid]) / s1[valid])
kr = None
if abs(kl) > 0:
if Typ == 'OSCR':
ll = int(ind(xmeas, dx))
rr = ll + 1
else:
ll = int(ind(xmeas, dx))
rr = int(ind(Dr, dx))
if Typ == 'DIAM':
if rr >= ll and ll >= 1 and rr <= len(IN):
seg = IN[ll - 1:rr]
seg = seg[seg > 0]
if len(seg) > 0:
kr = np.mean(-np.log(seg))
else:
x = (np.arange(ll - 1, rr)) * dx
if len(x) >= 2 and x[0] > x0 and x[0] < x0r and x[-1] > x0 and x[-1] < x0r:
s1 = strng2(x, x0, x0r, 1)
seg = IN[ll - 1:rr]
valid = (seg > 0) & (s1 > 0)
if np.any(valid):
kr = np.mean(-np.log(seg[valid]) / s1[valid])
if kr is not None:
Kontrast = kl - kr
else:
Kontrast = 0.0
return Kontrast
def kcheck2(IN, x0, x0r, xmeas, Dl, Dr, dx, Anzpara, Typ, xshift=0):
IN = np.asarray(IN, dtype=np.float64).ravel()
Kontrast = 0.0
Dae = 0.0
DaeGrad = 0.0
Apol = np.zeros(3, dtype=np.float64)
ll = int(ind(Dl, dx, xshift))
rr = int(ind(Dr, dx, xshift))
mitt = int(ind(xmeas, dx, xshift))
rangeflag = 0
d0 = x0r - x0
kl = 0.0
kr = 0.0
if ((mitt - ll) > 4) and ((rr - mitt) > 4) and (Dl > x0) and (Dl < x0r) and (Dr > x0) and (Dr < x0r):
if (Dl < (x0 + 0.5 * d0)) and (Dr < (x0 + 0.5 * d0)):
rangeflag = -1
rr_left = int(ind(xmeas, dx, xshift))
ll_left = int(ind(Dl, dx, xshift))
ivek = np.arange(1, rr_left - ll_left + 2)
jvek = ivek + (ll_left - 1)
jvek = jvek[jvek <= len(IN)]
xl2 = (jvek - 1) * dx + xshift
s1 = strng2(xl2, x0, x0r, 1)
seg_in = IN[jvek.astype(int) - 1]
valid = (seg_in > 0) & (s1 > 0)
if np.any(valid):
kl2 = -(np.log(seg_in[valid])) / s1[valid]
xl2_valid = xl2[valid]
if len(xl2_valid) >= 3:
A = polyfit2(xl2_valid, kl2, 2)
try:
kl = np.polyval(A, xmeas)
except Exception:
kl = np.mean(kl2)
A_lin = polyfit2(xl2_valid, kl2, 1)
DaeGrad = A_lin[0] if len(A_lin) >= 1 else 0.0
else:
kl = np.mean(kl2)
DaeGrad = 0.0
ll_right = int(ind(xmeas + dx, dx, xshift))
rr_right = int(ind(Dr, dx, xshift))
x1 = xmeas
x1r = x0r - (xmeas - x0)
ivek_r = np.arange(1, rr_right - ll_right + 2)
jvek_r = ivek_r + (ll_right - 1)
jvek_r = jvek_r[jvek_r <= len(IN)]
xr2 = (jvek_r - 1) * dx + xshift
s1_r = strng2(xr2, x0, x0r, 1)
s2_r = strng2(xr2, x1, x1r, 1)
seg_in_r = IN[jvek_r.astype(int) - 1]
valid_r = (seg_in_r > 0) & (s2_r > 0)
if np.any(valid_r):
kr2 = -(np.log(seg_in_r[valid_r]) + kl * (s1_r[valid_r] - s2_r[valid_r])) / s2_r[valid_r]
kr = np.mean(kr2)
Kontrast = kr - kl
Dae = kl
elif (Dl > (x0 + 0.5 * d0)) and (Dr > (x0 + 0.5 * d0)):
rangeflag = 1
rr_right = int(ind(Dr, dx, xshift))
ll_right = int(ind(xmeas, dx, xshift))
ivek_r = np.arange(1, rr_right - ll_right + 2)
jvek_r = ivek_r + (ll_right - 1)
jvek_r = jvek_r[jvek_r <= len(IN)]
xr2 = (jvek_r - 1) * dx + xshift
s1_r = strng2(xr2, x0, x0r, 1)
seg_in_r = IN[jvek_r.astype(int) - 1]
valid_r = (seg_in_r > 0) & (s1_r > 0)
if np.any(valid_r):
kr2 = -(np.log(seg_in_r[valid_r])) / s1_r[valid_r]
xr2_valid = xr2[valid_r]
if len(xr2_valid) >= 3:
A = polyfit2(xr2_valid, kr2, 2)
try:
kr = np.polyval(A, xmeas)
except Exception:
kr = np.mean(kr2)
Dae = kr
A_lin = polyfit2(xr2_valid, kr2, 1)
DaeGrad = -A_lin[0] if len(A_lin) >= 1 else 0.0
else:
kr = np.mean(kr2)
Dae = kr
DaeGrad = 0.0
ll_left = int(ind(Dl, dx, xshift))
rr_left = int(ind(xmeas - dx, dx, xshift))
x1 = x0 + (x0r - xmeas)
x1r = xmeas
ivek_l = np.arange(1, rr_left - ll_left + 2)
jvek_l = ivek_l + (ll_left - 1)
jvek_l = jvek_l[jvek_l <= len(IN)]
xl2 = (jvek_l - 1) * dx + xshift
s1_l = strng2(xl2, x0, x0r, 1)
s2_l = strng2(xl2, x1, x1r, 1)
seg_in_l = IN[jvek_l.astype(int) - 1]
valid_l = (seg_in_l > 0) & (s2_l > 0)
if np.any(valid_l):
kl2 = -(np.log(seg_in_l[valid_l]) + kr * (s1_l[valid_l] - s2_l[valid_l])) / s2_l[valid_l]
kl = np.mean(kl2)
Kontrast = kl - kr
Dae = kr
return Kontrast, Dae, DaeGrad, Apol
def _plausi_layer_sub(layer, minwarning, minerror, errornumber):
layer = np.asarray(layer, dtype=np.float64).ravel()
if layer[1] == 0:
if layer[0] < minerror:
layer[1] = errornumber
elif layer[0] < minwarning:
layer[2] = errornumber
return layer
def _errordep_layer_sub(indep_layer, dep_layer, errornumber):
indep_layer = np.asarray(indep_layer, dtype=np.float64).ravel()
dep_layer = np.asarray(dep_layer, dtype=np.float64).ravel()
if dep_layer[1] == 0 and indep_layer[1] == errornumber:
dep_layer[1] = indep_layer[1]
elif dep_layer[2] == 0 and indep_layer[2] == errornumber:
dep_layer[2] = indep_layer[2]
return dep_layer
def plausi_layer(inresults, settings):
ERR_OSC = 89
ERR_ISO = 88
ERR_ISC = 87
OSC_WARNING = 0.0
OSC_ERROR = 0.0
ISO_WARNING = 0.0
ISO_ERROR = 0.0
ISC_WARNING = 0.0
ISC_ERROR = 0.0
devicetype = None
try:
devicetype = settings.get('version', {}).get('devicetype', None)
except Exception:
pass
confData20 = None
try:
confData = settings.get('confData', None)
if confData is not None and len(np.atleast_1d(confData)) >= 20:
confData20 = float(np.atleast_1d(confData)[19])
except Exception:
pass
if devicetype in [8000, 8001, 8100, 8101]:
if confData20 == 111:
ISC_WARNING = 0.3
ISC_ERROR = 0.25
elif confData20 == 109:
ISO_WARNING = 0.7
ISO_ERROR = 0.6
elif confData20 in [115, 118]:
ISC_WARNING = 0.4
ISC_ERROR = 0.3
else:
if confData20 == 111:
ISC_WARNING = 0.5
ISC_ERROR = 0.4
elif confData20 == 109:
ISO_WARNING = 0.7
ISO_ERROR = 0.6
elif confData20 in [115, 118]:
ISC_WARNING = 0.4
ISC_ERROR = 0.3
try:
left_osc = inresults.get('left', {}).get('osc', np.zeros((3, 2)))
right_osc = inresults.get('right', {}).get('osc', np.zeros((3, 2)))
left_iso = inresults.get('left', {}).get('iso', np.zeros((3, 2)))
right_iso = inresults.get('right', {}).get('iso', np.zeros((3, 2)))
left_isc = inresults.get('left', {}).get('isc', np.zeros((3, 2)))
right_isc = inresults.get('right', {}).get('isc', np.zeros((3, 2)))
all_osc = np.concatenate([np.asarray(left_osc)[1, :], np.asarray(right_osc)[1, :]])
all_iso = np.concatenate([np.asarray(left_iso)[1, :], np.asarray(right_iso)[1, :]])
all_isc = np.concatenate([np.asarray(left_isc)[1, :], np.asarray(right_isc)[1, :]])
layeruse = [
not np.any(all_osc == 45),
not np.any(all_iso == 45),
not np.any(all_isc == 45)
]
except Exception:
layeruse = [True, True, True]
if OSC_WARNING > 0 or OSC_ERROR > 0:
for side in ['left', 'right']:
for col in range(2):
key = f'{side}_osc_{col}'
try:
layer = inresults[side]['osc'][:, col]
layer = _plausi_layer_sub(layer, OSC_WARNING, OSC_ERROR, ERR_OSC)
inresults[side]['osc'][:, col] = layer
except Exception:
pass
if ISO_WARNING > 0 or ISO_ERROR > 0:
for side in ['left', 'right']:
for col in range(2):
try:
layer = inresults[side]['iso'][:, col]
layer = _plausi_layer_sub(layer, ISO_WARNING, ISO_ERROR, ERR_ISO)
inresults[side]['iso'][:, col] = layer
except Exception:
pass
if ISC_WARNING > 0 or ISC_ERROR > 0:
for side in ['left', 'right']:
for col in range(2):
try:
layer = inresults[side]['isc'][:, col]
layer = _plausi_layer_sub(layer, ISC_WARNING, ISC_ERROR, ERR_ISC)
inresults[side]['isc'][:, col] = layer
except Exception:
pass
if layeruse[0] and layeruse[1]:
for side in ['left', 'right']:
for col in range(2):
try:
osc_col = inresults[side]['osc'][:, col]
iso_col = inresults[side]['iso'][:, col]
if col == 0 and any(osc_col[1:3] == ERR_OSC):
inresults[side]['iso'][:, col] = _errordep_layer_sub(osc_col, iso_col, ERR_OSC)
except Exception:
pass
if layeruse[1] and layeruse[2]:
for side in ['left', 'right']:
for col in range(2):
try:
isc_col = inresults[side]['isc'][:, col]
iso_col = inresults[side]['iso'][:, col]
if col == 0 and any(isc_col[1:3] == ERR_ISC):
inresults[side]['iso'][:, col] = _errordep_layer_sub(isc_col, iso_col, ERR_ISC)
except Exception:
pass
return inresults
def mcoldef2(errorl):
errorl = np.asarray(errorl, dtype=np.float64).ravel()
if errorl[0]:
return 'r'
elif len(errorl) > 1 and errorl[1]:
return 'm'
else:
return 'g'
def mcoldefline(errorl):
return mcoldef2(errorl)
def limit(x, uplimit, lowlimit, limitflag=None):
x = np.asarray(x, dtype=np.float64)
uplimit = np.asarray(uplimit, dtype=np.float64)
lowlimit = np.asarray(lowlimit, dtype=np.float64)
if limitflag is None:
limitflag = np.ones_like(x, dtype=np.float64)
else:
limitflag = np.asarray(limitflag, dtype=np.float64)
y = x.copy()
errorl = 0
lflag = 0
if uplimit.size == 1:
uplimit = uplimit * np.ones_like(x)
if lowlimit.size == 1:
lowlimit = lowlimit * np.ones_like(x)
uplimiterused = 0
if x.shape == uplimit.shape and x.shape == limitflag.shape:
uplimiterused = 1
ind = np.where((x > uplimit) & (limitflag > 0))[0]
if len(ind) > 0:
y[ind] = uplimit[ind]
lflag = 1
lowlimiterused = 0
if x.shape == lowlimit.shape and x.shape == limitflag.shape:
lowlimiterused = 1
ind = np.where((x < lowlimit) & (limitflag > 0))[0]
if len(ind) > 0:
y[ind] = lowlimit[ind]
lflag = 1
if not uplimiterused and not lowlimiterused:
errorl = 1
return y, errorl, lflag
def validchk(x, minval, maxval, defaultval, defaultflag,
errorin=0, errorlow=0, errorhigh=0):
y = x
errorout = errorin
if x is None or (isinstance(x, np.ndarray) and x.size == 0):
y = defaultval
elif isinstance(x, (int, float, np.floating, np.integer)) and x < minval:
if defaultflag:
y = defaultval
else:
y = minval
if not errorin:
errorout = errorlow
elif isinstance(x, (int, float, np.floating, np.integer)) and x > maxval:
if defaultflag:
y = defaultval
else:
y = maxval
if not errorin:
errorout = errorhigh
return y, errorout
def chksettings(settings, errin, xray8k=0):
nomlengthconf = 1339
actualconftype = 3.020
if errin is None or (isinstance(errin, (float, int)) and np.isnan(errin)):
errin = np.zeros(2)
errsettings = np.atleast_1d(np.asarray(errin, dtype=np.float64)).ravel()
if len(errsettings) < 2:
errsettings = np.pad(errsettings, (0, 2 - len(errsettings)))
if errsettings[0] == 0:
confData = settings.get('confData', None)
if confData is None or len(np.atleast_1d(confData)) == 0:
errsettings[0] = 180
settings['confData'] = np.zeros(nomlengthconf)
elif len(np.atleast_1d(confData)) < nomlengthconf:
errsettings[0] = 181
settings['confData'] = np.zeros(nomlengthconf)
elif len(np.atleast_1d(confData)) > 119 and np.atleast_1d(confData)[119] < actualconftype:
errsettings[0] = 182
elif not xray8k:
geom_x = settings.get('geometryData', {}).get('x', {})
geom_y = settings.get('geometryData', {}).get('y', {})
x0 = geom_x.get('x0', 0)
y0 = geom_y.get('y0', 0)
xCCD = geom_x.get('xCCD', 0)
yCCD = geom_y.get('yCCD', 0)
if x0 <= 0 or y0 <= 0 or xCCD >= 0 or yCCD >= 0:
errsettings[0] = 184
geom_x['x0'] = 600
geom_y['y0'] = 600
else:
xgamma = geom_x.get('gamma')
ygamma = geom_y.get('gamma')
if xgamma is not None and ygamma is not None and len(np.atleast_1d(xgamma)) > 0 and len(np.atleast_1d(ygamma)) > 0:
xgamma_val = float(np.atleast_1d(xgamma)[0])
ygamma_val = float(np.atleast_1d(ygamma)[0])
if (xgamma_val < 80 or xgamma_val > 110 or
ygamma_val < 80 or ygamma_val > 110):
if xgamma_val == 0 and ygamma_val == 0:
geom_x['gamma'] = None
geom_y['gamma'] = None
errsettings[1] = 184
else:
errsettings[0] = 184
else:
calib_int = settings.get('calib_struct', {}).get('int', {})
calib_ext = settings.get('calib_struct', {}).get('ext', {})
calib_int_valid = isinstance(calib_int, dict) and len(calib_int) > 0
calib_ext_valid = isinstance(calib_ext, dict) and len(calib_ext) > 0
if (calib_int_valid and calib_int.get('err', 0) > 0 and
not calib_int.get('calibrationoff', 1)):
errsettings[0] = calib_int['err']
elif (calib_ext_valid and calib_ext.get('err', 0) > 0 and
not calib_ext.get('calibrationoff', 1)):
errsettings[0] = calib_ext['err']
elif not calib_int_valid:
errsettings[0] = 191
if not xray8k:
gap_dxCCD = settings.get('gap', {}).get('dxCCD', {})
dx_x = gap_dxCCD.get('x')
dx_y = gap_dxCCD.get('y')
if dx_x is not None and dx_y is not None and len(np.atleast_1d(dx_x)) > 0 and len(np.atleast_1d(dx_y)) > 0:
dx_x_val = float(np.atleast_1d(dx_x)[0])
dx_y_val = float(np.atleast_1d(dx_y)[0])
if dx_x_val == 0 and dx_y_val == 0:
gap_dxCCD['x'] = None
gap_dxCCD['y'] = None
errsettings[1] = 183
elif dx_x_val < 0 or dx_y_val < 0:
gap_dxCCD['x'] = 1e-6
gap_dxCCD['y'] = 1e-6
errsettings[0] = 183
return settings, errsettings
def plausi2000(results, avgresults, settings):
results_out = copy.deepcopy(results)
check_dm = settings.get('plausiData', {}).get('check_dm', 0)
check_lay = settings.get('plausiData', {}).get('check_lay', 0)
if check_dm and avgresults is not None:
dm_out_avg = avgresults.get('dmOut', np.zeros((4, 2)))
if np.all(dm_out_avg[1, 0:2] == 0):
val_in = results['dmOut'][0, 0:2].copy()
limitflag = results['dmOut'][1, 0:2] == 0
rel_limit_dm = settings['plausiData'].get('rel_limit_dm', 0)
abs_limit_dm = settings['plausiData'].get('abs_limit_dm', 0)
uplimit = (1 + rel_limit_dm) * dm_out_avg[0, 0:2] + abs_limit_dm
lowlimit = (1 - rel_limit_dm) * dm_out_avg[0, 0:2] - abs_limit_dm
val_out, _, _ = limit(val_in, uplimit, lowlimit, limitflag)
results_out['dmOut'][0, 0:2] = val_out
if check_lay and avgresults is not None:
for layer in ['wth', 'osc', 'isc']:
avg_left = avgresults.get('left', {}).get(layer, np.zeros((4, 2)))
avg_right = avgresults.get('right', {}).get(layer, np.zeros((4, 2)))
if np.all(avg_left[1, 0:2] == 0) and np.all(avg_right[1, 0:2] == 0):
val_in = np.concatenate([results['left'][layer][0, 0:2], results['right'][layer][0, 0:2]])
limitflag = np.concatenate([results['left'][layer][1, 0:2] == 0, results['right'][layer][1, 0:2] == 0])
rel_limit_lay = settings['plausiData'].get('rel_limit_lay', 0)
abs_limit_lay = settings['plausiData'].get('abs_limit_lay', 0)
avg_all = np.concatenate([avg_left[0, 0:2], avg_right[0, 0:2]])
uplimit = (1 + rel_limit_lay) * avg_all + abs_limit_lay
lowlimit = (1 - rel_limit_lay) * avg_all - abs_limit_lay
val_out, _, _ = limit(val_in, uplimit, lowlimit, limitflag)
results_out['left'][layer][0, 0:2] = val_out[0:2]
results_out['right'][layer][0, 0:2] = val_out[2:4]
if (check_dm and avgresults is not None) or (check_lay and avgresults is not None):
results_out = isofit(results_out)
results_out = corefit(results_out)
return results_out
def chk_tolchksettings(tchkstrct):
if not isinstance(tchkstrct, dict):
return False
fields = [
'PtolDMmean', 'PtolDM',
'PtolOSCmean', 'PtolOSC',
'PtolISOmean', 'PtolISO',
'PtolISCmean', 'PtolISC',
'PtolWTHmean', 'PtolWTH',
'PtolCoremean', 'PtolCore',
'NtolDMmean', 'NtolDM',
'NtolOSCmean', 'NtolOSC',
'NtolISOmean', 'NtolISO',
'NtolISCmean', 'NtolISC',
'NtolWTHmean', 'NtolWTH',
'NtolCoremean', 'NtolCore',
]
vals = []
for f in fields:
v = tchkstrct.get(f, 0)
if isinstance(v, (list, np.ndarray)):
vals.extend(np.atleast_1d(v).tolist())
else:
vals.append(float(v))
return any(v > 0 for v in vals)