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

1489 lines
52 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import numpy as np
from scipy.optimize import least_squares
try:
from .math_utils import ind, polyfit2
from .geometry_utils import strng2
from .signal_utils import filter2k3
except ImportError:
from math_utils import ind, polyfit2
from geometry_utils import strng2
from signal_utils import filter2k3
def _simple_lm(fun, x0, ftol=1e-6, xtol=1e-6, max_nfev=400):
x = np.asarray(x0, dtype=np.float64).copy()
n = len(x)
lambd = 1e-3
nu = 2.0
residuals = fun(x)
cost = np.sum(residuals ** 2)
nfev = 1
success = False
while nfev < max_nfev:
eps = 1e-8
J = np.zeros((len(residuals), n))
for j in range(n):
dx_eps = np.zeros(n)
dx_eps[j] = eps * max(1.0, abs(x[j]))
residuals_plus = fun(x + dx_eps)
J[:, j] = (residuals_plus - residuals) / dx_eps[j]
nfev += 1
if nfev >= max_nfev:
break
if nfev >= max_nfev:
break
JtJ = J.T @ J
Jtr = J.T @ residuals
for _ in range(10):
diag = np.diag(JtJ) + lambd
A = JtJ + lambd * np.eye(n)
try:
delta = np.linalg.solve(A, Jtr)
except np.linalg.LinAlgError:
delta = np.linalg.lstsq(A, Jtr, rcond=None)[0]
x_new = x - delta
residuals_new = fun(x_new)
cost_new = np.sum(residuals_new ** 2)
nfev += 1
if cost_new < cost:
rho = (cost - cost_new) / (delta @ (lambd * delta + Jtr) + 1e-10)
if rho > 0.75:
lambd = lambd / 3.0
elif rho < 0.25:
lambd = lambd * 2.0
if np.max(np.abs(delta)) < xtol:
success = True
x = x_new
residuals = residuals_new
cost = cost_new
break
if abs(cost - cost_new) < ftol:
success = True
x = x_new
residuals = residuals_new
cost = cost_new
break
x = x_new
residuals = residuals_new
cost = cost_new
break
else:
lambd = lambd * nu
nu = nu * 2.0
else:
break
return x, cost, success, nfev
def attcalcx0(x, y, x0, x0r, right):
att0 = 0.0
x = np.asarray(x, dtype=np.float64)
y = np.asarray(y, dtype=np.float64)
y = np.where(y <= 0, 1e-6, y)
N = len(x)
if N > 4:
dx = (x[N - 1] - x[0]) / (N - 1)
if not right:
xleft = x0
xright = x[N - 1]
else:
xleft = x[0]
xright = x0r
if (xright - xleft) > dx:
ll = int(ind(xleft, dx, x[0], N))
rr = int(ind(xright, dx, x[0], N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
s0 = strng2(xt, x0, x0r)
min_s0 = 0.01 * (x0r - x0) if (x0r - x0) > 0 else 0.01
indvek = np.where(s0 > min_s0)[0]
if len(indvek) > 0:
att0 = -np.mean(np.log(yt[indvek]) / s0[indvek])
if np.isnan(att0) or np.isinf(att0):
att0 = 0.0
return att0
def attcalcx1(x, y, x0, x0r, x1, x1r, right):
att0 = 0.0
att1 = 0.0
x = np.asarray(x, dtype=np.float64)
y = np.asarray(y, dtype=np.float64).copy()
y[y <= 0] = 1e-6
N = len(x)
if N > 4:
dx = (x[N - 1] - x[0]) / (N - 1)
if not right:
xleft = x[0]
xright = x1
else:
xleft = x1r
xright = x[N - 1]
if (xright - xleft) > dx:
ll = int(ind(xleft, dx, x[0], N))
rr = int(ind(xright, dx, x[0], N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
s0 = strng2(xt, x0, x0r)
min_s0 = 0.01 * (x0r - x0) if (x0r - x0) > 0 else 0.01
indvek = np.where(s0 > min_s0)[0]
if len(indvek) > 0:
att0 = -np.mean(np.log(yt[indvek]) / s0[indvek])
if np.isnan(att0) or np.isinf(att0):
att0 = 0.0
if not right:
xleft = x1 + dx
xright = x[N - 1]
else:
xleft = x[0]
xright = x1r - dx
if (((xright - xleft) > dx) and (xright > x1) and (xright < x1r) and
(xleft > x1) and (xleft < x1r) and (att0 > 0)):
ll = int(ind(xleft, dx, x[0], N))
rr = int(ind(xright, dx, x[0], N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
s0 = strng2(xt, x0, x0r)
s1 = strng2(xt, x1, x1r)
min_s1 = 0.01 * (x1r - x1) if (x1r - x1) > 0 else 0.01
indvek = np.where(s1 > min_s1)[0]
if len(indvek) > 0:
att1 = np.mean((-np.log(yt[indvek]) - att0 * (s0[indvek] - s1[indvek])) / s1[indvek])
if np.isnan(att1) or np.isinf(att1):
att1 = 0.0
return att0, att1
def resfail(resnorm, lyt, meanyt):
return np.sqrt(resnorm / lyt) / meanyt
def edge_error2(calcval, exitflag, resnorm, avgval, startalpha0, minxt, maxxt,
minalpha0, maxalpha0, mincontr, maxcontr, contrsign, resmax,
diffxt1, diffxt2, lengthxt):
errorl = np.zeros(2, dtype=np.float64)
if exitflag < 0:
errorl[0] = 51
else:
if (calcval['x'] < (minxt + diffxt1)) or (calcval['x'] > (maxxt - diffxt1)):
errorl[1] = 47
if (calcval['x'] < (minxt + diffxt2)) or (calcval['x'] > (maxxt - diffxt2)):
errorl[0] = 47
if calcval['alpha0'] < minalpha0:
errorl[0] = 52
if calcval['alpha0'] > maxalpha0:
errorl[0] = 53
if abs(calcval['alpha1'] - calcval['alpha0']) < mincontr:
errorl[0] = 54
if (((calcval['alpha1'] - calcval['alpha0']) < 0) and (contrsign == 1)) or \
(((calcval['alpha1'] - calcval['alpha0']) > 0) and (contrsign == -1)):
errorl[0] = 56
relfail = resfail(resnorm, lengthxt, avgval)
if relfail > resmax:
errorl[0] = 57
if (calcval['x'] < minxt) or (calcval['x'] > maxxt):
errorl[0] = 46
return errorl
def x0fun(para_dyn, para_static, x, yactual=None):
x = np.asarray(x, dtype=np.float64)
x0 = para_dyn[0]
x0r = para_dyn[1]
alpha0 = para_dyn[2]
x3 = None
x3r = None
alpha1 = None
beta1 = None
if para_static.get('xlr41det', 0) == 1:
x3 = para_dyn[3]
x3r = para_dyn[4]
elif para_static.get('xlr41det', 0) == 2:
x3 = para_dyn[3]
x3r = para_dyn[4]
alpha1 = para_dyn[5]
beta1 = para_static.get('beta1', 0)
filtactive = para_static.get('filtactive', 0)
# 读取原始mm值,避免引用传递导致的重复转换
filtlength = para_static.get('filtlength_mm', para_static.get('filtlength', 0))
xout = None
if yactual is not None:
yactual = np.asarray(yactual, dtype=np.float64)
minx = np.min(x)
maxx = np.max(x)
dx = (maxx - minx) / (len(x) - 1)
if (x0 > minx) and (x0 < maxx):
stopind = int(ind((x0 - 2 * filtlength), dx, x[0], len(x)))
I0 = np.mean(yactual[0:stopind])
elif (x0r > minx) and (x0r < maxx):
startind = int(ind((x0r + 2 * filtlength), dx, x[0], len(x)))
I0 = np.mean(yactual[startind - 1:])
else:
I0 = 1.0
minI0 = 0.93
maxI0 = 1.07
if I0 > maxI0:
I0 = maxI0
elif I0 < minI0:
I0 = minI0
else:
I0 = para_static.get('I0', 1.0)
xlr41det = para_static.get('xlr41det', 0)
if xlr41det == 0:
s1 = strng2(x, x0, x0r, 1)
y = I0 * np.exp(-(alpha0 * s1))
elif xlr41det == 1:
s1 = strng2(x, x0, x0r, 1)
s3 = strng2(x, x3, x3r, 1)
y = I0 * np.exp(-(alpha0 * (s1 - s3)))
elif xlr41det == 2:
s1 = strng2(x, x0, x0r, 1)
s3 = strng2(x, x3, x3r, 1)
y = I0 * np.exp(-(alpha0 * (s1 - s3) + beta1 * ((s1 - s3) ** 2) + alpha1 * s3))
else:
y = np.zeros_like(x)
N2 = 0
if filtactive:
if para_static.get('unsharpness', 0) == 1:
from .filtering_utils import smooth
filtvek = smooth(para_static.get('a1', 1), para_static.get('a2', 1),
para_static.get('a3', 1), para_static.get('filtkoff', 1))
y, N2 = filter2k3(filtvek, y, 1)
else:
dx = x[1] - x[0]
filtlen = int(np.round(filtlength / dx))
if filtlen % 2 == 0:
filtlen = filtlen + 1
y, N2 = filter2k3((1.0 / filtlen) * np.ones(filtlen), y)
startind = N2
stopind = len(x) - N2
if para_static.get('lsqn', 0) == 1:
if yactual is not None:
y = y[startind:stopind] - yactual[startind:stopind]
else:
xout = x[startind:stopind]
y = y[startind:stopind]
return y, I0, xout, N2
def x1fun3setup(para_static, alpha0, alpha1):
mode = para_static.get('mode', 0)
if mode == 0:
para_dyn = np.array([alpha0, para_static['x1'], para_static['x1r'], alpha1], dtype=np.float64)
elif mode == 1:
para_dyn = np.array([alpha0, para_static['x1'], para_static['x1r']], dtype=np.float64)
elif mode == 2:
para_dyn = np.array([alpha0, para_static['x1'], alpha1], dtype=np.float64)
elif mode == 3:
para_dyn = np.array([alpha0, para_static['x1r'], alpha1], dtype=np.float64)
elif mode == 4:
para_dyn = np.array([alpha0, para_static['x1'], para_static['x1r'],
para_static['x0r'] - para_static['x0']], dtype=np.float64)
elif mode == 5 or mode == 6:
para_dyn = np.array([para_static['x1'], para_static['x1r']], dtype=np.float64)
elif mode == 7:
para_dyn = np.array([alpha0, para_static['x1'], para_static['x1r'], alpha1,
para_static.get('x2', 0), para_static.get('x2r', 0), 0.0], dtype=np.float64)
else:
para_dyn = np.array([alpha0, para_static['x1'], para_static['x1r'], alpha1], dtype=np.float64)
return para_dyn
def x1fun3out(calcpara, para_static):
mode = para_static.get('mode', 0)
dataout = {}
if mode == 0:
dataout['alpha0'] = calcpara[0]
dataout['x1'] = calcpara[1]
dataout['x1r'] = calcpara[2]
dataout['alpha1'] = calcpara[3]
elif mode == 1:
dataout['alpha0'] = calcpara[0]
dataout['x1'] = calcpara[1]
dataout['x1r'] = calcpara[2]
dataout['alpha1'] = 0.0
elif mode == 2:
dataout['alpha0'] = calcpara[0]
dataout['x1'] = calcpara[1]
dataout['alpha1'] = calcpara[2]
dataout['x1r'] = para_static.get('x1r', 0)
elif mode == 3:
dataout['alpha0'] = calcpara[0]
dataout['x1r'] = calcpara[1]
dataout['alpha1'] = calcpara[2]
dataout['x1'] = para_static.get('x1', 0)
elif mode == 4:
dataout['alpha0'] = calcpara[0]
dataout['x1'] = calcpara[1]
dataout['x1r'] = calcpara[2]
dataout['alpha1'] = 0.0
elif mode == 5:
reg_sub = para_static.get('reg_sub', {})
dataout['alpha0'] = reg_sub.get('alpha0', 0)
dataout['x1'] = calcpara[0]
dataout['x1r'] = calcpara[1]
dataout['alpha1'] = 0.0
elif mode == 6:
reg_sub = para_static.get('reg_sub', {})
dataout['alpha0'] = reg_sub.get('alpha0', 0)
dataout['x1'] = calcpara[0]
dataout['x1r'] = calcpara[1]
dataout['alpha1'] = reg_sub.get('alpha1', 0)
elif mode == 7:
dataout['alpha0'] = calcpara[0]
dataout['x1'] = calcpara[1]
dataout['x1r'] = calcpara[2]
dataout['alpha1'] = calcpara[3]
else:
dataout['alpha0'] = 0.0
dataout['x1'] = 0.0
dataout['x1r'] = 0.0
dataout['alpha1'] = 0.0
return dataout
def x0_x0r_reg_sub(x, IN, klevel=0, Anzpara=0):
x = np.asarray(x, dtype=np.float64)
IN = np.asarray(IN, dtype=np.float64)
trueind = np.where(IN < 1)[0]
x = x[trueind]
IN = IN[trueind]
x0 = 0.0
x0r = 0.0
alpha0 = 0.0
errorl = np.zeros(2, dtype=np.float64)
P = np.zeros(3, dtype=np.float64)
if len(IN) > 3:
IN2 = (np.log(IN)) ** 2
P = polyfit2(x, IN2, 2)
A = P[1] / P[0]
B = (P[1] ** 2 / (4 * P[0] ** 2)) - (P[2] / P[0])
if (B > 0) and (-P[0] > 0):
x0 = -0.5 * A - np.sqrt(B)
alpha0 = 0.5 * np.sqrt(-P[0])
x0r = -(x0 + A)
if alpha0 < klevel:
errorl[0] = 11
else:
errorl[0] = 58
else:
errorl[0] = 58
return x0, x0r, alpha0, errorl, P
def x1fun3(para_dyn, para_static, x, yactual=None):
x = np.asarray(x, dtype=np.float64)
regsubres = {}
xout = None
mode = para_static.get('mode', 0)
if mode == 0:
alpha0 = para_dyn[0]
x1 = para_dyn[1]
x1r = para_dyn[2]
alpha1 = para_dyn[3]
x0 = para_static['x0']
x0r = para_static['x0r']
elif mode == 1:
alpha0 = para_dyn[0]
x1 = para_dyn[1]
x1r = para_dyn[2]
x0 = para_static['x0']
x0r = para_static['x0r']
alpha1 = 0.0
elif mode == 2:
alpha0 = para_dyn[0]
x1 = para_dyn[1]
alpha1 = para_dyn[2]
x1r = para_static['x1r']
x0 = para_static['x0']
x0r = para_static['x0r']
elif mode == 3:
alpha0 = para_dyn[0]
x1r = para_dyn[1]
alpha1 = para_dyn[2]
x1 = para_static['x1']
x0 = para_static['x0']
x0r = para_static['x0r']
elif mode == 4:
alpha0 = para_dyn[0]
x1 = para_dyn[1]
x1r = para_dyn[2]
d0 = para_dyn[3]
x0 = 0.5 * (para_static['x0'] + para_static['x0r']) - 0.5 * d0
x0r = x0 + d0
alpha1 = 0.0
elif mode == 5:
x1 = para_dyn[0]
x1r = para_dyn[1]
alpha1 = 0.0
if yactual is not None:
yactual = np.asarray(yactual, dtype=np.float64)
minx = np.min(x)
maxx = np.max(x)
dx = (maxx - minx) / (len(x) - 1)
xmitt = 0.5 * (para_static['x0'] + para_static['x0r'])
if (x1 > minx) and (x1 <= maxx):
startind = 0
stopind = int(ind((x1 - 0.5 * para_static.get('filtlength', 0)), dx, x[0], len(x)))
xright = x[stopind - 1] + 2 * (xmitt - x[stopind - 1])
xreg = np.concatenate([x[startind:stopind], [xright]])
yreg = np.concatenate([yactual[startind:stopind], [yactual[stopind - 1]]])
rangeerr = 0
elif (x1r > minx) and (x1r <= maxx):
startind = int(ind((x1r + 0.5 * para_static.get('filtlength', 0)), dx, x[0], len(x)))
stopind = len(x)
xleft = x[startind - 1] - 2 * (x[startind - 1] - xmitt)
xreg = np.concatenate([[xleft], x[startind - 1:stopind]])
yreg = np.concatenate([[yactual[startind - 1]], yactual[startind - 1:stopind]])
rangeerr = 0
else:
rangeerr = 1
xreg = np.array([])
yreg = np.array([])
if not rangeerr:
x0, x0r, alpha0, _, _ = x0_x0r_reg_sub(xreg, yreg, 0, 0)
else:
x0 = 0.0
x0r = 0.0
alpha0 = 0.0
if (x0 == 0) or rangeerr:
x0 = para_static['x0']
x0r = para_static['x0r']
alpha0 = 0.0
regsubres['x0'] = x0
regsubres['x0r'] = x0r
regsubres['alpha0'] = alpha0
else:
x0 = para_static.get('reg_sub', {}).get('x0', para_static['x0'])
x0r = para_static.get('reg_sub', {}).get('x0r', para_static['x0r'])
alpha0 = para_static.get('reg_sub', {}).get('alpha0', 0.0)
elif mode == 6:
x1 = para_dyn[0]
x1r = para_dyn[1]
if yactual is not None:
yactual = np.asarray(yactual, dtype=np.float64)
minx = np.min(x)
maxx = np.max(x)
dx = (maxx - minx) / (len(x) - 1)
xmitt = 0.5 * (para_static['x0'] + para_static['x0r'])
if (x1 > minx) and (x1 <= maxx):
startind = 0
stopind = int(ind((x1 - 0.5 * para_static.get('filtlength', 0)), dx, x[0], len(x)))
xright = x[stopind - 1] + 2 * (xmitt - x[stopind - 1])
xreg = np.concatenate([x[startind:stopind], [xright]])
yreg = np.concatenate([yactual[startind:stopind], [yactual[stopind - 1]]])
rangeerr = 0
x1_inRange = 1
elif (x1r > minx) and (x1r <= maxx):
startind = int(ind((x1r + 0.5 * para_static.get('filtlength', 0)), dx, x[0], len(x)))
stopind = len(x)
xleft = x[startind - 1] - 2 * (x[startind - 1] - xmitt)
xreg = np.concatenate([[xleft], x[startind - 1:stopind]])
yreg = np.concatenate([[yactual[startind - 1]], yactual[startind - 1:stopind]])
rangeerr = 0
x1_inRange = 0
else:
rangeerr = 1
x1_inRange = 0
xreg = np.array([])
yreg = np.array([])
if not rangeerr:
x0, x0r, alpha0, _, _ = x0_x0r_reg_sub(xreg, yreg, 0, 0)
else:
x0 = 0.0
x0r = 0.0
alpha0 = 0.0
alpha1 = 0.0
if (not rangeerr) and not (x0 == 0):
if x1_inRange:
startind = int(ind((x1 + 2 * dx + 0.5 * para_static.get('filtlength', 0)), dx, x[0], len(x)))
stopx = min([maxx, (x1r - dx)])
stopind = int(ind(stopx, dx, x[0], len(x)))
else:
startx = max([minx, (x1 + dx)])
startind = int(ind(startx, dx, x[0], len(x)))
stopind = int(ind((x1r - 2 * dx - 0.5 * para_static.get('filtlength', 0)), dx, x[0], len(x)))
xreg2 = x[startind - 1:stopind]
yreg2 = yactual[startind - 1:stopind]
if len(xreg2) > 0:
s1 = strng2(xreg2, x0, x0r, 1)
s2 = strng2(xreg2, x1, x1r, 1)
if (x1r > x1):
alpha1vek = -(np.log(yreg2) + alpha0 * (s1 - s2)) / s2
valid = ~np.isinf(alpha1vek)
if np.any(valid):
alpha1 = np.mean(alpha1vek[valid])
rangeerr2 = 0
else:
alpha1 = 0.0
rangeerr2 = 1
else:
rangeerr2 = 1
else:
rangeerr2 = 1
if (x0 == 0) or rangeerr:
x0 = para_static['x0']
x0r = para_static['x0r']
alpha0 = 0.0
alpha1 = 0.0
elif rangeerr2:
alpha1 = 0.0
regsubres['x0'] = x0
regsubres['x0r'] = x0r
regsubres['alpha0'] = alpha0
regsubres['alpha1'] = alpha1
else:
x0 = para_static.get('reg_sub', {}).get('x0', para_static['x0'])
x0r = para_static.get('reg_sub', {}).get('x0r', para_static['x0r'])
alpha0 = para_static.get('reg_sub', {}).get('alpha0', 0.0)
alpha1 = para_static.get('reg_sub', {}).get('alpha1', 0.0)
elif mode == 7:
alpha0 = para_dyn[0]
x1 = para_dyn[1]
x1r = para_dyn[2]
alpha1 = para_dyn[3]
x2 = para_dyn[4]
x2r = para_dyn[5]
alpha2 = para_dyn[6]
x0 = para_static['x0']
x0r = para_static['x0r']
else:
alpha0 = 0.0
x1 = 0.0
x1r = 0.0
alpha1 = 0.0
x0 = para_static.get('x0', 0)
x0r = para_static.get('x0r', 0)
s1 = strng2(x, x0, x0r, 1)
s2 = strng2(x, x1, x1r, 1)
if mode in [1, 4, 5]:
y = np.exp(-(alpha0 * (s1 - s2)))
elif mode == 7:
s3 = strng2(x, x2, x2r, 1)
y = np.exp(-(alpha0 * (s1 - s2) + alpha1 * (s2 - s3) + alpha2 * s3))
else:
y = np.exp(-(alpha0 * (s1 - s2) + alpha1 * s2))
N2 = 0
if para_static.get('filtactive', 0):
dx = x[1] - x[0]
# 从para_static获取原始filtlength(mm),每次都重新转换为像素
# 匹配MATLAB值传递语义:每次调用filtlength都是原始mm值
filtlen_orig = para_static.get('filtlength_mm', para_static.get('filtlength', 0))
filtlen = int(np.round(filtlen_orig / dx))
if filtlen % 2 == 0:
filtlen = filtlen + 1
y, N2 = filter2k3((1.0 / filtlen) * np.ones(filtlen), y)
startind = N2
stopind = len(x) - N2
if para_static.get('lsqn', 0) == 1:
if yactual is not None:
yactual = np.asarray(yactual, dtype=np.float64)
y = y[startind:stopind] - yactual[startind:stopind]
else:
xout = x[startind:stopind]
y = y[startind:stopind]
return y, regsubres, xout
def x0_x0r_curvefit2(x, y, fun_startpara, fun_para_static, modul_para):
x = np.asarray(x, dtype=np.float64)
y = np.asarray(y, dtype=np.float64)
# 保存原始filtlength(mm),避免Python引用传递导致的重复转换问题
if 'filtlength_mm' not in fun_para_static:
fun_para_static['filtlength_mm'] = fun_para_static.get('filtlength', 0)
dataout = {
'left': {
'pos': {'result': np.nan, 'start': np.nan,
'limit': {'left': np.nan, 'right': np.nan}},
'att': {'outer': np.nan, 'inner': np.nan},
'error': np.array([np.nan, np.nan])
},
'right': {
'pos': {'result': np.nan, 'start': np.nan,
'limit': {'left': np.nan, 'right': np.nan}},
'att': {'outer': np.nan, 'inner': np.nan},
'error': np.array([np.nan, np.nan])
}
}
errorlevel = np.zeros((2, 2), dtype=np.float64)
calcpara = np.zeros(6, dtype=np.float64)
calcpara1 = np.zeros(6, dtype=np.float64)
calcpara2 = np.zeros(6, dtype=np.float64)
dx = x[1] - x[0]
diffxt1 = 0.2
diffxt2 = 0.10
tol_fun = modul_para.get('TolFun', 1e-6)
tol_x = modul_para.get('TolX', 1e-6)
max_iter = int(modul_para.get('MaxFunEvals', 400))
if 'xlr41det' not in fun_para_static:
fun_para_static['xlr41det'] = 0
if len(fun_startpara) < 5:
fun_para_static['xlr41det'] = 0
N = len(x)
leftcut = fun_startpara[0] - modul_para['range_outer'] - fun_para_static['filtlength']
if leftcut < (modul_para['x0limit_l'] - fun_para_static['filtlength']):
leftcut = modul_para['x0limit_l'] - fun_para_static['filtlength']
if fun_para_static['xlr41det']:
rightcut = fun_startpara[3] + modul_para['range_inner'] + fun_para_static['filtlength']
else:
rightcut = fun_startpara[0] + modul_para['range_inner'] + fun_para_static['filtlength']
if rightcut > (modul_para['x0limit_r'] + fun_para_static['filtlength']):
rightcut = modul_para['x0limit_r'] + fun_para_static['filtlength']
ll = int(ind(leftcut, dx, 0, N))
rr = int(ind(rightcut, dx, 0, N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
if len(xt) > 10:
if fun_para_static['xlr41det'] != 2:
fun_startpara[2] = attcalcx0(xt, yt, fun_startpara[0], fun_startpara[1], 0)
fun_para_static['lsqn'] = 1
try:
result = least_squares(lambda p: x0fun(p, fun_para_static, xt, yt)[0],
fun_startpara, method='lm',
ftol=tol_fun, xtol=tol_x, max_nfev=max_iter)
calcpara1 = result.x
resnorm = np.sum(result.fun ** 2)
exitflag = 1 if result.success else -1
except Exception as e:
import traceback
traceback.print_exc()
calcpara1 = fun_startpara
resnorm = 1e10
exitflag = -1
calcval = {'alpha0': 0, 'alpha1': calcpara1[2], 'x': calcpara1[0]}
dataout['left']['pos']['result'] = calcval['x']
dataout['left']['att']['outer'] = calcval['alpha0']
dataout['left']['att']['inner'] = calcval['alpha1']
minxt = np.min(xt)
maxxt = np.max(xt)
errorlevel[:, 0] = edge_error2(calcval, exitflag, resnorm, np.mean(yt), 0,
minxt, maxxt, modul_para['minatt1'], modul_para['maxatt1'],
modul_para['mincontr'], modul_para['maxcontr'], 1,
modul_para['resmax'], diffxt1, diffxt2, len(yt))
else:
errorlevel[0, 0] = 50
if fun_para_static['xlr41det'] == 1:
leftcut = fun_startpara[4] - modul_para['range_inner'] - fun_para_static['filtlength']
else:
leftcut = fun_startpara[1] - modul_para['range_inner'] - fun_para_static['filtlength']
if leftcut < (modul_para['x0rlimit_l'] - fun_para_static['filtlength']):
leftcut = modul_para['x0rlimit_l'] - fun_para_static['filtlength']
rightcut = fun_startpara[1] + modul_para['range_outer'] + fun_para_static['filtlength']
if rightcut > (modul_para['x0rlimit_r'] + fun_para_static['filtlength']):
rightcut = modul_para['x0rlimit_r'] + fun_para_static['filtlength']
ll = int(ind(leftcut, dx, 0, N))
rr = int(ind(rightcut, dx, 0, N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
if len(xt) > 10:
if fun_para_static['xlr41det'] != 2:
fun_startpara[2] = attcalcx0(xt, yt, fun_startpara[0], fun_startpara[1], 1)
fun_para_static['lsqn'] = 1
try:
result = least_squares(lambda p: x0fun(p, fun_para_static, xt, yt)[0],
fun_startpara, method='lm',
ftol=tol_fun, xtol=tol_x, max_nfev=max_iter)
calcpara2 = result.x
resnorm = np.sum(result.fun ** 2)
exitflag = 1 if result.success else -1
except Exception as e:
import traceback
traceback.print_exc()
calcpara2 = fun_startpara
resnorm = 1e10
exitflag = -1
calcval = {'alpha0': 0, 'alpha1': calcpara2[2], 'x': calcpara2[1]}
dataout['right']['pos']['result'] = calcval['x']
dataout['right']['att']['outer'] = calcval['alpha0']
dataout['right']['att']['inner'] = calcval['alpha1']
minxt = np.min(xt)
maxxt = np.max(xt)
errorlevel[:, 1] = edge_error2(calcval, exitflag, resnorm, np.mean(yt), 0,
minxt, maxxt, modul_para['minatt1'], modul_para['maxatt1'],
modul_para['mincontr'], modul_para['maxcontr'], 1,
modul_para['resmax'], diffxt1, diffxt2, len(yt))
else:
errorlevel[0, 1] = 50
if (errorlevel[0, 0] == 0) and (errorlevel[0, 1] == 0):
calcpara[0] = calcpara1[0]
calcpara[1] = calcpara2[1]
calcpara[2] = 0.5 * (calcpara1[2] + calcpara2[2])
elif errorlevel[0, 0] == 0:
calcpara[0] = calcpara1[0]
calcpara[2] = calcpara1[2]
elif errorlevel[0, 1] == 0:
calcpara[1] = calcpara2[1]
calcpara[2] = calcpara2[2]
if fun_para_static['xlr41det'] == 1:
calcpara = np.resize(calcpara, 6)
calcpara[3] = calcpara1[3]
calcpara[4] = calcpara2[4]
elif fun_para_static['xlr41det'] == 2:
calcpara = np.resize(calcpara, 6)
calcpara[3] = calcpara1[3]
calcpara[4] = calcpara2[4]
if len(calcpara1) > 5 and len(calcpara2) > 5:
calcpara[5] = 0.5 * (calcpara1[5] + calcpara2[5])
return calcpara, errorlevel, dataout
def x1_x1r_curvefit3(x, y, fun_para_static, modul_para):
x = np.asarray(x, dtype=np.float64)
y = np.asarray(y, dtype=np.float64)
# 保存原始filtlength(mm),避免Python引用传递导致的重复转换问题
if 'filtlength_mm' not in fun_para_static:
fun_para_static['filtlength_mm'] = fun_para_static.get('filtlength', 0)
errorlevel = np.zeros((2, 2), dtype=np.float64)
calcpara = np.zeros(4, dtype=np.float64)
dataout = {
'alpha0': 0, 'x1': 0, 'x1r': 0, 'alpha1': 0,
'left': {
'pos': {'result': np.nan, 'start': np.nan,
'limit': {'left': np.nan, 'right': np.nan}},
'att': {'outer': np.nan, 'inner': np.nan},
'error': np.array([np.nan, np.nan])
},
'right': {
'pos': {'result': np.nan, 'start': np.nan,
'limit': {'left': np.nan, 'right': np.nan}},
'att': {'outer': np.nan, 'inner': np.nan},
'error': np.array([np.nan, np.nan])
}
}
dx = x[1] - x[0]
N = len(x)
tol_fun = modul_para.get('TolFun', 1e-6)
tol_x = modul_para.get('TolX', 1e-6)
max_iter = int(modul_para.get('MaxFunEvals', 400))
contrsign = modul_para.get('contrsign', 0)
leftcut = fun_para_static['x1'] - modul_para['range_outer'] - fun_para_static['filtlength']
if leftcut < (modul_para['x1limit_l'] - fun_para_static['filtlength']):
leftcut = modul_para['x1limit_l'] - fun_para_static['filtlength']
rightcut = fun_para_static['x1'] + modul_para['range_inner'] + fun_para_static['filtlength']
if rightcut > modul_para['x1limit_r'] + fun_para_static['filtlength']:
rightcut = modul_para['x1limit_r'] + fun_para_static['filtlength']
ll = int(ind(leftcut, dx, 0, N))
rr = int(ind(rightcut, dx, 0, N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
dataoutleft = None
if len(xt) > 10:
att0, att1 = attcalcx1(xt, yt, fun_para_static['x0'], fun_para_static['x0r'],
fun_para_static['x1'], fun_para_static['x1r'], 0)
fun_startpara = x1fun3setup(fun_para_static, att0, att1)
fun_para_static['lsqn'] = 1
try:
result = least_squares(lambda p: x1fun3(p, fun_para_static, xt, yt)[0],
fun_startpara, method='lm',
ftol=tol_fun, xtol=tol_x, max_nfev=max_iter)
calcpara_left = result.x
resnorm = np.sum(result.fun ** 2)
exitflag = 1 if result.success else -1
except Exception:
calcpara_left = fun_startpara
resnorm = 1e10
exitflag = -1
_, fun_para_static['reg_sub'], _ = x1fun3(calcpara_left, fun_para_static, xt, yt)
dataoutleft = x1fun3out(calcpara_left, fun_para_static)
calcval = {'alpha0': dataoutleft['alpha0'], 'alpha1': dataoutleft['alpha1'],
'x': dataoutleft['x1']}
dataout['left']['pos']['result'] = calcval['x']
dataout['left']['att']['inner'] = calcval['alpha1']
dataout['left']['att']['outer'] = calcval['alpha0']
minxt = np.min(xt)
maxxt = np.max(xt)
errorlevel[:, 0] = edge_error2(calcval, exitflag, resnorm, np.mean(yt), att0,
minxt, maxxt, modul_para['minatt1'], modul_para['maxatt1'],
modul_para['mincontr'], modul_para['maxcontr'], contrsign,
modul_para['resmax'], 0.1 * (maxxt - minxt),
0.05 * (maxxt - minxt), len(yt))
else:
errorlevel[0, 0] = 50
if fun_para_static.get('mode', 0) == 2:
fun_para_static['mode'] = 3
leftcut = fun_para_static['x1r'] - modul_para['range_inner'] - fun_para_static['filtlength']
if leftcut < (modul_para['x1rlimit_l'] - fun_para_static['filtlength']):
leftcut = modul_para['x1rlimit_l'] - fun_para_static['filtlength']
rightcut = fun_para_static['x1r'] + modul_para['range_outer'] + fun_para_static['filtlength']
if rightcut > modul_para['x1rlimit_r'] + fun_para_static['filtlength']:
rightcut = modul_para['x1rlimit_r'] + fun_para_static['filtlength']
ll = int(ind(leftcut, dx, 0, N))
rr = int(ind(rightcut, dx, 0, N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
dataoutright = None
if len(xt) > 10:
att0, att1 = attcalcx1(xt, yt, fun_para_static['x0'], fun_para_static['x0r'],
fun_para_static['x1'], fun_para_static['x1r'], 1)
fun_startpara = x1fun3setup(fun_para_static, att0, att1)
fun_para_static['lsqn'] = 1
try:
result = least_squares(lambda p: x1fun3(p, fun_para_static, xt, yt)[0],
fun_startpara, method='lm',
ftol=tol_fun, xtol=tol_x, max_nfev=max_iter)
calcpara_right = result.x
resnorm = np.sum(result.fun ** 2)
exitflag = 1 if result.success else -1
except Exception:
calcpara_right = fun_startpara
resnorm = 1e10
exitflag = -1
_, fun_para_static['reg_sub'], _ = x1fun3(calcpara_right, fun_para_static, xt, yt)
dataoutright = x1fun3out(calcpara_right, fun_para_static)
calcval = {'alpha0': dataoutright['alpha0'], 'alpha1': dataoutright['alpha1'],
'x': dataoutright['x1r']}
dataout['right']['pos']['result'] = calcval['x']
dataout['right']['att']['inner'] = calcval['alpha1']
dataout['right']['att']['outer'] = calcval['alpha0']
minxt = np.min(xt)
maxxt = np.max(xt)
errorlevel[:, 1] = edge_error2(calcval, exitflag, resnorm, np.mean(yt), att0,
minxt, maxxt, modul_para['minatt1'], modul_para['maxatt1'],
modul_para['mincontr'], modul_para['maxcontr'], contrsign,
modul_para['resmax'], 0.1 * (maxxt - minxt),
0.05 * (maxxt - minxt), len(yt))
else:
errorlevel[0, 1] = 50
if (errorlevel[0, 0] == 0) and (errorlevel[0, 1] == 0):
dataout['alpha0'] = 0.5 * (dataoutleft['alpha0'] + dataoutright['alpha0'])
dataout['x1'] = dataoutleft['x1']
dataout['x1r'] = dataoutright['x1r']
dataout['alpha1'] = 0.5 * (dataoutleft['alpha1'] + dataoutright['alpha1'])
elif errorlevel[0, 0] == 0:
dataout['alpha0'] = dataoutleft['alpha0']
dataout['x1'] = dataoutleft['x1']
dataout['x1r'] = 0
dataout['alpha1'] = dataoutleft['alpha1']
elif errorlevel[0, 1] == 0:
dataout['alpha0'] = dataoutright['alpha0']
dataout['x1'] = 0
dataout['x1r'] = dataoutright['x1r']
dataout['alpha1'] = dataoutright['alpha1']
return dataout, errorlevel
def circlepos(d, strng):
dist = 0.0
if strng <= d:
dist = 0.5 * d + np.sqrt(0.25 * d ** 2 - (strng ** 2 / 4))
dist = d - dist
return dist
def linreg(IN, Dl, Dr, dx, alles, xshift=0):
IN = np.asarray(IN, dtype=np.float64)
ll = int(ind(Dl, dx, xshift))
rr = int(ind(Dr, dx, xshift))
rechtsx = (ll - 1) * dx + xshift
N = 2 * int(np.floor((rr - ll + 1) / 2))
Indiffv = np.zeros(N, dtype=np.float64)
x = np.zeros(N, dtype=np.float64)
Indiffv[0:N] = IN[np.arange(N) + ll - 1]
x[0:N] = np.arange(N) * dx
A = polyfit2(x, Indiffv, 1)
reg = np.zeros(N, dtype=np.float64)
Indiff = np.zeros(N, dtype=np.float64)
reg[0:N] = A[1] + A[0] * dx * np.arange(N)
Indiff[0:N] = Indiffv[0:N] - reg[0:N]
Ref = Indiffv[int(N / 2)]
return Indiff, rechtsx, Ref
def qcheck(Indiff, dx, Ref, klevel, Anzpara):
Indiff = np.asarray(Indiff, dtype=np.float64)
errorlevel = np.zeros(2, dtype=np.float64)
N = len(Indiff)
x = np.arange(N) * dx
A = polyfit2(x, Indiff, 2)
Scheitelx = -A[1] / (2 * A[0])
if Scheitelx > N * dx:
errorlevel[1] = 11
if Scheitelx < 0:
errorlevel[1] = 11
if abs(A[0]) > 0:
Scheitely = A[2] - ((A[1] ** 2) / (4 * A[0]))
diff1 = abs(np.polyval(A, 0) - Scheitely)
diff2 = abs(np.polyval(A, N * dx) - Scheitely)
diff = (diff1 + diff2) / 2
Kontrast = diff * 1 / (N * dx)
if Kontrast < klevel:
errorlevel[0] = 11
else:
errorlevel[0] = 11
Maximum = (A[0] < 0)
return errorlevel, Maximum
def _lfilter_fifi(b, a, x, zi):
b = np.asarray(b, dtype=np.float64)
a = np.asarray(a, dtype=np.float64)
x = np.asarray(x, dtype=np.float64)
y = np.zeros_like(x)
m = len(b)
n = len(a)
nfilt = max(m, n)
z = np.asarray(zi, dtype=np.float64).copy()
if len(z) < nfilt - 1:
z = np.pad(z, (0, nfilt - 1 - len(z)))
for i in range(len(x)):
y[i] = b[0] * x[i] + z[0]
for j in range(1, nfilt):
bj = b[j] if j < m else 0.0
aj = a[j] if j < n else 0.0
if j < nfilt - 1:
z[j - 1] = bj * x[i] + z[j] - aj * y[i]
else:
z[j - 1] = bj * x[i] - aj * y[i]
return y
def fifi(b, a, x):
b = np.asarray(b, dtype=np.float64).ravel()
a = np.asarray(a, dtype=np.float64).ravel()
x = np.asarray(x, dtype=np.float64)
if len(b) == 0 or len(a) == 0 or len(x) == 0:
return np.array([])
orig_shape = x.shape
if x.ndim > 1:
x = x.ravel()
len_x = len(x)
nb = len(b)
na = len(a)
nfilt = max(nb, na)
nfact = 3 * (nfilt - 1)
if nb < nfilt:
b = np.pad(b, (0, nfilt - nb))
if na < nfilt:
a = np.pad(a, (0, nfilt - na))
if nfilt > 1:
A_mat = np.eye(nfilt - 1)
col = -a[1:nfilt]
B_mat = np.zeros((nfilt - 1, nfilt - 1))
B_mat[0, :] = col
if nfilt > 2:
B_mat[1:, :-1] = np.eye(nfilt - 2)
zi = np.linalg.solve(A_mat - B_mat, b[1:nfilt] - a[1:nfilt] * b[0])
else:
zi = np.array([])
y_pad = np.concatenate([
2 * x[0] - x[nfact:0:-1],
x,
2 * x[-1] - x[-2:-nfact - 2:-1]
])
y1 = _lfilter_fifi(b, a, y_pad, zi * y_pad[0])
y1 = y1[::-1]
y2 = _lfilter_fifi(b, a, y1, zi * y1[0])
y2 = y2[::-1]
y_out = y2[nfact:len_x + nfact]
if len(orig_shape) > 1:
y_out = y_out.reshape(orig_shape)
return y_out
def minmaxall(x):
x = np.asarray(x, dtype=np.float64).ravel()
Nt = len(x)
inan = np.where(np.isnan(x))[0]
indx = np.arange(Nt)
if len(inan) > 0:
indx = np.delete(indx, inan)
x = np.delete(x, inan)
Nt = len(x)
dx = np.diff(x)
b = (dx > 0).astype(int)
db = np.diff(b)
Ind_max = np.where(db == -1)[0] + 1
Ind_min = np.where(db == 1)[0] + 1
Val_max = x[Ind_max]
Val_min = x[Ind_min]
Ind_max = Ind_max[np.argsort(-Ind_max)]
Val_max = Val_max[np.argsort(-Ind_max)]
Ind_min = Ind_min[np.argsort(-Ind_min)]
Val_min = Val_min[np.argsort(-Ind_min)]
return Val_max, Ind_max, Val_min, Ind_min
def errfunc(errorl, errorlevel):
errorl = np.asarray(errorl, dtype=np.float64).ravel()
errorlevel = np.asarray(errorlevel, dtype=np.float64).ravel()
if (errorlevel[0] == 0) and (errorl[0] > 0):
errorlevel[0] = errorl[0]
if len(errorlevel) > 1 and len(errorl) > 1:
if (errorlevel[1] == 0) and (errorl[1] > 0):
errorlevel[1] = errorl[1]
return errorlevel
def lincorn(IN, conf):
IN = np.asarray(IN, dtype=np.float64)
conf = np.asarray(conf, dtype=np.float64)
x = 0.0
errorlevel = np.zeros(2, dtype=np.float64)
Dl = conf[0]
Dr = conf[1]
Limitl = conf[2]
Limitr = conf[3]
fg1 = conf[4]
sym = conf[5]
Centerdiff = conf[6]
Itermax = conf[7]
dx = conf[8]
klevel = conf[9]
alles = conf[10]
fakfg = conf[11]
Maximumc = conf[12]
right = None
if len(conf) >= 14:
right = conf[13]
errorl = np.zeros(2, dtype=np.float64)
stop = 0
loop = 0
xalt = Dl + (Dr - Dl) / 2
fg = fg1 * fakfg
fgn = 2 * fg * dx
try:
from .filtering_utils import buttmat
except ImportError:
from filtering_utils import buttmat
BFilt1, AFilt1, _ = buttmat(fgn)
fgn = 2 * fg1 * dx
BFilt2, AFilt2, _ = buttmat(fgn)
ind_Dl = int(ind(Dl, dx, 0, len(IN)))
ind_Dr = int(ind(Dr, dx, 0, len(IN)))
range_ind = ind_Dr - ind_Dl
if range_ind > 5:
while stop == 0:
loop = loop + 1
Indiff, rechtsx, Ref = linreg(IN, Dl, Dr, dx, alles)
err_q, Maximumq = qcheck(Indiff, dx, Ref, klevel, alles)
errorlevel[0] = err_q[0]
errorlevel[1] = err_q[1]
if Maximumc == 2:
Maximum = Maximumq
else:
Maximum = Maximumc
if loop == 1:
Maximumloop1 = Maximum
if Maximumloop1 != Maximum:
errorl[0] = 13
if loop == 1:
AFilt = AFilt1
BFilt = BFilt1
else:
AFilt = AFilt2
BFilt = BFilt2
fourindiff = fifi(BFilt, AFilt, Indiff)
if right is not None:
Val_max, Ind_max, Val_min, Ind_min = minmaxall(fourindiff)
if len(Ind_max) > 0:
if right:
x = Ind_max[-1]
else:
x = Ind_max[0]
else:
try:
from .extremum_utils import minmax
except ImportError:
from extremum_utils import minmax
mwert, x = minmax(fourindiff, Maximum)
else:
try:
from .extremum_utils import minmax
except ImportError:
from extremum_utils import minmax
mwert, x = minmax(fourindiff, Maximum)
x = (x - 1) * dx + rechtsx
symnew = sym
if ((x - Limitl) < symnew):
symnew = x - Limitl
if ((Limitr - x) < symnew):
symnew = Limitr - x
Dl = x - symnew
Dr = x + symnew
if ((loop == Itermax) or ((abs(x - xalt) < Centerdiff) and (loop > 1))):
stop = 1
if Maximumq != Maximum:
errorl[0] = 13
if (int(ind(Dr, dx, 0, len(IN))) - int(ind(Dl, dx, 0, len(IN)))) < 7:
stop = 1
errorl[0] = 12
errorlevel = errfunc(errorl, errorlevel)
xalt = x
else:
errorlevel[0] = 12
return x, errorlevel
def x1_x1r_curvefit4(x, y, fun_para_static, modul_para):
x = np.asarray(x, dtype=np.float64)
y = np.asarray(y, dtype=np.float64)
# 保存原始filtlength(mm),避免Python引用传递导致的重复转换问题
if 'filtlength_mm' not in fun_para_static:
fun_para_static['filtlength_mm'] = fun_para_static.get('filtlength', 0)
errorlevel = np.zeros((2, 2), dtype=np.float64)
calcpara = np.zeros(4, dtype=np.float64)
dataout = {
'alpha0': 0, 'x1': 0, 'x1r': 0, 'alpha1': 0,
'left': {
'pos': {'result': np.nan, 'start': np.nan,
'limit': {'left': np.nan, 'right': np.nan}},
'att': {'outer': np.nan, 'inner': np.nan},
'error': np.array([np.nan, np.nan])
},
'right': {
'pos': {'result': np.nan, 'start': np.nan,
'limit': {'left': np.nan, 'right': np.nan}},
'att': {'outer': np.nan, 'inner': np.nan},
'error': np.array([np.nan, np.nan])
}
}
resnorm = np.ones(2, dtype=np.float64)
dx = x[1] - x[0]
N = len(x)
tol_fun = modul_para.get('TolFun', 1e-6)
tol_x = modul_para.get('TolX', 1e-6)
max_iter = int(modul_para.get('MaxFunEvals', 400))
contrsign = modul_para.get('contrsign', 0)
leftcut = fun_para_static['x1'] - modul_para['range_outer'] - fun_para_static['filtlength']
if leftcut < (modul_para['x1limit_l'] - fun_para_static['filtlength']):
leftcut = modul_para['x1limit_l'] - fun_para_static['filtlength']
rightcut = fun_para_static['x1'] + modul_para['range_inner'] + fun_para_static['filtlength']
if rightcut > modul_para['x1limit_r'] + fun_para_static['filtlength']:
rightcut = modul_para['x1limit_r'] + fun_para_static['filtlength']
ll = int(ind(leftcut, dx, 0, N))
rr = int(ind(rightcut, dx, 0, N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
dataoutleft = None
if len(xt) > 10:
att0, att1 = attcalcx1(xt, yt, fun_para_static['x0'], fun_para_static['x0r'],
fun_para_static['x1'], fun_para_static['x1r'], 0)
fun_startpara = x1fun3setup(fun_para_static, att0, att1)
fun_para_static['lsqn'] = 1
use_lm = (modul_para.get('LevenbergMarquardt', 0) or
fun_para_static.get('mode', 0) in (5, 6))
opt_method = 'lm' if use_lm else 'trf'
try:
result = least_squares(lambda p: x1fun3(p, fun_para_static, xt, yt)[0],
fun_startpara, method=opt_method,
ftol=tol_fun, xtol=tol_x, max_nfev=max_iter)
calcpara_left = result.x
resnorm[0] = np.sum(result.fun ** 2)
exitflag = 1 if result.success else -1
except Exception as e:
calcpara_left = fun_startpara
resnorm[0] = 1e10
exitflag = -1
_, fun_para_static['reg_sub'], _ = x1fun3(calcpara_left, fun_para_static, xt, yt)
dataoutleft = x1fun3out(calcpara_left, fun_para_static)
calcval = {'alpha0': dataoutleft['alpha0'], 'alpha1': dataoutleft['alpha1'],
'x': dataoutleft['x1']}
dataout['left']['pos']['result'] = calcval['x']
dataout['left']['att']['inner'] = calcval['alpha1']
dataout['left']['att']['outer'] = calcval['alpha0']
minxt = np.min(xt)
maxxt = np.max(xt)
contrsign = modul_para.get('contrsign', 0)
errorlevel[:, 0] = edge_error2(calcval, exitflag, resnorm[0], np.mean(yt), att0,
minxt, maxxt, modul_para['minatt1'], modul_para['maxatt1'],
modul_para['mincontr'], modul_para['maxcontr'], contrsign,
modul_para['resmax'], 0.1 * (maxxt - minxt),
0.05 * (maxxt - minxt), len(yt))
# 将左侧拟合得到的x1(即x2左侧)传递给右侧拟合作为固定值
# 虽然MATLAB原代码未显式更新,但从物理意义和拟合精度考虑需要传递
if errorlevel[0, 0] == 0 and 'x1' in dataoutleft and np.isfinite(dataoutleft['x1']):
fun_para_static['x1'] = dataoutleft['x1']
else:
errorlevel[0, 0] = 50
if fun_para_static.get('mode', 0) == 2:
fun_para_static['mode'] = 3
leftcut = fun_para_static['x1r'] - modul_para['range_inner'] - fun_para_static['filtlength']
if leftcut < (modul_para['x1rlimit_l'] - fun_para_static['filtlength']):
leftcut = modul_para['x1rlimit_l'] - fun_para_static['filtlength']
rightcut = fun_para_static['x1r'] + modul_para['range_outer'] + fun_para_static['filtlength']
if rightcut > modul_para['x1rlimit_r'] + fun_para_static['filtlength']:
rightcut = modul_para['x1rlimit_r'] + fun_para_static['filtlength']
ll = int(ind(leftcut, dx, 0, N))
rr = int(ind(rightcut, dx, 0, N))
xt = x[ll - 1:rr]
yt = y[ll - 1:rr]
dataoutright = None
if len(xt) > 10:
att0, att1 = attcalcx1(xt, yt, fun_para_static['x0'], fun_para_static['x0r'],
fun_para_static['x1'], fun_para_static['x1r'], 1)
fun_startpara = x1fun3setup(fun_para_static, att0, att1)
fun_para_static['lsqn'] = 1
use_lm_r = (modul_para.get('LevenbergMarquardt', 0) or
fun_para_static.get('mode', 0) in (5, 6))
opt_method_r = 'lm' if use_lm_r else 'trf'
try:
result = least_squares(lambda p: x1fun3(p, fun_para_static, xt, yt)[0],
fun_startpara, method=opt_method_r,
ftol=tol_fun, xtol=tol_x, max_nfev=max_iter)
calcpara_right = result.x
resnorm[1] = np.sum(result.fun ** 2)
exitflag = 1 if result.success else -1
except Exception as e:
calcpara_right = fun_startpara
resnorm[1] = 1e10
exitflag = -1
_, fun_para_static['reg_sub'], _ = x1fun3(calcpara_right, fun_para_static, xt, yt)
dataoutright = x1fun3out(calcpara_right, fun_para_static)
calcval = {'alpha0': dataoutright['alpha0'], 'alpha1': dataoutright['alpha1'],
'x': dataoutright['x1r']}
dataout['right']['pos']['result'] = calcval['x']
dataout['right']['att']['inner'] = calcval['alpha1']
dataout['right']['att']['outer'] = calcval['alpha0']
minxt = np.min(xt)
maxxt = np.max(xt)
errorlevel[:, 1] = edge_error2(calcval, exitflag, resnorm[1], np.mean(yt), att0,
minxt, maxxt, modul_para['minatt1'], modul_para['maxatt1'],
modul_para['mincontr'], modul_para['maxcontr'], contrsign,
modul_para['resmax'], 0.1 * (maxxt - minxt),
0.05 * (maxxt - minxt), len(yt))
else:
errorlevel[0, 1] = 50
if (errorlevel[0, 0] == 0) and (errorlevel[0, 1] == 0):
dataout['alpha0'] = 0.5 * (dataoutleft['alpha0'] + dataoutright['alpha0'])
dataout['x1'] = dataoutleft['x1']
dataout['x1r'] = dataoutright['x1r']
dataout['alpha1'] = 0.5 * (dataoutleft['alpha1'] + dataoutright['alpha1'])
elif errorlevel[0, 0] == 0:
dataout['alpha0'] = dataoutleft['alpha0']
dataout['x1'] = dataoutleft['x1']
dataout['x1r'] = 0
dataout['alpha1'] = dataoutleft['alpha1']
elif errorlevel[0, 1] == 0:
dataout['alpha0'] = dataoutright['alpha0']
dataout['x1'] = 0
dataout['x1r'] = dataoutright['x1r']
dataout['alpha1'] = dataoutright['alpha1']
return dataout, errorlevel, resnorm
def x1RangeLimiter(x0, x0r, xl41, xr41, NOMOSCL, NOMOSCR, FactorOSC,
NOMISCL, NOMISCR, FactorINS, CableType):
try:
from .math_utils import equal
except ImportError:
from math_utils import equal
if equal(CableType, 79):
NOMINSL = 0.5 * ((x0r - x0) - NOMOSCL - NOMOSCR)
NOMINSR = NOMINSL
else:
NOMINSL = (xl41 - x0) - NOMOSCL - NOMISCL
NOMINSR = (x0r - xr41) - NOMOSCR - NOMISCR
x1Limitr = min(x0 + NOMOSCL * FactorOSC, x0 + NOMOSCL + (NOMINSL / FactorINS))
x1rLimitl = max(x0r - NOMOSCR * FactorOSC, x0r - NOMOSCR - (NOMINSR / FactorINS))
return x1Limitr, x1rLimitl