Files
CPY_AlgorithmGateway/algorithm/layer_calibration_utils.py
T
2026-07-30 18:46:32 +08:00

493 lines
19 KiB
Python

import numpy as np
def linint3(x, y, xi):
x = np.asarray(x, dtype=np.float64).ravel()
y = np.asarray(y, dtype=np.float64).ravel()
xi = np.asarray(xi, dtype=np.float64).ravel()
if len(x) != len(y):
raise ValueError('length(x) must be == length(y)')
if len(x) < 2:
raise ValueError('length(x) must be >= 2')
sort_idx = np.argsort(xi)
xi_sorted = xi[sort_idx]
yi_sorted = np.zeros_like(xi_sorted)
N = len(x)
k = 0
newk = True
for i in range(len(xi_sorted)):
foundxi = False
while not foundxi:
if k < N - 1 and xi_sorted[i] >= x[k] and xi_sorted[i] < x[k + 1]:
if newk:
m = (y[k + 1] - y[k]) / (x[k + 1] - x[k])
newk = False
yi_sorted[i] = m * (xi_sorted[i] - x[k]) + y[k]
foundxi = True
elif xi_sorted[i] <= x[0]:
m = (y[1] - y[0]) / (x[1] - x[0])
yi_sorted[i] = m * (xi_sorted[i] - x[0]) + y[0]
foundxi = True
elif xi_sorted[i] >= x[N - 1]:
m = (y[N - 1] - y[N - 2]) / (x[N - 1] - x[N - 2])
yi_sorted[i] = m * (xi_sorted[i] - x[N - 2]) + y[N - 2]
foundxi = True
else:
if k < N - 2:
k += 1
newk = True
else:
raise ValueError('Linint3: No solution, because no pos. step xi')
yi = np.zeros_like(xi)
yi[sort_idx] = yi_sorted
return yi
def lowlimit(x, bp):
x = np.asarray(x, dtype=np.float64)
y = x.copy()
yind = np.where(x < bp)
a2 = 1.0 / (2 * bp)
a0 = 0.5 * bp
y[yind] = a2 * x[yind] ** 2 + a0
return y, a0
def _layer_side_fit(results, side, layername, DefaultError=255.0):
lay_idx = {'osc': 0, 'iso': 1, 'isc': 2}
lay_names = ['osc', 'iso', 'isc']
wthvalid = (results[side]['wth'][2, :] == 0).astype(np.float64)
other_valid = np.ones(3, dtype=object)
for li, ln in enumerate(lay_names):
if ln == layername:
this_valid = (results[side][ln][2, :] == 0).astype(np.float64)
else:
other_valid[li] = ((results[side][ln][2, :] == 0) |
(results[side][ln][2, :] == 45)).astype(np.float64)
valid_new = wthvalid.copy()
for li, ln in enumerate(lay_names):
if ln == layername:
valid_new *= this_valid
else:
valid_new *= other_valid[li]
other_sum = np.zeros_like(results[side]['wth'][1, :])
for ln in lay_names:
if ln != layername:
other_sum += results[side][ln][1, :]
results[side][layername][1, :] = (
(results[side]['wth'][1, :] - other_sum) * valid_new
)
newfailed = this_valid & (1 - valid_new.astype(int))
if np.any(newfailed):
results[side][layername][2, :] = DefaultError * newfailed.astype(np.float64)
return results
def oscfit(results):
DefaultError = 255.0
for side in ['left', 'right']:
wthvalid = (results[side]['wth'][2, :] == 0).astype(np.float64)
oscvalid = (results[side]['osc'][2, :] == 0).astype(np.float64)
isovalid = ((results[side]['iso'][2, :] == 0) |
(results[side]['iso'][2, :] == 45)).astype(np.float64)
iscvalid = ((results[side]['isc'][2, :] == 0) |
(results[side]['isc'][2, :] == 45)).astype(np.float64)
oscvalid_new = wthvalid * oscvalid * isovalid * iscvalid
results[side]['osc'][1, :] = (
(results[side]['wth'][1, :] -
results[side]['iso'][1, :] -
results[side]['isc'][1, :]) * oscvalid_new
)
newfailed = oscvalid * (1 - oscvalid_new.astype(int))
if np.any(newfailed):
results[side]['osc'][2, :] = DefaultError * newfailed.astype(np.float64)
return results
def isofit(results):
DefaultError = 255.0
for side in ['left', 'right']:
wthvalid = (results[side]['wth'][2, :] == 0).astype(np.float64)
oscvalid = ((results[side]['osc'][2, :] == 0) |
(results[side]['osc'][2, :] == 45)).astype(np.float64)
iscvalid = ((results[side]['isc'][2, :] == 0) |
(results[side]['isc'][2, :] == 45)).astype(np.float64)
isovalid = (results[side]['iso'][2, :] == 0).astype(np.float64)
isovalid_new = wthvalid * oscvalid * isovalid * iscvalid
results[side]['iso'][1, :] = (
(results[side]['wth'][1, :] -
results[side]['osc'][1, :] -
results[side]['isc'][1, :]) * isovalid_new
)
newfailed = isovalid * (1 - isovalid_new.astype(int))
if np.any(newfailed):
results[side]['iso'][2, :] = DefaultError * newfailed.astype(np.float64)
return results
def iscfit(results):
DefaultError = 255.0
for side in ['left', 'right']:
wthvalid = (results[side]['wth'][2, :] == 0).astype(np.float64)
oscvalid = ((results[side]['osc'][2, :] == 0) |
(results[side]['osc'][2, :] == 45)).astype(np.float64)
isovalid = ((results[side]['iso'][2, :] == 0) |
(results[side]['iso'][2, :] == 45)).astype(np.float64)
iscvalid = (results[side]['isc'][2, :] == 0).astype(np.float64)
iscvalid_new = wthvalid * oscvalid * isovalid * iscvalid
results[side]['isc'][1, :] = (
(results[side]['wth'][1, :] -
results[side]['osc'][1, :] -
results[side]['iso'][1, :]) * iscvalid_new
)
newfailed = iscvalid * (1 - iscvalid_new.astype(int))
if np.any(newfailed):
results[side]['isc'][2, :] = DefaultError * newfailed.astype(np.float64)
return results
def corefit(results):
DefaultError = 255.0
corevalid_new = (
(results['dmOut'][2, :] == 0) &
(results['left']['wth'][2, :] == 0) &
(results['right']['wth'][2, :] == 0)
).astype(np.float64)
results['coreDm'][1, :] = (
(results['dmOut'][1, :] -
results['left']['wth'][1, :] -
results['right']['wth'][1, :]) * corevalid_new
)
newfailed = (1 - results['coreDm'][2, :].astype(int)) & (1 - corevalid_new.astype(int))
if np.any(newfailed):
errvekx = np.array([results['dmOut'][2, 0],
results['left']['wth'][2, 0],
results['right']['wth'][2, 0]])
errveky = np.array([results['dmOut'][2, 1],
results['left']['wth'][2, 1],
results['right']['wth'][2, 1]])
errindx = np.where(errvekx)[0]
errindy = np.where(errveky)[0]
errxy = np.zeros(2)
if len(errindx) > 0:
errxy[0] = errvekx[errindx[0]]
if len(errindy) > 0:
errxy[1] = errveky[errindy[0]]
results['coreDm'][2, :] = errxy * newfailed.astype(np.float64)
return results
def _calib_side(results, results_out, csector, layername, calib_key):
act_key = f'{calib_key}act'
nom_key = f'{calib_key}nom'
if act_key in csector and len(np.atleast_1d(csector[act_key])) > 0:
for side in ['left', 'right']:
val_in = np.concatenate([
results[side][layername][1, 0:2].ravel(),
results['right' if side == 'left' else 'left'][layername][1, 0:2].ravel()
]) if side == 'left' else None
if side == 'left':
val_in_left = np.concatenate([
results['left'][layername][1, 0:2].ravel(),
results['right'][layername][1, 0:2].ravel()
])
try:
val_out = linint3(csector[act_key], csector[nom_key], val_in_left)
results_out['left'][layername][1, 0:2] = val_out[0:2]
results_out['right'][layername][1, 0:2] = val_out[2:4]
except Exception:
pass
return results_out
def osc_calib(results, results_out, csector):
if 'lay1act' in csector and len(np.atleast_1d(csector['lay1act'])) > 0:
val_in = np.concatenate([
results['left']['osc'][1, 0:2].ravel(),
results['right']['osc'][1, 0:2].ravel()
])
try:
val_out = linint3(csector['lay1act'], csector['lay1nom'], val_in)
results_out['left']['osc'][1, 0:2] = val_out[0:2]
results_out['right']['osc'][1, 0:2] = val_out[2:4]
except Exception:
pass
return results_out
def iso_calib(results, results_out, csector):
if 'lay2act' in csector and len(np.atleast_1d(csector['lay2act'])) > 0:
val_in = np.concatenate([
results['left']['iso'][1, 0:2].ravel(),
results['right']['iso'][1, 0:2].ravel()
])
try:
val_out = linint3(csector['lay2act'], csector['lay2nom'], val_in)
results_out['left']['iso'][1, 0:2] = val_out[0:2]
results_out['right']['iso'][1, 0:2] = val_out[2:4]
except Exception:
pass
return results_out
def isc_calib(results, results_out, csector):
if 'lay3act' in csector and len(np.atleast_1d(csector['lay3act'])) > 0:
val_in = np.concatenate([
results['left']['isc'][1, 0:2].ravel(),
results['right']['isc'][1, 0:2].ravel()
])
try:
val_out = linint3(csector['lay3act'], csector['lay3nom'], val_in)
results_out['left']['isc'][1, 0:2] = val_out[0:2]
results_out['right']['isc'][1, 0:2] = val_out[2:4]
except Exception:
pass
return results_out
def layer_correct(results, calib_struct, layeruse, cableType):
import copy
results_out = copy.deepcopy(results)
sectionindex = None
calibrate = False
if (isinstance(calib_struct, dict) and
calib_struct.get('calibrationoff') is not None and
not calib_struct.get('calibrationoff', 1) and
not calib_struct.get('err', 1) and
len(np.atleast_1d(calib_struct.get('sectionType', []))) > 0):
ii = 0
run = True
NN = len(np.atleast_1d(calib_struct['sectionType']))
sectionType = np.atleast_1d(calib_struct['sectionType']).ravel()
mincableType = np.atleast_1d(calib_struct['mincableType']).ravel()
maxcableType = np.atleast_1d(calib_struct['maxcableType']).ravel()
while run:
if (mincableType[ii] <= cableType and
maxcableType[ii] >= cableType):
sectionindex = int(sectionType[ii])
run = False
elif ii == NN - 1:
sectionindex = None
run = False
else:
ii += 1
sectionindex = None
run = True
else:
sectionindex = None
if sectionindex is not None:
sect = calib_struct.get('sect', {}).get(sectionindex, {})
diam_err = calib_struct.get(f'sect.{sectionindex}.diam.err', 1)
wall_err = calib_struct.get(f'sect.{sectionindex}.wall.err', 1)
lay1_err = calib_struct.get(f'sect.{sectionindex}.lay1.err', 1)
lay2_err = calib_struct.get(f'sect.{sectionindex}.lay2.err', 1)
lay3_err = calib_struct.get(f'sect.{sectionindex}.lay3.err', 1)
if not diam_err and not wall_err and not lay1_err and not lay2_err and not lay3_err:
calibrate = True
if calibrate:
calidemand = np.zeros(3)
calidemand[0] = len(np.atleast_1d(calib_struct.get(f'sect.{sectionindex}.lay1.nom', []))) > 0
calidemand[1] = len(np.atleast_1d(calib_struct.get(f'sect.{sectionindex}.lay2.nom', []))) > 0
calidemand[2] = len(np.atleast_1d(calib_struct.get(f'sect.{sectionindex}.lay3.nom', []))) > 0
layeruse = np.asarray(layeruse).ravel()
if np.all(layeruse == [0, 0, 0]):
ccase = 0
elif np.all(layeruse == [0, 0, 1]):
ccase = 3
elif np.all(layeruse == [0, 1, 0]):
ccase = 2
elif np.all(layeruse == [0, 1, 1]):
if calidemand[1] == 0:
ccase = 5
else:
ccase = 6
elif np.all(layeruse == [1, 0, 0]):
ccase = 1
elif np.all(layeruse == [1, 1, 0]):
if np.all(calidemand[0:2] == [0, 1]):
ccase = 4
else:
ccase = 5
elif np.all(layeruse == [1, 1, 1]):
if np.all(calidemand == [0, 1, 1]):
ccase = 4
elif np.all(calidemand[1:3] == [1, 0]):
ccase = 6
else:
ccase = 5
else:
ccase = 0
csector = {}
for key in ['diam', 'wall', 'lay1', 'lay2', 'lay3']:
for suffix in ['act', 'nom', 'err']:
full_key = f'sect.{sectionindex}.{key}.{suffix}'
if full_key in calib_struct:
csector[f'{key}{suffix}'] = calib_struct[full_key]
diam_nom = calib_struct.get(f'sect.{sectionindex}.diam.nom', [])
if len(np.atleast_1d(diam_nom)) > 0:
val_in = results['dmOut'][1, 0:2].ravel()
try:
val_out = linint3(calib_struct[f'sect.{sectionindex}.diam.act'],
calib_struct[f'sect.{sectionindex}.diam.nom'],
val_in)
results_out['dmOut'][1, 0:2] = val_out
except Exception:
pass
if ccase > 0:
wall_nom = calib_struct.get(f'sect.{sectionindex}.wall.nom', [])
if len(np.atleast_1d(wall_nom)) > 0:
val_in = np.concatenate([
results['left']['wth'][1, 0:2].ravel(),
results['right']['wth'][1, 0:2].ravel()
])
try:
val_out = linint3(calib_struct[f'sect.{sectionindex}.wall.act'],
calib_struct[f'sect.{sectionindex}.wall.nom'],
val_in)
results_out['left']['wth'][1, 0:2] = val_out[0:2]
results_out['right']['wth'][1, 0:2] = val_out[2:4]
except Exception:
pass
if ccase == 1:
results_out['left']['osc'][1, :] = results_out['left']['wth'][1, :].copy()
results_out['right']['osc'][1, :] = results_out['right']['wth'][1, :].copy()
elif ccase == 2:
results_out['left']['iso'][1, :] = results_out['left']['wth'][1, :].copy()
results_out['right']['iso'][1, :] = results_out['right']['wth'][1, :].copy()
elif ccase == 3:
results_out['left']['isc'][1, :] = results_out['left']['wth'][1, :].copy()
results_out['right']['isc'][1, :] = results_out['right']['wth'][1, :].copy()
elif ccase == 4:
results_out = iso_calib(results, results_out, csector)
results_out = isc_calib(results, results_out, csector)
results_out = oscfit(results_out)
elif ccase == 5:
results_out = osc_calib(results, results_out, csector)
results_out = isc_calib(results, results_out, csector)
results_out = isofit(results_out)
elif ccase == 6:
results_out = osc_calib(results, results_out, csector)
results_out = iso_calib(results, results_out, csector)
results_out = iscfit(results_out)
results_out = corefit(results_out)
return results_out
def uponor_alucorrect2(results, cabletype):
cabletype = round(float(cabletype))
if cabletype not in (101, 105):
return results
if cabletype == 101:
errvek = [
results['dmOut'][1, 0], results['dmOut'][1, 0],
results['right']['osc'][1, 0], results['right']['osc'][1, 1],
results['left']['osc'][1, 1], results['right']['iso'][1, 0],
results['right']['iso'][1, 1], results['left']['iso'][1, 1],
]
else:
errvek = [
results['dmOut'][1, 0], results['dmOut'][1, 0],
results['left']['osc'][1, 0], results['left']['osc'][1, 1],
results['right']['osc'][1, 0], results['right']['osc'][1, 1],
results['left']['iso'][1, 0], results['left']['iso'][1, 1],
results['right']['iso'][1, 0], results['right']['iso'][1, 1],
]
if all(v == 0 for v in errvek):
if cabletype == 101:
isomitt = (1.0 / 3.0) * (
results['right']['iso'][0, 0] +
results['left']['iso'][0, 1] +
results['right']['iso'][0, 1]
)
results['right']['osc'][0, 0] += 0.5 * (results['right']['iso'][0, 0] - isomitt)
results['left']['osc'][0, 1] += 0.5 * (results['left']['iso'][0, 1] - isomitt)
results['right']['osc'][0, 1] += 0.5 * (results['right']['iso'][0, 1] - isomitt)
if not results['right']['isc'][1, 0]:
results['right']['isc'][0, 0] += 0.5 * (results['right']['iso'][0, 0] - isomitt)
if not results['left']['isc'][1, 1]:
results['left']['isc'][0, 1] += 0.5 * (results['left']['iso'][0, 1] - isomitt)
if not results['right']['isc'][1, 1]:
results['right']['isc'][0, 1] += 0.5 * (results['right']['iso'][0, 1] - isomitt)
results['right']['iso'][0, 0] = isomitt
results['left']['iso'][0, 1] = isomitt
results['right']['iso'][0, 1] = isomitt
else:
isomitt = (1.0 / 4.0) * (
results['left']['iso'][0, 0] + results['left']['iso'][0, 1] +
results['right']['iso'][0, 0] + results['right']['iso'][0, 1]
)
results['left']['osc'][0, 0] += 0.5 * (results['left']['iso'][0, 0] - isomitt)
results['right']['osc'][0, 0] += 0.5 * (results['right']['iso'][0, 0] - isomitt)
results['left']['osc'][0, 1] += 0.5 * (results['left']['iso'][0, 1] - isomitt)
results['right']['osc'][0, 1] += 0.5 * (results['right']['iso'][0, 1] - isomitt)
if not results['left']['isc'][1, 0]:
results['left']['isc'][0, 0] += 0.5 * (results['left']['iso'][0, 0] - isomitt)
if not results['right']['isc'][1, 0]:
results['right']['isc'][0, 0] += 0.5 * (results['right']['iso'][0, 0] - isomitt)
if not results['left']['isc'][1, 1]:
results['left']['isc'][0, 1] += 0.5 * (results['left']['iso'][0, 1] - isomitt)
if not results['right']['isc'][1, 1]:
results['right']['isc'][0, 1] += 0.5 * (results['right']['iso'][0, 1] - isomitt)
results['left']['iso'][0, 0] = isomitt
results['right']['iso'][0, 0] = isomitt
results['left']['iso'][0, 1] = isomitt
results['right']['iso'][0, 1] = isomitt
else:
errind = [i for i, v in enumerate(errvek) if v > 0]
errorvalue = np.array([0.0, errvek[errind[0]], 0.0])
for side in ['left', 'right']:
for layer in ['osc', 'iso', 'isc']:
for col in range(2):
results[side][layer][:, col] = errorvalue.copy()
return results