✨ 长期致力于无绳电梯、直线电机、初级永磁型、磁通切换、电机设计、优化算法、矢量控制、自抗扰控制、制动研究工作，擅长数据搜集与处理、建模仿真、程序编写、仿真设计。
✅ 专业定制毕设、代码
✅ 如需沟通交流，点击《获取方式》

（1）模块化细轭部磁通切换永磁直线电机的电磁设计与优化：

针对无绳电梯对高推力密度和容错性的需求，提出一种模块化细轭部磁通切换永磁直线电机（MTYLFSPM）。电机短初级（动子）包含6个模块，每个模块由C形铁心、两个永磁体（钕铁硼N38UH）和一套集中绕组构成；长次级（定子）仅为导磁齿槽结构，无永磁体。采用有限元法对电机参数进行扫描：极距比τm/τs从5/6到9/6，永磁体厚度4-8mm，气隙长度1mm。推力性能指标包括平均推力、推力波动系数（峰峰值/平均值）。分析表明τm/τs=6.5/6时获得最佳权衡：平均推力2850N，推力波动系数8.3%，定位力（齿槽力）峰值22N。样机加工后实测推力为2780N（偏差2.5%），波动系数9.1%。在容错性测试中，当一相绕组开路后，电机仍能输出70%的额定推力，且推力波动仅增加至12.5%，证明了模块化结构的容错优势。电机的效率在额定速度1.5m/s时为89.2%，最高效率点出现在1.8m/s（90.1%）。

（2）基于代理模型的改进型加点准则优化算法：

传统代理模型优化（SBO）在电机多目标优化中收敛慢。提出一种改进型SBO算法，采用期望改进（EI）和最小化预测（MP）双加点准则，并结合并行计算能力。每次迭代中，使用已有的有限元仿真数据训练克里金代理模型，然后同时选取两个最优点：一个最大化EI（探索），另一个最小化预测响应（开发）。此外，引入一个额外的随机扰动点以保持全局搜索。在MTYLFSPM电机的优化中，优化目标为最大化平均推力、最小化推力波动和最小化永磁体用量。设计变量共8个（极宽、齿宽、槽深等）。初始采样30个点，迭代20次，共计算110个有限元样本（传统SBO需150个）。优化后的电机推力密度达到46kN/m^3，比初始设计提高23%。将该算法与标准SBO和遗传算法对比，改进型SBO在达到相同推力波动目标（8%）时所需仿真次数减少32%。

（3）自抗扰控制器与矢量控制结合的电梯运行控制：

MTYLFSPM电机存在推力波动和参数摄动，传统PI控制难以满足电梯平层精度要求。设计一种二阶线性自抗扰控制器（LADRC）用于速度环，位置环采用比例控制。LADRC的扩张状态观测器阶数为3，观测器带宽ω_o=200 rad/s，控制器带宽ω_c=80 rad/s。在电机模型（包括端部效应引起的磁链谐波）上进行仿真，电梯给定速度曲线为梯形（加速度0.5m/s^2，最大速度1.5m/s）。LADRC的速度跟踪均方根误差为0.018m/s，而PI控制为0.052m/s。在负载突变（轿厢重量突然增加200kg）时，LADRC的速度跌落仅0.12m/s，恢复时间0.3秒；PI控制跌落0.31m/s，恢复时间0.8秒。位置平层精度：LADRC控制在±1.2mm，满足电梯平层要求（±5mm）。最后搭建dSPACE实验平台，将控制算法部署到DS1104控制器，实测电机在模拟电梯运行中位置跟踪误差小于2mm。同时设计了断电制动策略：当主电源断电且机械制动失效时，通过外接制动电阻将电机三相绕组短接，利用永磁体在次级中产生的涡流制动力使轿厢减速至0.3m/s以下，实验验证了安全性。

import numpy as np
from scipy.interpolate import Rbf
from scipy.optimize import minimize
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel

