661 lines
23 KiB
Python
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)
|