两个风场本地测试完毕

Temp_Diag.PY

@@ -1,357 +0,0 @@
-# @Time    : 2019-6-19
-# @Author  : wilbur.cheng@SKF
-# @FileName: baseMSET.py
-# @Software: a package in skf anomaly detection library to realize multivariate state estimation technique
-#            this package has included all the functions used in MSET, similarity calculation, state memory matrix D,
-#            normal state matrix L, residual calculation, and the basic SPRT (Sequential Probability Ratio Test)
-#            function for binary hypothesis testing.
-#
-
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from sklearn.neighbors import BallTree
-import openpyxl
-import time
-#from scikit-learn.neighbors import BallTree
-
-class MSET_Temp():
-
-    matrixD = None
-    matrixL = None
-    healthyResidual = None
-
-    normalDataBallTree = None
-
-
-
-    def __init__(self):
-        self.model = None
-
-    def _get_by_id(self, table_name, ids):
-            """Get data from MySQL database by IDs"""
-            df_res = []
-            engine = create_engine('mysql+pymysql://root:admin123456@106.120.102.238:10336/energy_data_prod')
-            for id in ids:
-                table_name=windcode+'_minute'
-                lastday_df_sql = f"SELECT * FROM {table_name} where id = {id}"
-                df = pd.read_sql(lastday_df_sql, engine)
-                df_res.append(df)
-            return df_ress
-
-    def calcSimilarity(self, x, y, m = 'euc'):
-        """
-        Calcualte the similartity of two feature vector
-        :param x: one of input feature list
-        :param y: one of input feature list
-        :param m: method of the similarity calculation method, default is the Eucilidean distance named 'euc';
-                    a city block distance function is used when m set to "cbd'.
-        :return: the two feature similarity, float, range (0,1)
-        """
-
-        if (len(x) != len(y)):
-            return 0
-
-        if (m == 'cbd'):
-            dSimilarity = [1/(1+np.abs(p-q)) for p,q in zip(x,y)]
-            dSimilarity = np.sum(dSimilarity)/len(x)
-        else:
-            dSimilarity = [np.power(p-q,2) for p, q in zip(x, y)]
-            dSimilarity = 1/(1+np.sqrt(np.sum(dSimilarity)))
-
-        return dSimilarity
-
-
-    def genDLMatrix(self, trainDataset, dataSize4D=100, dataSize4L=50):
-        """
-        automatically generate the D and L matrix from training data set, assuming the training data set is all normal
-        state data.
-        :param trainDataset: 2D array, [count of data， length of feature]
-        :param dataSize4D: minimized count of state for matrix D
-        :param dataSize4L: minimized count of state for matrix L
-        :return: 0 if successful, -1 if fail
-        """
-        [m,n] = np.shape(trainDataset)
-
-        if m < dataSize4D + dataSize4L:
-            print('training dataset is too small to generate the matrix D and L')
-            return -1
-
-        self.matrixD = []
-        selectIndex4D = []
-        # Step 1: add all the state with minimum or maximum value in each feature into Matrix D
-
-        for i in range(0, n):
-            feature_i = trainDataset[:,i]
-            minIndex = np.argmin(feature_i)
-            maxIndex = np.argmax(feature_i)
-
-            self.matrixD.append(trainDataset[minIndex, :].tolist())
-            selectIndex4D.append(minIndex)
-            self.matrixD.append(trainDataset[maxIndex, :].tolist())
-            selectIndex4D.append(maxIndex)
-
-        # Step 2: iteratively add the state with the maximum average distance to the states in selected matrixD
-        while(1):
-
-            if (len(selectIndex4D) >= dataSize4D):
-                break
-
-            # Get the free state list
-            freeStateList = list(set(np.arange(0, len(trainDataset))) - set(selectIndex4D))
-
-            # Calculate the average dist of each state in free to selected state in matrix D
-            distList = []
-            for i in freeStateList:
-                tmpState = trainDataset[i]
-                tmpDist = [1-self.calcSimilarity(x, tmpState) for x in self.matrixD]
-                distList.append(np.mean(tmpDist))
-
-            # select the free state with largest average distance to states in matrixD, and update matrixD
-            selectId = freeStateList[distList.index(np.max(distList))]
-            self.matrixD.append(trainDataset[selectId, :].tolist())
-            selectIndex4D.append(selectId)
-        #format matrixD from list to array
-        self.matrixD = np.array(self.matrixD)
-        self.normalDataBallTree = BallTree(self.matrixD, leaf_size=4, metric = lambda i,j: 1-self.calcSimilarity(i,j))
-
-
-        # Step 3. select remaining state for matrix L
-        #index4L = list(set(np.arange(0, len(trainDataset))) - set(selectIndex4D))
-        #self.matrixL = trainDataset[index4L, :]
-        # consider the limited dataset, using all the train data to matrix L
-        self.matrixL = trainDataset
-
-        # Calculate the healthy Residual from matrix L
-        lamdaRatio = 1e-3
-        [m, n] = np.shape(self.matrixD)
-        self.DDSimilarity = np.array([[1-self.calcSimilarity(x,y) for x in self.matrixD] for y in self.matrixD] + lamdaRatio*np.eye(n))
-        self.DDSimilarity = 1/self.DDSimilarity
-
-        #self.healthyResidual = self.calcResidual(self.matrixL)
-        self.healthyResidual = self.calcResidualByLocallyWeightedLR(self.matrixL)
-
-
-        return 0
-
-    def calcResidualByLocallyWeightedLR(self, newStates):
-        """
-        find the K-nearest neighbors for each input state, then calculate the estimated state by locally weighted average.
-        :param newStates: input states list
-        :return: residual R_x
-        """
-        [m,n] = np.shape(newStates)
-        est_X = []
-        # print(newStates)
-        for x in newStates:
-            (dist, iList) = self.normalDataBallTree.query([x], 20, return_distance=True)
-            weight = 1/(dist[0]+1e-1)
-            weight = weight/sum(weight)
-            eState = np.sum([w*self.matrixD[i] for w,i in zip(weight, iList[0])])
-            est_X.append(eState)
-
-        est_X = np.reshape(est_X, (len(est_X),1))
-        # print(est_X)
-        # print(newStates)
-        return est_X - newStates
-
-    def calcStateResidual(self, newsStates):
-        stateResidual = self.calcResidualByLocallyWeightedLR(newsStates)
-        return stateResidual
-
-    def calcSPRT(self, newsStates, feature_weight, alpha=0.1, beta=0.1, decisionGroup=5):
-        """
-        anomaly detection based Wald's SPRT algorithm, refer to A.Wald, Sequential Analysis,Wiley, New York, NY, USA, 1947
-        :param newsStates: input states list
-        :param feature_weight: the important weight for each feature, Normalized and Nonnegative
-        :param alpha: prescribed false alarm rate， 0 < alpha < 1
-        :param beta: prescribed miss alarm rate, 0 < beta < 1
-        :param decisionGroup: length of the test sample when the decision is done
-
-        :return: anomaly flag for each group of states, 1:anomaly, -1:normal, (-1:1): unable to decision
-        """
-
-        # Step 1. transfer the raw residual vector to dimension reduced residual using feature weight
-        #stateResidual = self.calcResidual(newsStates)
-        stateResidual = self.calcResidualByLocallyWeightedLR(newsStates)
-        # print(stateResidual)
-        weightedStateResidual = [np.dot(x, feature_weight) for x in stateResidual]
-        # print(weightedStateResidual)
-        weightedHealthyResidual = [np.dot(x, feature_weight) for x in self.healthyResidual]
-
-        '''
-        plt.subplot(211)
-        plt.plot(weightedHealthyResidual)
-        plt.xlabel('Sample index')
-        plt.ylabel('Healthy State Residual')
-        plt.subplot(212)
-        plt.plot(weightedStateResidual)
-        plt.xlabel('Sample index')
-        plt.ylabel('All State Residual')
-        plt.show()
-        '''
-        # Calculate the distribution of health state residual
-        mu0 = np.mean(weightedHealthyResidual)
-        sigma0 = np.std(weightedHealthyResidual)
-
-
-        #sigma1 = np.std(weightedStateResidual)
-
-        lowThres = np.log(beta/(1-alpha))
-        highThres = np.log((1-beta)/alpha)
-
-        flag = []
-        for i in range(0, len(newsStates)-decisionGroup+1):
-            # For each group to calculate the new state residual distribution
-            # Then check the  hypothesis testing results
-            mu1 = np.mean(weightedStateResidual[i:i+decisionGroup])
-            si = np.sum(weightedStateResidual[i:i+decisionGroup])*(mu1-mu0)/sigma0**2 - decisionGroup*(mu1**2-mu0**2)/(2*sigma0**2)
-
-            if (si > highThres):
-                si = highThres
-            if (si < lowThres):
-                si = lowThres
-
-            if (si > 0):
-                si = si/highThres
-            if (si < 0):
-                si = si/lowThres
-
-            flag.append(si)
-
-        return flag
-
-
-
-if __name__=='__main__':
-
-    start_time = time.time()
-    myMSET = MSET_Temp()
-    # 1、计算各子系统的健康度(子系统包括：发电机组、传动系统(直驱机组无齿轮箱、无数据)、机舱系统、变流器系统、电网环境、辅助系统（无数据))
-    # 1.1、发电机组健康度评分
-    # Title = pd.read_excel(r'/Users/xmia/Documents/code/Temp_Diag/34_QITAIHE.xlsx', header=None, nrows=1, usecols=[12, 13, 14])
-    # df_D = pd.read_excel(r'/Users/xmia/Documents/code/Temp_Diag/34_QITAIHE.xlsx',
-    #                        usecols=[0, 12, 13, 14], parse_dates=True)  # 读取温度指标：齿轮箱油温12、驱动侧发电机轴承温度13、非驱动侧发电机轴承温度14
-    df = pd.read_csv('/Users/xmia/Desktop/ZN/华电中光/471_QTH1125/2024/#34.csv', usecols=[
-                        'wind_turbine_number',
-                        'time_stamp', 
-                        'main_bearing_temperature', 
-                        'gearbox_oil_temperature', 
-                        'generatordrive_end_bearing_temperature', 
-                        'generatornon_drive_end_bearing_temperature'
-                    ], parse_dates=['time_stamp']) 
-    df = df[df['wind_turbine_number'] == 'WOG01312']
-    df = df.drop(columns=['wind_turbine_number'])
-    df_D = df[df['time_stamp'] > '2024-11-15']
-
-    cols = df_D.columns
-    df_D[cols] = df_D[cols].apply(pd.to_numeric, errors='coerce')
-    df_D = df_D.dropna()  # 删除空行和非数字项
-
-    x_date = df_D.iloc[len(df_D) // 2 + 1:, 0]  #获取时间序列
-    x_date = pd.to_datetime(x_date)
-    df_Temp = df_D.iloc[:, 1:]  #获取除时间列以外的数据
-    df_Temp_values = df_Temp.values
-    df_Temp_values = np.array(df_Temp_values)
-    [m, n] = np.shape(df_Temp_values)
-    # Residual = []
-    flag_Spart_data = []
-    for i in range(0, n):
-        df_Temp_i = df_Temp_values[:, i]
-        trainDataSet_data = df_Temp_i[0:len(df_Temp_i) // 2]
-        testDataSet_data = df_Temp_i[len(df_Temp_i) // 2 + 1:]
-        trainDataSet_data = np.reshape(trainDataSet_data, (len(trainDataSet_data), 1))
-        testDataSet_data = np.reshape(testDataSet_data, (len(testDataSet_data), 1))
-
-        myMSET.genDLMatrix(trainDataSet_data, 60, 5)
-        # stateResidual = self.calcStateResidual(testDataSet_data)
-        flag_data = myMSET.calcSPRT(testDataSet_data, np.array(1), decisionGroup=1)
-        # Residual.append(stateResidual)
-        flag_Spart_data.append(flag_data)
-    flag_Spart_data = np.array(flag_Spart_data)
-    flag_Spart_data = flag_Spart_data.T
-    Temp1 = flag_Spart_data[:,0]
-    Temp2 = flag_Spart_data[:,1]
-    Temp3 = flag_Spart_data[:,2]
-    Temp1_lable = "gearbox_oil_temperature"
-    Temp2_lable = "generatordrive_end_bearing_temperature"
-    Temp3_lable = "generatornon_drive_end_bearing_temperature"
-
-    print(x_date)
-
-    # alarmedFlag = np.array([[i, Temp1[i]] for i, x in enumerate(Temp1) if x > 0.99])  # Flag中选出大于0.99的点
-
-    plt.rcParams['font.sans-serif'] = ['SimHei']  # 显示中文标签
-    plt.close('all')
-    plt.subplot(311)
-    plt.plot(x_date, Temp1, 'b-o', label=Temp1_lable)
-    plt.ylabel(Temp1_lable)
-    plt.xlabel('时间')
-
-    # plt.scatter(alarmedFlag1[:, 0], alarmedFlag1[:, 2], marker='x', c='r')
-    plt.subplot(312)
-    plt.plot(x_date, Temp2)
-    plt.ylabel(Temp2_lable)
-    plt.xlabel('时间')
-    #plt.scatter(alarmedFlag[:, 0], alarmedFlag[:, 1], marker='x', c='r')
-    plt.subplot(313)
-    plt.plot(x_date, Temp3)
-    plt.ylabel(Temp3_lable)
-    plt.xlabel('时间')
-    #plt.scatter(alarmedFlag[:, 0], alarmedFlag[:, 1], marker='x', c='r')
-    plt.show()
-    print(flag_Spart_data)
-    print(np.shape(flag_Spart_data))
-
-
-    end_time = time.time()
-    execution_time = end_time - start_time
-    print(f"Execution time: {execution_time} seconds")
-
-
-
-#
-
-    '''
-    f = open("speed_vib.txt", "r")
-    data1 = f.read()
-    f.close()
-    data1 = data1.split('\n')
-    rpm = [(row.split('\t')[0]).strip() for row in data1]
-    vib = [(row.split('\t')[-1]).strip() for row in data1]
-
-    # print(rpm)
-    rpm = np.array(rpm).astype(np.float64)
-    vib = np.array(vib).astype(np.float64)
-
-    #vib = [(x-np.mean(vib))/np.std(vib) for x in vib]
-    #print(vib)
-    trainDataSet = [vib[i] for i in range(0,100) if vib[i] < 5]
-    trainDataSet = np.reshape(trainDataSet,(len(trainDataSet),1))
-    testDataSet = np.reshape(vib, (len(vib),1))
-    '''
-
-
-    # Title = pd.read_csv(r'F1710001001.csv', header=None, nrows=1, usecols=[36,37,38], encoding='gbk')
-
-    '''
-    alarmedFlag = np.array([[i, flag[i]] for i, x in enumerate(flag) if x > 0.99])  # Flag中选出大于0.99的点
-    plt.close('all')
-    plt.subplot(211)
-    plt.plot(testDataSet)
-    plt.ylabel('Vibration')
-    plt.xlabel('Sample index')
-    plt.subplot(212)
-    plt.plot(flag)
-    plt.ylabel('SPRT results')
-    plt.xlabel('Sample index')
-    plt.scatter(alarmedFlag[:,0], alarmedFlag[:,1], marker='x',c='r')
-
-    plt.show()
-    '''
-
-
-
-
-
-

cms_class_20241201.py

@@ -64,6 +64,7 @@ class CMSAnalyst:
 
         # envelope_spectrum_analysis
         # datas是[df1,df2,.....]
+        #从数据库获取原始数据
         self.datas = self._get_by_id(table_name,ids)
         self.datas = [df[['mesure_data','time_stamp','sampling_frequency','wind_turbine_number','rotational_speed','mesure_point_name']] for df in self.datas]
         # 只输入一个id，返回一个[df],所以拿到self.data[0]
@@ -73,12 +74,14 @@ class CMSAnalyst:
         self.data = np.array(ast.literal_eval(self.data_filter['mesure_data'][0]))
         self.envelope_spectrum_m = self.data.shape[0]
         self.envelope_spectrum_n = 1
+        #设置分析参数
         self.fs = int(self.data_filter['sampling_frequency'].iloc[0])
         self.envelope_spectrum_t = np.arange(self.envelope_spectrum_m) / self.fs
         self.fmin = fmin if fmin is not None else 0 
         self.fmax = fmax if fmax is not None else float('inf') 
         self.envelope_spectrum_y = self._bandpass_filter(self.data)
         self.f, self.HP = self._calculate_envelope_spectrum(self.envelope_spectrum_y)
+        #设备信息
         self.wind_code = self.data_filter['wind_turbine_number'].iloc[0]
         self.rpm_Gen = self.data_filter['rotational_speed'].iloc[0]
         self.mesure_point_name = self.data_filter['mesure_point_name'].iloc[0]
@@ -89,16 +92,16 @@ class CMSAnalyst:
         self.CF = pd.DataFrame(self.CF,index=[0])
         print(self.CF)
         print(self.rpm_Gen)
-        if self.CF['type'].iloc[0] == 'bearing':
-            n_rolls_m = self.CF['n_rolls'].iloc[0]
-            d_rolls_m = self.CF['d_rolls'].iloc[0]
-            D_diameter_m = self.CF['D_diameter'].iloc[0]
-            theta_deg_m = self.CF['theta_deg'].iloc[0]
-            print(n_rolls_m)
-            print(d_rolls_m)
-            print(D_diameter_m)
-            print(theta_deg_m)
-            self.bearing_frequencies = self.calculate_bearing_frequencies(n_rolls_m, d_rolls_m, D_diameter_m, theta_deg_m, self.rpm_Gen)
+        #if self.CF['type'].iloc[0] == 'bearing':
+        n_rolls_m = self.CF['n_rolls'].iloc[0]
+        d_rolls_m = self.CF['d_rolls'].iloc[0]
+        D_diameter_m = self.CF['D_diameter'].iloc[0]
+        theta_deg_m = self.CF['theta_deg'].iloc[0]
+        print(n_rolls_m)
+        print(d_rolls_m)
+        print(D_diameter_m)
+        print(theta_deg_m)
+        self.bearing_frequencies = self.calculate_bearing_frequencies(n_rolls_m, d_rolls_m, D_diameter_m, theta_deg_m, self.rpm_Gen)
         print(self.bearing_frequencies)
         self.bearing_frequencies = pd.DataFrame(self.bearing_frequencies,index=[0])
         print(self.bearing_frequencies)
@@ -125,7 +128,7 @@ class CMSAnalyst:
             df_res.append(df)
         return df_res
 
-    # envelope_spectrum_analysis
+    # envelope_spectrum_analysis 包络谱分析
     def _bandpass_filter(self, data):
         """带通滤波"""
         
@@ -183,38 +186,38 @@ class CMSAnalyst:
         fn_Gen = round(self.fn_Gen, 2)
         _3P_1X = round(self.fn_Gen, 2) * 3
 
-        if self.CF['type'].iloc[0] == 'bearing':
-            result = {
-                "fs":self.fs,
-                "Xrms":round(Xrms, 2),
-                "x":list(x),
-                "y":list(y),
-                "title":title,
-                "xaxis":xaxis,
-                "yaxis":yaxis,
-                "rpm_Gen": round(rpm_Gen, 2),  # 转速r/min
-                "BPFI":  [{"Xaxis": BPFI_1X ,"val": "1BPFI"},{"Xaxis": BPFI_1X*2 ,"val": "2BPFI"},
-                          {"Xaxis": BPFI_1X*3, "val": "3BPFI"}, {"Xaxis": BPFI_1X*4, "val": "4BPFI"},
-                          {"Xaxis": BPFI_1X*5, "val": "5BPFI"}, {"Xaxis": BPFI_1X*6, "val": "6BPFI"}],
-                "BPFO": [{"Xaxis": BPFO_1X ,"val": "1BPFO"},{"Xaxis": BPFO_1X*2 ,"val": "2BPFO"},
-                          {"Xaxis": BPFO_1X*3, "val": "3BPFO"}, {"Xaxis": BPFO_1X*4, "val": "4BPFO"},
-                          {"Xaxis": BPFO_1X*5, "val": "5BPFO"}, {"Xaxis": BPFO_1X*6, "val": "6BPFO"}],
-                "BSF": [{"Xaxis": BSF_1X ,"val": "1BSF"},{"Xaxis": BSF_1X*2 ,"val": "2BSF"},
-                          {"Xaxis": BSF_1X*3, "val": "3BSF"}, {"Xaxis": BSF_1X*4, "val": "4BSF"},
-                          {"Xaxis": BSF_1X*5, "val": "5BSF"}, {"Xaxis": BSF_1X*6, "val": "6BSF"}],
-                "FTF": [{"Xaxis": FTF_1X ,"val": "1FTF"},{"Xaxis": FTF_1X*2 ,"val": "2FTF"},
-                          {"Xaxis": FTF_1X*3, "val": "3FTF"}, {"Xaxis": FTF_1X*4, "val": "4FTF"},
-                          {"Xaxis": FTF_1X*5, "val": "5FTF"}, {"Xaxis": FTF_1X*6, "val": "6FTF"}],
-                "fn_Gen":[{"Xaxis": fn_Gen ,"val": "1X"},{"Xaxis": fn_Gen*2 ,"val": "2X"},
-                          {"Xaxis": fn_Gen*3, "val": "3X"}, {"Xaxis": fn_Gen*4, "val": "4X"},
-                          {"Xaxis": fn_Gen*5, "val": "5X"}, {"Xaxis": fn_Gen*6, "val": "6X"}],
-                "B3P":_3P_1X,
-            }
+        # if self.CF['type'].iloc[0] == 'bearing':
+        result = {
+            "fs":self.fs,
+            "Xrms":round(Xrms, 2),
+            "x":list(x),
+            "y":list(y),
+            "title":title,
+            "xaxis":xaxis,
+            "yaxis":yaxis,
+            "rpm_Gen": round(rpm_Gen, 2),  # 转速r/min
+            "BPFI":  [{"Xaxis": BPFI_1X ,"val": "1BPFI"},{"Xaxis": BPFI_1X*2 ,"val": "2BPFI"},
+                        {"Xaxis": BPFI_1X*3, "val": "3BPFI"}, {"Xaxis": BPFI_1X*4, "val": "4BPFI"},
+                        {"Xaxis": BPFI_1X*5, "val": "5BPFI"}, {"Xaxis": BPFI_1X*6, "val": "6BPFI"}],
+            "BPFO": [{"Xaxis": BPFO_1X ,"val": "1BPFO"},{"Xaxis": BPFO_1X*2 ,"val": "2BPFO"},
+                        {"Xaxis": BPFO_1X*3, "val": "3BPFO"}, {"Xaxis": BPFO_1X*4, "val": "4BPFO"},
+                        {"Xaxis": BPFO_1X*5, "val": "5BPFO"}, {"Xaxis": BPFO_1X*6, "val": "6BPFO"}],
+            "BSF": [{"Xaxis": BSF_1X ,"val": "1BSF"},{"Xaxis": BSF_1X*2 ,"val": "2BSF"},
+                        {"Xaxis": BSF_1X*3, "val": "3BSF"}, {"Xaxis": BSF_1X*4, "val": "4BSF"},
+                        {"Xaxis": BSF_1X*5, "val": "5BSF"}, {"Xaxis": BSF_1X*6, "val": "6BSF"}],
+            "FTF": [{"Xaxis": FTF_1X ,"val": "1FTF"},{"Xaxis": FTF_1X*2 ,"val": "2FTF"},
+                        {"Xaxis": FTF_1X*3, "val": "3FTF"}, {"Xaxis": FTF_1X*4, "val": "4FTF"},
+                        {"Xaxis": FTF_1X*5, "val": "5FTF"}, {"Xaxis": FTF_1X*6, "val": "6FTF"}],
+            "fn_Gen":[{"Xaxis": fn_Gen ,"val": "1X"},{"Xaxis": fn_Gen*2 ,"val": "2X"},
+                        {"Xaxis": fn_Gen*3, "val": "3X"}, {"Xaxis": fn_Gen*4, "val": "4X"},
+                        {"Xaxis": fn_Gen*5, "val": "5X"}, {"Xaxis": fn_Gen*6, "val": "6X"}],
+            "B3P":_3P_1X,
+        }
         # result = json.dumps(result, ensure_ascii=False)
         return result
 
 
-    # frequency_domain_analysis
+    # frequency_domain_analysis 频谱分析
 
     def _calculate_spectrum(self, data):
         """计算频谱"""
@@ -254,37 +257,37 @@ class CMSAnalyst:
         fn_Gen = round(self.fn_Gen, 2)
         _3P_1X = round(self.fn_Gen, 2) * 3
 
-        if self.CF['type'].iloc[0] == 'bearing':
-            result = {
-                "fs":self.fs,
-                "Xrms":round(Xrms, 2),
-                "x":list(x),
-                "y":list(y),
-                "title":title,
-                "xaxis":xaxis,
-                "yaxis":yaxis,
-                "rpm_Gen": round(rpm_Gen, 2),  # 转速r/min
-                "BPFI":  [{"Xaxis": BPFI_1X ,"val": "1BPFI"},{"Xaxis": BPFI_1X*2 ,"val": "2BPFI"},
-                          {"Xaxis": BPFI_1X*3, "val": "3BPFI"}, {"Xaxis": BPFI_1X*4, "val": "4BPFI"},
-                          {"Xaxis": BPFI_1X*5, "val": "5BPFI"}, {"Xaxis": BPFI_1X*6, "val": "6BPFI"}],
-                "BPFO": [{"Xaxis": BPFO_1X ,"val": "1BPFO"},{"Xaxis": BPFO_1X*2 ,"val": "2BPFO"},
-                          {"Xaxis": BPFO_1X*3, "val": "3BPFO"}, {"Xaxis": BPFO_1X*4, "val": "4BPFO"},
-                          {"Xaxis": BPFO_1X*5, "val": "5BPFO"}, {"Xaxis": BPFO_1X*6, "val": "6BPFO"}],
-                "BSF": [{"Xaxis": BSF_1X ,"val": "1BSF"},{"Xaxis": BSF_1X*2 ,"val": "2BSF"},
-                          {"Xaxis": BSF_1X*3, "val": "3BSF"}, {"Xaxis": BSF_1X*4, "val": "4BSF"},
-                          {"Xaxis": BSF_1X*5, "val": "5BSF"}, {"Xaxis": BSF_1X*6, "val": "6BSF"}],
-                "FTF": [{"Xaxis": FTF_1X ,"val": "1FTF"},{"Xaxis": FTF_1X*2 ,"val": "2FTF"},
-                          {"Xaxis": FTF_1X*3, "val": "3FTF"}, {"Xaxis": FTF_1X*4, "val": "4FTF"},
-                          {"Xaxis": FTF_1X*5, "val": "5FTF"}, {"Xaxis": FTF_1X*6, "val": "6FTF"}],
-                "fn_Gen":[{"Xaxis": fn_Gen ,"val": "1X"},{"Xaxis": fn_Gen*2 ,"val": "2X"},
-                          {"Xaxis": fn_Gen*3, "val": "3X"}, {"Xaxis": fn_Gen*4, "val": "4X"},
-                          {"Xaxis": fn_Gen*5, "val": "5X"}, {"Xaxis": fn_Gen*6, "val": "6X"}],
-                "B3P":_3P_1X,
-            }
+        # if self.CF['type'].iloc[0] == 'bearing':
+        result = {
+            "fs":self.fs,
+            "Xrms":round(Xrms, 2),
+            "x":list(x),
+            "y":list(y),
+            "title":title,
+            "xaxis":xaxis,
+            "yaxis":yaxis,
+            "rpm_Gen": round(rpm_Gen, 2),  # 转速r/min
+            "BPFI":  [{"Xaxis": BPFI_1X ,"val": "1BPFI"},{"Xaxis": BPFI_1X*2 ,"val": "2BPFI"},
+                        {"Xaxis": BPFI_1X*3, "val": "3BPFI"}, {"Xaxis": BPFI_1X*4, "val": "4BPFI"},
+                        {"Xaxis": BPFI_1X*5, "val": "5BPFI"}, {"Xaxis": BPFI_1X*6, "val": "6BPFI"}],
+            "BPFO": [{"Xaxis": BPFO_1X ,"val": "1BPFO"},{"Xaxis": BPFO_1X*2 ,"val": "2BPFO"},
+                        {"Xaxis": BPFO_1X*3, "val": "3BPFO"}, {"Xaxis": BPFO_1X*4, "val": "4BPFO"},
+                        {"Xaxis": BPFO_1X*5, "val": "5BPFO"}, {"Xaxis": BPFO_1X*6, "val": "6BPFO"}],
+            "BSF": [{"Xaxis": BSF_1X ,"val": "1BSF"},{"Xaxis": BSF_1X*2 ,"val": "2BSF"},
+                        {"Xaxis": BSF_1X*3, "val": "3BSF"}, {"Xaxis": BSF_1X*4, "val": "4BSF"},
+                        {"Xaxis": BSF_1X*5, "val": "5BSF"}, {"Xaxis": BSF_1X*6, "val": "6BSF"}],
+            "FTF": [{"Xaxis": FTF_1X ,"val": "1FTF"},{"Xaxis": FTF_1X*2 ,"val": "2FTF"},
+                        {"Xaxis": FTF_1X*3, "val": "3FTF"}, {"Xaxis": FTF_1X*4, "val": "4FTF"},
+                        {"Xaxis": FTF_1X*5, "val": "5FTF"}, {"Xaxis": FTF_1X*6, "val": "6FTF"}],
+            "fn_Gen":[{"Xaxis": fn_Gen ,"val": "1X"},{"Xaxis": fn_Gen*2 ,"val": "2X"},
+                        {"Xaxis": fn_Gen*3, "val": "3X"}, {"Xaxis": fn_Gen*4, "val": "4X"},
+                        {"Xaxis": fn_Gen*5, "val": "5X"}, {"Xaxis": fn_Gen*6, "val": "6X"}],
+            "B3P":_3P_1X,
+        }
         result = json.dumps(result, ensure_ascii=False)
         return result
 
-    # time_domain_analysis
+    # time_domain_analysis 时域分析
     def time_domain(self):
         """绘制时域波形参数"""        
         x = self.time_domain_analysis_t
@@ -342,7 +345,7 @@ class CMSAnalyst:
         return result
 
 
-    # trend_analysis
+    # trend_analysis 趋势图
 
     def trend_analysis(self):
 
@@ -412,61 +415,264 @@ class CMSAnalyst:
         all_stats = json.dumps(all_stats,  ensure_ascii=False)
         return all_stats
 
+    # def Characteristic_Frequency(self):
+    #     """提取轴承、齿轮等参数"""
+    #     # 1、从测点名称中提取部件名称（计算特征频率的部件）
+    #     str1 = self.mesure_point_name
+    #     # str2 = ["main_bearing", "front_main_bearing", "rear_main_bearing", "generator_non_drive_end"]
+    #     str2 = ["main_bearing", "front_main_bearing", "rear_main_bearing", "generator","stator","gearbox"]
+    #     for str in str2:
+    #         if str in str1:
+    #             parts = str
+    #             if parts == "front_main_bearing":
+    #                 parts = "front_bearing"
+    #             elif parts == "rear_main_bearing":
+    #                 parts = "rear_bearing"
+
+    #     print(parts)
     def Characteristic_Frequency(self):
         """提取轴承、齿轮等参数"""
         # 1、从测点名称中提取部件名称（计算特征频率的部件）
         str1 = self.mesure_point_name
-        str2 = ["main_bearing", "front_main_bearing", "rear_main_bearing", "generator_non_drive_end"]
-        for str in str2:
-            if str in str1:
-                parts = str
-                if parts == "front_main_bearing":
-                    parts = "front_bearing"
-                elif parts == "rear_main_bearing":
-                    parts = "rear_bearing"
-
-        print(parts)
+        # str2 = ["main_bearing", "front_main_bearing", "rear_main_bearing", "generator_non_drive_end"]
+        # str2 = ["main_bearing", "front_main_bearing", "rear_main_bearing", "generator","stator","gearbox"]
+        # for str in str2:
+        #     if str in str1:
+        #         parts = str
+        #         # if parts == "front_main_bearing":
+        #         #     parts = "front_bearing"
+        #         # elif parts == "rear_main_bearing":
+        #         #     parts = "rear_bearing"
+        print(str1)
 
         # 2、连接233的数据库'energy_show'，从表'wind_engine_group'查找风机编号'engine_code'对应的机型编号'mill_type_code'
         engine_code = self.wind_code
+        print(engine_code)
         Engine2 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
-        df_sql2 = f"SELECT * FROM {'wind_engine_group'} where engine_code = {'engine_code'} "
+        # df_sql2 = f"SELECT * FROM {'wind_engine_group'} where engine_code = {'engine_code'} "
+        df_sql2 = f"SELECT * FROM wind_engine_group WHERE engine_code = '{engine_code}'"
         df2 = pd.read_sql(df_sql2, Engine2)
         mill_type_code = df2['mill_type_code'].iloc[0]
         print(mill_type_code)
 
-        # 3、从表'unit_bearings'中通过机型编号'mill_type_code'查找部件'brand'、'model'的参数信息
+        # # 3、从表'unit_bearings'中通过机型编号'mill_type_code'查找部件'brand'、'model'的参数信息
+        # Engine3 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
+        # #unit_bearings是主轴承的参数 
+        # df_sql3 = f"SELECT * FROM {'unit_bearings'} where mill_type_code = {'mill_type_code'} "
+        # df3 = pd.read_sql(df_sql3, Engine3)
+        # brand = 'front_bearing' + '_brand'  # parts代替'front_bearing'
+        # model = 'front_bearing' + '_model'  # parts代替'front_bearing'
+        # print(brand)
+        # _brand = df3[brand].iloc[0]
+        # _model = df3[model].iloc[0]
+        # print(_brand)
+        # print(_model)
+
+        # 3、从相关的表中通过机型编号'mill_type_code'或者齿轮箱编号gearbox_code查找部件'brand'、'model'的参数信息
         Engine3 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
-        df_sql3 = f"SELECT * FROM {'unit_bearings'} where mill_type_code = {'mill_type_code'} "
-        df3 = pd.read_sql(df_sql3, Engine3)
-        brand = 'front_bearing' + '_brand'  # parts代替'front_bearing'
-        model = 'front_bearing' + '_model'  # parts代替'front_bearing'
-        print(brand)
-        _brand = df3[brand].iloc[0]
-        _model = df3[model].iloc[0]
-        print(_brand)
-        print(_model)
-
+        #unit_bearings主轴承参数表 关键词"main_bearing"
+        if 'main_bearing' in str1:
+            print("main_bearing")
+            # df_sql3 = f"SELECT * FROM {'unit_bearings'} where mill_type_code = {'mill_type_code'} "
+            df_sql3 = f"SELECT * FROM unit_bearings WHERE mill_type_code = '{mill_type_code}' "            
+            df3 = pd.read_sql(df_sql3, Engine3)
+            if df3.empty:
+                print("警告: 没有找到有效的机型信息")   
+            if 'front' in str1:
+                brand = 'front_bearing' + '_brand'  
+                model = 'front_bearing' + '_model'  
+                front_has_value = not pd.isna(df3[brand].iloc[0]) and not pd.isna(df3[model].iloc[0]) 
+                if not  front_has_value:
+                    print("警告: 没有找到有效的品牌信息")
+            elif 'rear' in str1:
+                brand = 'rear_bearing' + '_brand'  
+                model = 'rear_bearing' + '_model'  
+                end_has_value = not pd.isna(df3[brand].iloc[0]) and not pd.isna(df3[model].iloc[0])       
+                if not  end_has_value:
+                    print("警告: 没有找到有效的品牌信息")                
+            else:
+                # 当没有指定 front 或 end 时，自动选择有值的轴承信息
+                front_brand_col = 'front_bearing_brand'
+                front_model_col = 'front_bearing_model'
+                rear_brand_col = 'rear_bearing_brand'
+                rear_model_col = 'rear_bearing_model'
+                # 检查 front_bearing 是否有值
+                front_has_value = not pd.isna(df3[front_brand_col].iloc[0]) and not pd.isna(df3[front_model_col].iloc[0])                
+                # 检查 end_bearing 是否有值
+                end_has_value = not pd.isna(df3[rear_brand_col].iloc[0]) and not pd.isna(df3[rear_model_col].iloc[0])               
+                # 根据检查结果选择合适的列
+                if front_has_value and end_has_value:
+                    # 如果两者都有值，默认选择 front
+                    brand = front_brand_col
+                    model = front_model_col
+                elif front_has_value:
+                    brand = front_brand_col
+                    model = front_model_col
+                elif end_has_value:
+                    brand = rear_brand_col
+                    model = rear_model_col
+                else:
+                    # 如果两者都没有有效值，设置默认值或抛出异常
+                    print("警告: 没有找到有效的轴承信息")
+                    brand = front_brand_col  # 默认使用 front
+                    model = front_model_col  # 默认使用 front
+            print(brand)
+            _brand = df3[brand].iloc[0]
+            _model = df3[model].iloc[0]
+            print(_brand)
+            print(_model)     
+        #unit_dynamo 发电机参数表 关键词generator stator
+        elif 'generator'in str1 or 'stator' in str1:
+            print("generator or 'stator'")
+            # df_sql3 = f"SELECT * FROM {'unit_dynamo'} where mill_type_code = {'mill_type_code'} "
+            df_sql3 = f"SELECT * FROM unit_dynamo WHERE mill_type_code = '{mill_type_code}' "
+            df3 = pd.read_sql(df_sql3, Engine3)
+            if 'non' in str1:
+                brand = 'non_drive_end_bearing' + '_brand'  
+                model = 'non_drive_end_bearing' + '_model'  
+            else:
+                brand = 'drive_end_bearing' + '_brand'  
+                model = 'drive_end_bearing' + '_model'              
+            print(brand)
+            _brand = df3[brand].iloc[0]
+            _model = df3[model].iloc[0]
+            print(_brand)
+            print(_model)       
+
+         #齿轮箱区分行星轮/平行轮 和 轴承两个表
+        elif 'gearbox' in str1:
+            print("gearbox")
+            #根据mill_type_code从unit_gearbox表中获得gearbox_code
+            df_sql3 = f"SELECT * FROM unit_gearbox WHERE mill_type_code = '{mill_type_code}' "
+            df3 = pd.read_sql(df_sql3, Engine3)
+            gearbox_code =df3['code'].iloc[0]
+            print(gearbox_code)
+            Engine33 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
+             #如果是行星轮/平行轮 则从unit_gearbox_structure 表中取数据
+            if 'planet'in str1 or 'sun' in str1:
+                print("'planet' or 'sun' ")
+                gearbox_structure =1 if 'planet'in str1 else 2
+                planetary_gear_grade =1
+                if 'first' in str1:
+                    planetary_gear_grade =1
+                elif 'second'in str1:
+                    planetary_gear_grade =2
+                elif 'third'in str1:
+                    planetary_gear_grade =3
+                # df_sql33 = f"SELECT * FROM unit_gearbox_structure WHERE gearbox_code = '{gearbox_code}' "
+                df_sql33 = f"""
+                SELECT bearing_brand, bearing_model 
+                FROM unit_gearbox_structure 
+                    WHERE gearbox_code = '{gearbox_code}' 
+                    AND gearbox_structure = '{gearbox_structure}'
+                    AND planetary_gear_grade = '{planetary_gear_grade}'
+                    """
+                df33 = pd.read_sql(df_sql33, Engine33)
+                if df33.empty:
+                    print("unit_gearbox_structure没有该测点的参数")
+                else:
+                    brand = 'bearing' + '_brand'  
+                    model = 'bearing' + '_model'  
+                    print(brand)
+                    _brand = df33[brand].iloc[0]
+                    _model = df33[model].iloc[0]
+                    has_value = not pd.isna(df33[brand].iloc[0]) and not pd.isna(df33[model].iloc[0])
+                    if has_value:   
+                        print(_brand)
+                        print(_model)   
+                    else:
+                        print("警告: 没有找到有效的轴承信息")
+             #如果是齿轮箱轴承 则从unit_gearbox_bearings 表中取数据
+            elif 'shaft' in str1 or'input' in str1:
+                print("'shaft'or'input'")
+                # df_sql33 = f"SELECT * FROM unit_gearbox_bearings WHERE gearbox_code = '{gearbox_code}' "
+                # df33 = pd.read_sql(df_sql33, Engine33)
+                #高速轴 低速中间轴 取bearing_rs/gs均可
+                parallel_wheel_grade=1
+                if 'low_speed' in str1:
+                    parallel_wheel_grade =3                
+                elif 'low_speed_intermediate' in str1:
+                    parallel_wheel_grade =3
+                elif 'high_speed' in str1:
+                    parallel_wheel_grade =3    
+                # df_sql33 = f"SELECT * FROM unit_gearbox_bearings WHERE gearbox_code = '{gearbox_code}' "
+                df_sql33 = f"""
+                SELECT bearing_rs_brand, bearing_rs_model, bearing_gs_brand, bearing_gs_model 
+                FROM unit_gearbox_bearings 
+                WHERE gearbox_code = '{gearbox_code}'
+                AND parallel_wheel_grade = '{parallel_wheel_grade}'
+                """
+                df33 = pd.read_sql(df_sql33, Engine33)
+                if not df33.empty:
+                    if 'high_speed' in str1 or 'low_speed_intermediate' in str1:
+                        rs_brand = 'bearing_rs' + '_brand'  
+                        rs_model = 'bearing_rs' + '_model'  
+                        gs_brand = 'bearing_gs' + '_brand'  
+                        gs_model = 'bearing_gs' + '_model'  
+                        rs_has_value = not pd.isna(df33[rs_brand].iloc[0]) and not pd.isna(df33[rs_model].iloc[0])     
+                        gs_has_value = not pd.isna(df33[gs_brand].iloc[0]) and not pd.isna(df33[gs_model].iloc[0])    
+                        if rs_has_value and gs_has_value:
+                            brand = rs_brand
+                            model = rs_model
+                        elif rs_has_value:
+                            brand = rs_brand
+                            model = rs_model
+                        elif gs_has_value:
+                            brand = gs_brand
+                            model = gs_model
+                        else:
+                            print("警告: 没有找到有效的品牌信息")
+                            brand = rs_brand 
+                            model = rs_model 
+                    #低速轴 取bearing_model          
+                    elif 'low_speed'in str1:
+                        brand = 'bearing' + '_brand'  
+                        model = 'bearing' + '_model'
+                else:
+                    print("警告: 没有找到有效的轴承信息")     
+                print(brand)
+                _brand = df33[brand].iloc[0]
+                _model = df33[model].iloc[0]
+                print(_brand)
+                print(_model)   
+
+        # # 4、从表'unit_dict_brand_model'中通过'_brand'、'_model'查找部件的参数信息
+        # Engine4 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
+        # df_sql4 = f"SELECT * FROM unit_dict_brand_model where manufacture = %s AND model_number = %s"
+        # params = [(_brand, _model)]
+        # df4 = pd.read_sql(df_sql4, Engine4, params=params)
+        # if 'bearing' in parts:
+        #     n_rolls = df4['rolls_number'].iloc[0]
+        #     d_rolls = df4['rolls_diameter'].iloc[0]
+        #     D_diameter = df4['circle_diameter'].iloc[0]
+        #     theta_deg = df4['theta_deg'].iloc[0]
+        #     result = {
+        #         "type":'bearing',
+        #         "n_rolls":round(n_rolls, 2),
+        #         "d_rolls":round(d_rolls, 2),
+        #         "D_diameter":round(D_diameter, 2),
+        #         "theta_deg":round(theta_deg, 2),
+        #     }
+        # # result = json.dumps(result, ensure_ascii=False)
+        #     return result
         # 4、从表'unit_dict_brand_model'中通过'_brand'、'_model'查找部件的参数信息
         Engine4 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
         df_sql4 = f"SELECT * FROM unit_dict_brand_model where manufacture = %s AND model_number = %s"
         params = [(_brand, _model)]
         df4 = pd.read_sql(df_sql4, Engine4, params=params)
-        if 'bearing' in parts:
-            n_rolls = df4['rolls_number'].iloc[0]
-            d_rolls = df4['rolls_diameter'].iloc[0]
-            D_diameter = df4['circle_diameter'].iloc[0]
-            theta_deg = df4['theta_deg'].iloc[0]
-            result = {
-                "type":'bearing',
-                "n_rolls":round(n_rolls, 2),
-                "d_rolls":round(d_rolls, 2),
-                "D_diameter":round(D_diameter, 2),
-                "theta_deg":round(theta_deg, 2),
-            }
-        # result = json.dumps(result, ensure_ascii=False)
-            return result
-
+        n_rolls = df4['rolls_number'].iloc[0]
+        d_rolls = df4['rolls_diameter'].iloc[0]
+        D_diameter = df4['circle_diameter'].iloc[0]
+        theta_deg = df4['theta_deg'].iloc[0]
+        result = {
+            "type":'bearing',
+            "n_rolls":round(n_rolls, 2),
+            "d_rolls":round(d_rolls, 2),
+            "D_diameter":round(D_diameter, 2),
+            "theta_deg":round(theta_deg, 2),
+        }
+    # result = json.dumps(result, ensure_ascii=False)
+        return result
     def calculate_bearing_frequencies(self, n, d, D, theta_deg, rpm):
         """
         计算轴承各部件特征频率

connect mysql.py

@@ -7,6 +7,78 @@ import pymysql
 from sqlalchemy import create_engine, text
 import math
 
+# # 与志亮的数据库连接
+
+# #1、定义从235数据库中通过“windcode”风场编号和'ids'id号来查找波形数据记录
+# def _get_by_id(windcode, ids):
+#     df_res = []
+#     engine = create_engine('mysql+pymysql://root:admin123456@106.120.102.238:10336/energy_data_prod')
+#     for id in ids:
+#         table_name = windcode + '_wave'
+#         lastday_df_sql = f"SELECT * FROM {table_name} where id = {id} "
+#         # print(lastday_df_sql)
+#         df = pd.read_sql(lastday_df_sql, engine)
+#         df_res.append(df)
+#     return df_res
+
+# #2、找到波形记录提取特定的列值
+# datas = _get_by_id('WOF091200030', [115041])
+# datas = [df[['mesure_data','time_stamp','sampling_frequency', 'wind_turbine_number', 'rotational_speed', 'mesure_point_name']] for df in datas]
+# data_filter = datas[0]
+# rpm_Gen = data_filter['rotational_speed'].iloc[0]
+# wind_code = data_filter['wind_turbine_number'].iloc[0]
+# mesure_point_name = data_filter['mesure_point_name'].iloc[0]
+# fs = int(data_filter['sampling_frequency'].iloc[0])
+# print(wind_code)
+# print(fs)
+# print(rpm_Gen)
+
+# #3、从测点名称中提取部件名称（计算特征频率的部件）
+# str1 = mesure_point_name
+# str2 = ["main_bearing", "front_main_bearing", "rear_main_bearing", "generator_non_drive_end"]
+# for str in str2:
+#     if str in str1:
+#         parts = str
+#         if parts == "front_main_bearing":
+#             parts = "front_bearing"
+#         elif parts == "rear_main_bearing":
+#             parts = "rear_bearing"
+# print(parts)
+
+# #4、连接233的数据库'energy_show'，从表'wind_engine_group'查找风机编号'engine_code'对应的机型编号'mill_type_code'
+# engine_code = wind_code
+# Engine2 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
+# df_sql2 = f"SELECT * FROM {'wind_engine_group'} where engine_code = {'engine_code'} "
+# df2 = pd.read_sql(df_sql2, Engine2)
+# mill_type_code = df2['mill_type_code'].iloc[0]
+# print(mill_type_code)
+
+# #5、从表'unit_bearings'中通过机型编号'mill_type_code'查找部件'brand'、'model'的参数信息
+# Engine3 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
+# df_sql3 = f"SELECT * FROM {'unit_bearings'} where mill_type_code = {'mill_type_code'} "
+# df3 = pd.read_sql(df_sql3, Engine3)
+# brand = parts+'_brand'            # parts代替'front_bearing'
+# model = parts +'_model'           # parts代替'front_bearing'
+# print(brand)
+# _brand = df3[brand].iloc[0]
+# _model = df3[model].iloc[0]
+# print(_brand)
+# print(_model)
+
+# #6、从表'unit_dict_brand_model'中通过'_brand'、'_model'查找部件的参数信息
+# Engine4 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
+# df_sql4 = f"SELECT * FROM unit_dict_brand_model where manufacture = %s AND model_number = %s"
+# params = [(_brand,  _model)]
+# df4 = pd.read_sql(df_sql4, Engine4, params=params)
+# if 'bearing' in parts:
+#     n_rolls = df4['rolls_number'].iloc[0]
+#     d_rolls = df4['rolls_diameter'].iloc[0]
+#     D_diameter = df4['circle_diameter'].iloc[0]
+#     theta_deg = df4['theta_deg'].iloc[0]
+# print(n_rolls)
+# print(d_rolls)
+# print(D_diameter)
+# print(theta_deg)
 # 与志亮的数据库连接
 
 #1、定义从235数据库中通过“windcode”风场编号和'ids'id号来查找波形数据记录
@@ -35,14 +107,14 @@ print(rpm_Gen)
 
 #3、从测点名称中提取部件名称（计算特征频率的部件）
 str1 = mesure_point_name
-str2 = ["main_bearing", "front_main_bearing", "rear_main_bearing", "generator_non_drive_end"]
+str2 = ["main_bearing", "front_main_bearing", "rear_main_bearing", "generator","stator","gearbox"]
 for str in str2:
     if str in str1:
         parts = str
-        if parts == "front_main_bearing":
-            parts = "front_bearing"
-        elif parts == "rear_main_bearing":
-            parts = "rear_bearing"
+        # if parts == "front_main_bearing":
+        #     parts = "front_bearing"
+        # elif parts == "rear_main_bearing":
+        #     parts = "rear_bearing"
 print(parts)
 
 #4、连接233的数据库'energy_show'，从表'wind_engine_group'查找风机编号'engine_code'对应的机型编号'mill_type_code'
@@ -55,10 +127,10 @@ print(mill_type_code)
 
 #5、从表'unit_bearings'中通过机型编号'mill_type_code'查找部件'brand'、'model'的参数信息
 Engine3 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show')
-df_sql3 = f"SELECT * FROM {'unit_bearings'} where mill_type_code = {'mill_type_code'} "
+df_sql3 = f"SELECT * FROM {'unit_dynamo'} where mill_type_code = {'mill_type_code'} "
 df3 = pd.read_sql(df_sql3, Engine3)
-brand = parts+'_brand'            # parts代替'front_bearing'
-model = parts +'_model'           # parts代替'front_bearing'
+brand = 'end_bearing'+'_brand'            # parts代替'front_bearing'
+model = 'end_bearing' +'_model'           # parts代替'front_bearing'
 print(brand)
 _brand = df3[brand].iloc[0]
 _model = df3[model].iloc[0]
@@ -70,16 +142,14 @@ Engine4 = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306
 df_sql4 = f"SELECT * FROM unit_dict_brand_model where manufacture = %s AND model_number = %s"
 params = [(_brand,  _model)]
 df4 = pd.read_sql(df_sql4, Engine4, params=params)
-if 'bearing' in parts:
-    n_rolls = df4['rolls_number'].iloc[0]
-    d_rolls = df4['rolls_diameter'].iloc[0]
-    D_diameter = df4['circle_diameter'].iloc[0]
-    theta_deg = df4['theta_deg'].iloc[0]
+n_rolls = df4['rolls_number'].iloc[0]
+d_rolls = df4['rolls_diameter'].iloc[0]
+D_diameter = df4['circle_diameter'].iloc[0]
+theta_deg = df4['theta_deg'].iloc[0]
 print(n_rolls)
 print(d_rolls)
 print(D_diameter)
 print(theta_deg)
-
 def calculate_bearing_frequencies(n, d, D, theta_deg, rpm):
     """
     计算轴承各部件特征频率