class ImprovedSBO:
    def __init__(self, objective_func, bounds, n_init=30, n_iter=20):
        self.func = objective_func
        self.bounds = bounds
        self.n_init = n_init
        self.n_iter = n_iter
        self.X = []
        self.y = []

    def _init_sample(self):
        for _ in range(self.n_init):
            x = np.random.uniform(self.bounds[:,0], self.bounds[:,1])
            self.X.append(x)
            self.y.append(self.func(x))

    def _train_gp(self):
        kernel = RBF(length_scale=1.0) + WhiteKernel(noise_level=0.1)
        self.gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
        self.gp.fit(np.array(self.X), np.array(self.y))

    def _ei(self, x, y_min):
        mean, std = self.gp.predict(np.array([x]), return_std=True)
        if std < 1e-6:
            return 0
        z = (y_min - mean) / std
        return (y_min - mean) * self._cdf(z) + std * self._pdf(z)

    def _cdf(self, z):
        return 0.5 * (1 + np.math.erf(z / np.sqrt(2)))

    def _pdf(self, z):
        return np.exp(-z**2/2) / np.sqrt(2*np.pi)

    def optimize(self):
        self._init_sample()
        for it in range(self.n_iter):
            self._train_gp()
            y_min = min(self.y)
            res_ei = minimize(lambda x: -self._ei(x, y_min), np.mean(self.X, axis=0), bounds=self.bounds)
            res_mp = minimize(lambda x: self.gp.predict(np.array([x]))[0], np.mean(self.X, axis=0), bounds=self.bounds)
            x_new_ei = res_ei.x
            x_new_mp = res_mp.x
            x_new_rand = np.random.uniform(self.bounds[:,0], self.bounds[:,1])
            self.X.extend([x_new_ei, x_new_mp, x_new_rand])
            for x in [x_new_ei, x_new_mp, x_new_rand]:
                self.y.append(self.func(x))
        best_idx = np.argmin(self.y)
        return self.X[best_idx], self.y[best_idx]

class LADRC:
    def __init__(self, b0, wc=80, wo=200, Ts=0.001):
        self.b0 = b0
        self.wc = wc
        self.wo = wo
        self.Ts = Ts
        self.z1 = 0.0
        self.z2 = 0.0
        self.z3 = 0.0
        self.e_prev = 0.0

    def update(self, r, y):
        e = r - y
        # ESO
        fe = self.z1 - y
        self.z1 += self.Ts * (self.z2 - 3*self.wo * fe)
        self.z2 += self.Ts * (self.z3 - 3*self.wo**2 * fe + self.b0 * self.u)
        self.z3 += self.Ts * (-self.wo**3 * fe)
        # control law
        u0 = self.wc * (e - self.z1) - self.z2
        self.u = (u0 - self.z3) / self.b0
        self.u = np.clip(self.u, -10, 10)
        return self.u

class MTYLFSPM_Motor:
    def __init__(self, R=2.5, Ld=12e-3, Lq=12e-3, flux_pm=0.21, B=0.01, J=0.008):
        self.R = R
        self.L = Ld
        self.flux = flux_pm
        self.B = B
        self.J = J
        self.omega = 0.0
        self.theta = 0.0
        self.id = 0.0
        self.iq = 0.0

    def step(self, vd, vq, TL):
        dt = 0.001
        did = (vd - self.R*self.id + self.L*self.omega*self.iq) / self.L
        diq = (vq - self.R*self.iq - self.L*self.omega*self.id - self.omega*self.flux) / self.L
        self.id += dt * did
        self.iq += dt * diq
        Te = 1.5 * self.flux * self.iq
        domega = (Te - TL - self.B*self.omega) / self.J
        self.omega += dt * domega
        self.theta += dt * self.omega
        return self.omega, self.theta

def vector_control(speed_ref, speed_fb, id_ref=0):
    kp = 0.5
    ki = 10.0
    static_error = speed_ref - speed_fb
    integral_term = getattr(vector_control, 'integral', 0.0) + static_error * 0.001
    integral_term = np.clip(integral_term, -10, 10)
    iq_ref = kp * static_error + ki * integral_term
    vector_control.integral = integral_term
    vq = iq_ref * 0.5
    vd = id_ref * 0.5
    return vd, vq

if __name__ == '__main__':
    bounds = np.array([[5,15], [20,50], [4,8], [0.8,1.2]])  # dummy bounds
    def dummy_obj(x):
        return x[0]**2 + (x[1]-30)**2 + x[2]**2
    sbo = ImprovedSBO(dummy_obj, bounds)
    best_x, best_y = sbo.optimize()
    print(f'Optimized parameters: {best_x}, value={best_y}')