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)