energy-data-trans/tmp_file/ClassIdentifier_1.py_bak

import numpy as np
from pandas import DataFrame

from service.plt_service import get_base_wind_and_power
from utils.file.trans_methods import read_file_to_df


class ClassIdentifier(object):

    def __init__(self, wind_turbine_number, file_path: str = None, origin_df: DataFrame = None, index='time_stamp',
                 wind_velocity='wind_velocity',
                 active_power='active_power'):
        """
        :param wind_turbine_number: The wind turbine number.
        :param file_path: The file path of the input data.
        :param origin_df: The pandas DataFrame containing the input data.
        :param index: 索引字段
        :param wind_velocity: 风速字段
        :param active_power: 有功功率字段
        """
        self.wind_turbine_number = wind_turbine_number
        self.index = index
        self.wind_velocity = wind_velocity
        self.active_power = active_power

        self.rated_wind_speed = 'rated_wind_speed'
        self.rated_capacity = 'rated_capacity'

        if file_path is None and origin_df is None:
            raise ValueError("Either file_path or origin_df should be provided.")

        if file_path:
            self.df = read_file_to_df(file_path)
        else:
            self.df = origin_df

        self.df = self.df.set_index(keys=self.index)

    def identifier(self):
        # 风速 和 有功功率 df
        wind_and_power_df = self.df[[self.wind_velocity, self.active_power]]
        wind_and_power_df.reset_index(inplace=True)
        wind_and_power_df_count = wind_and_power_df.shape[0]
        PowerMax = wind_and_power_df[self.active_power].max()
        PowerRated = np.ceil(PowerMax / 100) * 100
        PRated = 1500  # 额定功率1500kw,可改为2000kw
        VCutOut = 25
        VCutIn = 3
        VRated = 10
        # 网格法确定风速风向分区数量，功率方向分区数量，
        # PNum = (PRated+100)/25  #功率分区间隔25kW
        PNum = int(np.ceil(PowerRated / 25))  # 功率分区间隔25kW
        VNum = int(np.ceil(VCutOut / 0.25))  # 风速分区间隔0.25m/s

        # 实发电量
        EPActualTotal = 0  # 实发电量
        for i in range(wind_and_power_df_count):
            if wind_and_power_df.loc[i, self.active_power] >= 0:
                EPActualTotal = EPActualTotal + wind_and_power_df.loc[i, self.active_power] / 6

        print("EPActualTotal", EPActualTotal)
        # 平均风速
        WindSpeedAvr = 0
        WindSum = 0
        for i in range(wind_and_power_df_count):
            if wind_and_power_df.loc[i, self.wind_velocity] >= 0:
                WindSum = WindSum + wind_and_power_df.loc[i, self.wind_velocity]
        WindSpeedAvr = WindSum / wind_and_power_df_count
        print("windSpeedAvr", WindSpeedAvr)
        # 用于计算损失电量的标杆功率曲线，可更换为风机设计功率曲线
        # base_wind_and_power_df = get_base_wind_and_power(self.wind_turbine_number)
        base_wind_and_power_df = read_file_to_df(r"D:\中能智能\matlib计算相关\好点坏点matlib计算\A型风机设计功率曲线.csv", header=None)
        base_wind_and_power_df.columns = [self.rated_wind_speed, self.rated_capacity]
        if base_wind_and_power_df.empty:
            raise ValueError("风场编号:" + self.wind_turbine_number + "未查询到风速功率信息")
        base_wind_and_power_count = base_wind_and_power_df.shape[0]

        # 风机可利用率，计算方法：大于切入风速但发电功率小于0
        TurbineRunRate = 0
        nShouldGP = 0
        nRealGP = 0
        for i in range(wind_and_power_df_count):
            if wind_and_power_df.loc[i, self.wind_velocity] >= VCutIn:
                nShouldGP = nShouldGP + 1
                if wind_and_power_df.loc[i, self.active_power] > 0:
                    nRealGP = nRealGP + 1
        if nShouldGP > 0:
            TurbineRunRate = nRealGP / nShouldGP * 100

        print("disp(TurbineRunRate)", TurbineRunRate)
        # 理论电量-
        EPIdealTotalAAA = 0  # 理论电量-
        nWhichBin = 0
        IdealPower = 0
        for i in range(wind_and_power_df_count):
            # 应发电量-理论
            nWhichBin = 0
            for m in range(base_wind_and_power_count - 1):
                if base_wind_and_power_df.loc[m, self.rated_wind_speed] < wind_and_power_df.loc[
                    i, self.wind_velocity] <= \
                        base_wind_and_power_df.loc[m + 1, self.rated_wind_speed]:
                    nWhichBin = m
                    break

            # 插值计算对应设计功率
            if nWhichBin > base_wind_and_power_count - 1 or nWhichBin == 0:
                continue

            IdealPower = (wind_and_power_df.loc[i, self.wind_velocity] - base_wind_and_power_df.loc[nWhichBin,
                                                                                                    self.rated_wind_speed]) / (
                                 base_wind_and_power_df.loc[nWhichBin + 1, self.rated_wind_speed] -
                                 base_wind_and_power_df.loc[nWhichBin, self.rated_wind_speed]) * (
                                 base_wind_and_power_df.loc[nWhichBin + 1, self.rated_capacity] -
                                 base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]) \
                         + base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]
            EPIdealTotalAAA = EPIdealTotalAAA + IdealPower / 6

        print('EPIdealTotalAAA', EPIdealTotalAAA)
        #
        # 存储功率大于零的运行数据
        DzMarch809 = np.zeros([wind_and_power_df_count, 2], dtype=float)
        nCounter1 = 0
        for i in range(wind_and_power_df_count):
            if wind_and_power_df.loc[i, self.active_power] > 0:
                DzMarch809[nCounter1, 0] = wind_and_power_df.loc[i, self.wind_velocity]
                DzMarch809[nCounter1, 1] = wind_and_power_df.loc[i, self.active_power]

                nCounter1 = nCounter1 + 1

        print('nCounter1', nCounter1)

        # 统计各网格落入的散点个数
        XBoxNumber = np.ones([PNum, VNum], dtype=int)
        nWhichP = -1
        nWhichV = -1
        for i in range(nCounter1):
            for m in range(PNum):
                if m * 25 < DzMarch809[i, 1] <= (m + 1) * 25:
                    nWhichP = m
                    break
            for n in range(VNum):
                if ((n + 1) * 0.25 - 0.125) < DzMarch809[i, 0] <= ((n + 1) * 0.25 + 0.125):
                    nWhichV = n
                    break

            if nWhichP > -1 and nWhichV > -1:
                XBoxNumber[nWhichP, nWhichV] = XBoxNumber[nWhichP, nWhichV] + 1

        for m in range(PNum):
            for n in range(VNum):
                XBoxNumber[m, n] = XBoxNumber[m, n] - 1

        print('XBoxNumber', XBoxNumber)
        # 在功率方向将网格内散点绝对个数转换为相对百分比，备用
        PBoxPercent = np.zeros([PNum, VNum], dtype=float)
        PBinSum = np.zeros(PNum, dtype=int)

        for i in range(PNum):
            for m in range(VNum):
                PBinSum[i] = PBinSum[i] + XBoxNumber[i, m]

            for m in range(VNum):
                if PBinSum[i] > 0:
                    PBoxPercent[i, m] = XBoxNumber[i, m] / PBinSum[i] * 100

        # 在风速方向将网格内散点绝对个数转换为相对百分比，备用
        VBoxPercent = np.zeros([PNum, VNum], dtype=float)
        VBinSum = np.zeros(VNum, dtype=int)

        for i in range(VNum):
            for m in range(PNum):
                VBinSum[i] = VBinSum[i] + XBoxNumber[m, i]

            for m in range(PNum):
                if VBinSum[i] > 0:
                    VBoxPercent[m, i] = XBoxNumber[m, i] / VBinSum[i] * 100

        # 以水平功率带方向为准，分析每个水平功率带中，功率主带中心，即找百分比最大的网格位置。
        PBoxMaxIndex = np.zeros(PNum, dtype=int)  # 水平功率带最大网格位置索引
        PBoxMaxP = np.zeros(PNum, dtype=int)  # 水平功率带最大网格百分比

        for m in range(PNum):
            # 确定每一水平功率带的最大网格位置索引即百分比值
            PBoxMaxP[m], PBoxMaxIndex[m] = PBoxPercent[m, :].max(), PBoxPercent[m, :].argmax()

        # 以垂直风速方向为准，分析每个垂直风速带中，功率主带中心，即找百分比最大的网格位置。
        VBoxMaxIndex = np.zeros(VNum, dtype=int)
        VBoxMaxV = np.zeros(VNum, dtype=int)

        for m in range(VNum):
            [VBoxMaxV[m], VBoxMaxIndex[m]] = VBoxPercent[:, m].max(), VBoxPercent[:, m].argmax()

        # 切入风速特殊处理，如果切入风速过于偏右，向左拉回
        if PBoxMaxIndex[0] > 14:
            PBoxMaxIndex[0] = 9

        # 以水平功率带方向为基准，进行分析
        DotDense = np.zeros(PNum, dtype=int)  # 每一水平功率带的功率主带包含的网格数
        DotDenseLeftRight = np.zeros([PNum, 2], dtype=int)  # 存储每一水平功率带的功率主带以最大网格为中心，向向左，向右扩展的网格数
        DotValve = 90  # 从中心向左右对称扩展网格的散点百分比和的阈值。
        PDotDenseSum = 0

        iSpreadLeft = 1  # 向左扩展网格计数，初值为1
        iSpreadRight = 1  # 向右扩展网格技术，初值为1
        for i in range(PNum - 6):  # 从最下层水平功率带1开始，向上到第PNum-6个水平功率带（额定功率一下水平功率带），逐一分析
            PDotDenseSum = PBoxMaxP[i]  # 以中心最大水平功率带为基准，向左向右对称扩展网格，累加各网格散点百分比
            iSpreadRight = 1
            iSpreadLeft = 1
            while PDotDenseSum < DotValve:

                if (PBoxMaxIndex[i] + iSpreadRight) < VNum - 1:
                    PDotDenseSum = PDotDenseSum + PBoxPercent[i, PBoxMaxIndex[i] + iSpreadRight]  # 向右侧扩展
                    iSpreadRight = iSpreadRight + 1

                if (PBoxMaxIndex[i] + iSpreadRight) > VNum - 1:
                    break

                if (PBoxMaxIndex[i] - iSpreadLeft) > 0:
                    PDotDenseSum = PDotDenseSum + PBoxPercent[i, PBoxMaxIndex[i] - iSpreadLeft]  # 向左侧扩展
                    iSpreadLeft = iSpreadLeft + 1

                if (PBoxMaxIndex[i] - iSpreadLeft) <= 0:
                    break

            iSpreadRight = iSpreadRight - 1

            iSpreadLeft = iSpreadLeft - 1
            # 向左右对称扩展完毕

            DotDenseLeftRight[i, 0] = iSpreadLeft
            DotDenseLeftRight[i, 1] = iSpreadRight
            DotDense[i] = iSpreadLeft + iSpreadRight + 1

        # 各行功率主带右侧宽度的中位数最具有代表性
        DotDenseWidthLeft = np.zeros([PNum - 6, 1], dtype=int)
        for i in range(PNum - 6):
            DotDenseWidthLeft[i] = DotDenseLeftRight[i, 1]

        MainBandRight = np.median(DotDenseWidthLeft)

        # 散点向右显著延展分布的水平功率带为限功率水平带
        PowerLimit = np.zeros([PNum, 1], dtype=int)  # 各水平功率带是否为限功率标识，==1：是；==0：不是
        WidthAverage = 0  # 功率主带平均宽度
        WidthVar = 0  # 功率主带方差
        # PowerLimitValve = 6    #限功率主带判别阈值
        PowerLimitValve = np.ceil(MainBandRight) + 3  # 限功率主带判别阈值

        nCounterLimit = 0
        nCounter = 0

        for i in range(PNum - 6):
            if DotDenseLeftRight[i, 1] > PowerLimitValve and PBinSum[i] > 20:  # 如果向右扩展网格数大于阈值，且该水平功率带点总数>20，是
                PowerLimit[i] = 1
                nCounterLimit = nCounterLimit + 1

            if DotDenseLeftRight[i, 1] <= PowerLimitValve:
                WidthAverage = WidthAverage + DotDenseLeftRight[i, 1]  # 统计正常水平功率带右侧宽度
                nCounter = nCounter + 1

        WidthAverage = WidthAverage / nCounter  # 功率主带平均宽度

        print("WidthAverage", WidthAverage)

        # 各水平功率带的功率主带宽度的方差，反映从下到上宽度是否一致，或是否下宽上窄等异常情况
        for i in range(PNum - 6):
            if DotDenseLeftRight[i, 1] <= PowerLimitValve:
                WidthVar = WidthVar + (DotDenseLeftRight[i, 1] - WidthAverage) * (
                        DotDenseLeftRight[i, 1] - WidthAverage)

        WidthVar = np.sqrt(WidthVar / nCounter)

        # 各水平功率带，功率主带的风速范围，右侧扩展网格数*2*0.25
        PowerBandWidth = WidthAverage * 2 * 0.25

        # 对限负荷水平功率带的最大网格较下面相邻层显著偏右，拉回
        for i in range(1, PNum - 6):
            if PowerLimit[i] == 1 and abs(PBoxMaxIndex[i] - PBoxMaxIndex[i - 1]) > 5:
                PBoxMaxIndex[i] = PBoxMaxIndex[i - 1] + 1

        # 输出各层功率主带的左右边界网格索引
        DotDenseInverse = np.zeros([PNum, 2], dtype=int)

        for i in range(PNum):
            DotDenseInverse[i, :] = DotDenseLeftRight[PNum - i - 1, :]

        # print('DotDenseInverse', DotDenseInverse)

        # 功率主带的右边界
        CurveWidthR = int(np.ceil(WidthAverage) + 2)

        # CurveWidthL = 6    #功率主带的左边界
        CurveWidthL = CurveWidthR

        BBoxLimit = np.zeros([PNum, VNum], dtype=int)  # 网格是否为限功率网格的标识，如果为限功率水平功率带，从功率主带右侧边缘向右的网格为限功率网格
        for i in range(2, PNum - 6):
            if PowerLimit[i] == 1:
                for j in range(PBoxMaxIndex[i] + CurveWidthR, VNum):
                    BBoxLimit[i, j] = 1

        BBoxRemove = np.zeros([PNum, VNum], dtype=int)  # 数据异常需要剔除的网格标识，标识==1：功率主带右侧的欠发网格；==2：功率主带左侧的超发网格
        for m in range(PNum - 6):
            for n in range(PBoxMaxIndex[m] + CurveWidthR - 1, VNum):
                BBoxRemove[m, n] = 1

            for n in range(PBoxMaxIndex[m] - CurveWidthL - 1, 0, -1):
                BBoxRemove[m, n] = 2

        # 确定功率主带的左上拐点，即额定风速位置的网格索引
        CurveTop = np.zeros(2, dtype=int)
        CurveTopValve = 3  # 网格的百分比阈值
        BTopFind = 0
        for m in range(PNum - 4 - 1, 0, -1):
            for n in range(VNum):
                if VBoxPercent[m, n] > CurveTopValve and XBoxNumber[m, n] >= 10:  # 如左上角网格的百分比和散点个数大于阈值。
                    CurveTop[0] = m
                    CurveTop[1] = n
                    BTopFind = 1
                    break

            if BTopFind == 1:
                break

        IsolateValve = 3
        for m in range(PNum - 6):
            for n in range(PBoxMaxIndex[m] + CurveWidthR - 1, VNum):
                if PBoxPercent[m, n] < IsolateValve:
                    BBoxRemove[m, n] = 1

        # 功率主带顶部宽度
        CurveWidthT = 2
        for m in range(PNum - CurveWidthT - 1, PNum):
            for n in range(VNum):
                BBoxRemove[m, n] = 3  # 网格为额定功率以上的超发点

        # 功率主带拐点左侧的欠发网格标识
        for m in range(PNum - 5 - 1, PNum):
            for n in range(CurveTop[1] - 2 - 1):
                BBoxRemove[m, n] = 2

        # 以网格的标识，决定该网格内数据的标识。Dzwind_and_power_dfSel功率非零数据的标识位。散点在哪个网格，此网格的标识即为该点的标识
        Dzwind_and_power_dfSel = np.zeros(nCounter1, dtype=int)  # is ==1,欠发功率点；==2，超发功率点；==3，额定风速以上的超发功率点 ==4, 限电
        nWhichP = 0
        nWhichV = 0
        nBadA = 0

        for i in range(nCounter1):
            for m in range(PNum):
                if DzMarch809[i, 1] > (m - 1) * 25 and DzMarch809[i, 1] <= m * 25:
                    nWhichP = m
                    break

            for n in range(VNum):
                if DzMarch809[i, 0] > (n * 0.25 - 0.125) and DzMarch809[i, 0] <= (n * 0.25 + 0.125):
                    nWhichV = n
                    break

            if nWhichP > 0 and nWhichV > 0:

                if BBoxRemove[nWhichP, nWhichV] == 1:
                    Dzwind_and_power_dfSel[i] = 1
                    nBadA = nBadA + 1

                if BBoxRemove[nWhichP, nWhichV] == 2:
                    Dzwind_and_power_dfSel[i] = 2

                if BBoxRemove[nWhichP, nWhichV] == 3:
                    Dzwind_and_power_dfSel[i] = 0  # 3  # 额定风速以上的超发功率点认为是正常点，不再标识。

                if BBoxLimit[nWhichP, nWhichV] == 1 and nWhichP>16:
                    Dzwind_and_power_dfSel[i] = 4

        print("nWhichP", nWhichP)
        print("nWhichV", nWhichV)
        print("nBadA", nBadA)

        # 限负荷数据标识方法2：把数据切割为若干个窗口。对每一窗口，以第一个点为基准，连续nWindowLength个数据的功率在方差范围内，呈现显著水平分布的点
        PVLimit = np.zeros([nCounter1, 2], dtype=int)  # 存储限负荷数据
        nLimitTotal = 0
        nWindowLength = 3
        LimitWindow = np.zeros(nWindowLength, dtype=int)
        UpLimit = 0  # 上限
        LowLimit = 0  # 下限
        PowerStd = 15  # 功率波动方差
        bAllInUpLow = 1  # ==1:窗口内所有数据均在方差上下限之内，限负荷==0,不满足条件
        bAllInAreas = 1  # ==1：窗口所有数据均在200~PRated-300kW范围内；==0：不满足此条件
        nWindowNum = int(np.floor(nCounter1 / nWindowLength))
        PowerLimitUp = PRated - 300
        PowerLimitLow = 200
        for i in range(nWindowNum):
            for j in range(nWindowLength):
                LimitWindow[j] = DzMarch809[i * nWindowLength + j, 1]

            bAllInAreas = 1
            for j in range(nWindowLength):
                if LimitWindow[j] < PowerLimitLow or LimitWindow[j] > PowerLimitUp:
                    bAllInAreas = 0

            if bAllInAreas == 0:
                continue

            UpLimit = LimitWindow[0] + PowerStd
            LowLimit = LimitWindow[0] - PowerStd
            bAllInUpLow = 1
            for j in range(1, nWindowLength):
                if LimitWindow[j] < LowLimit or LimitWindow[j] > UpLimit:
                    bAllInUpLow = 0

            if bAllInUpLow == 1:
                for j in range(nWindowLength):
                    Dzwind_and_power_dfSel[i * nWindowLength + j] = 4  # 标识窗口内的数据为限负荷数据

                for j in range(nWindowLength):
                    PVLimit[nLimitTotal, :] = DzMarch809[i * nWindowLength + j, :]
                    nLimitTotal = nLimitTotal + 1

        print("nLimitTotal", nLimitTotal)

        # 相邻水平功率主带的锯齿平滑
        PVLeftDown = np.zeros(2, dtype=int)
        PVRightUp = np.zeros(2, dtype=int)
        nSmooth = 0
        for i in range(PNum - 6 - 1):
            PVLeftDown = np.zeros(2, dtype=int)
            PVRightUp = np.zeros(2, dtype=int)

            if (PBoxMaxIndex[i + 1] - PBoxMaxIndex[i]) >= 1:
                PVLeftDown[0] = (PBoxMaxIndex[i] + CurveWidthR) * 0.25 - 0.125
                PVLeftDown[1] = (i - 1) * 25

                PVRightUp[0] = (PBoxMaxIndex[i + 1] + CurveWidthR) * 0.25 - 0.125
                PVRightUp[1] = (i + 1 - 1) * 25

                for m in range(nCounter1):
                    if DzMarch809[m, 0] > PVLeftDown[0] and DzMarch809[m, 0] < PVRightUp[0] and PVLeftDown[1] < \
                            DzMarch809[m, 1] < PVRightUp[1]:  # 在该锯齿中
                        if (DzMarch809[m, 1] - PVLeftDown[1]) / (DzMarch809[m, 0] - PVLeftDown[0]) > (
                                PVRightUp[1] - PVLeftDown[1]) / (
                                PVRightUp[0] - PVLeftDown[0]):  # 斜率大于对角连线，则在锯齿左上三角形中，选中
                            Dzwind_and_power_dfSel[m] = 0
                            nSmooth = nSmooth + 1

        print("nSmooth", nSmooth)

        # 存储好点
        nCounterPV = 0
        PVDot = np.zeros([nCounter1, 2], dtype=int)
        for i in range(nCounter1):
            if Dzwind_and_power_dfSel[i] == 0:
                PVDot[nCounterPV, :] = DzMarch809[i, :]
                nCounterPV = nCounterPV + 1

        nCounterVP = nCounterPV
        print("nCounterVP", nCounterVP)

        # 存储坏点
        nCounterBad = 0
        PVBad = np.zeros([nCounter1, 2], dtype=int)
        for i in range(nCounter1):
            if Dzwind_and_power_dfSel[i] == 1 or Dzwind_and_power_dfSel[i] == 2 or Dzwind_and_power_dfSel[i] == 3:
                PVBad[nCounterBad, :] = DzMarch809[i, :]
                nCounterBad = nCounterBad + 1

        print("nCounterBad", nCounterBad)

        # 用功率主带中的好点绘制实测功率曲
        XBinNumber = np.ones(50, dtype=int)
        PCurve = np.zeros([50, 2], dtype=int)
        PCurve[:, 0] = [i / 2 for i in range(1, 51)]
        XBinSum = np.zeros([50, 2], dtype=int)
        nWhichBin = 0

        for i in range(nCounterVP):
            nWhichBin = 0

            for b in range(50):
                if PVDot[i, 0] > (b * 0.5 - 0.25) and PVDot[i, 0] <= (b * 0.5 + 0.25):
                    nWhichBin = b
                    break

            if nWhichBin > 0:
                XBinSum[nWhichBin, 0] = XBinSum[nWhichBin, 0] + PVDot[i, 0]  # wind speed
                XBinSum[nWhichBin, 1] = XBinSum[nWhichBin, 1] + PVDot[i, 1]  # Power
                XBinNumber[nWhichBin] = XBinNumber[nWhichBin] + 1

        for b in range(50):
            XBinNumber[b] = XBinNumber[b] - 1

        for b in range(50):
            if XBinNumber[b] > 0:
                PCurve[b, 0] = XBinSum[b, 0] / XBinNumber[b]
                PCurve[b, 1] = XBinSum[b, 1] / XBinNumber[b]

        # 对额定风速以上的功率直接赋额定功率
        VRatedNum = int(VRated / 0.5)
        for m in range(VRatedNum, 50):
            if PCurve[m, 1] == 0:
                PCurve[m, 1] = PRated

        # print("PCurve", PCurve)

        # 绘制标准正则功率曲线，以0.5m/s标准为间隔
        # 15m/s以上为额定功率，15m/s以下为计算得到
        PCurveNorm = np.zeros([50, 2], dtype=int)
        for i in range(30, 50):
            PCurveNorm[i, 0] = i * 0.5
            PCurveNorm[i, 1] = PRated

        # 15m/s一下正则功率曲线
        CurveData = np.zeros([30, 2], dtype=int)
        for i in range(30):
            CurveData[i, :] = PCurve[i, :]

        CurveNorm = np.zeros([30, 2], dtype=int)
        VSpeed = [i / 2 for i in range(1, 31)]

        WhichBin = 0

        K = 0
        a = 0
        for m in range(30):
            K = 0
            a = 0

            for n in range(30):
                if abs(CurveData[n, 0] - VSpeed[m]) < 0.1:
                    WhichBin = n
                    break

            if WhichBin > 1:
                if CurveData[WhichBin, 0] - CurveData[WhichBin - 1, 0] > 0:
                    K = (CurveData[WhichBin, 1] - CurveData[WhichBin - 1, 1]) / (
                            CurveData[WhichBin, 0] - CurveData[WhichBin - 1, 0])
                    a = CurveData[WhichBin, 1] - K * CurveData[WhichBin, 0]

            CurveNorm[m, 0] = VSpeed[m]
            CurveNorm[m, 1] = a + K * VSpeed[m]

        for i in range(30):
            PCurveNorm[i, :] = CurveNorm[i, :]

        # 子模块3：损失电量计算及发电性能评价
        CC = len(PCurve[:, 0])
        EPIdealTotal = 0
        # 计算停机损失
        EPLostStopTotal = 0
        EPLost = 0

        nWhichBin = 0
        IdealPower = 0
        nStopTotal = 0
        for i in range(wind_and_power_df_count):
            if wind_and_power_df.loc[i, self.active_power] <= 0:
                nWhichBin = 0
                for m in range(base_wind_and_power_count - 1):
                    if wind_and_power_df.loc[i, self.wind_velocity] > base_wind_and_power_df.loc[
                        m, self.rated_wind_speed] and wind_and_power_df.loc[i, self.wind_velocity] <= \
                            base_wind_and_power_df.loc[
                                m + 1, self.rated_wind_speed]:
                        nWhichBin = m
                        break

                if nWhichBin > base_wind_and_power_count - 1 or nWhichBin == 0:
                    continue

                IdealPower = (wind_and_power_df.loc[i, self.wind_velocity] - base_wind_and_power_df.loc[
                    nWhichBin, self.rated_wind_speed]) / (
                                     base_wind_and_power_df.loc[nWhichBin + 1, self.rated_wind_speed] -
                                     base_wind_and_power_df.loc[
                                         nWhichBin, self.rated_wind_speed]) * (
                                     base_wind_and_power_df.loc[nWhichBin + 1, self.rated_capacity]
                                     - base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]) \
                             + base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]

                EPLost = IdealPower / 6
                EPLostStopTotal = EPLostStopTotal + EPLost
                nStopTotal = nStopTotal + 1

        print("EPLost", EPLost)
        print("nStopTotal", nStopTotal)
        print("EPLostStopTotal", EPLostStopTotal)

        nWhichP = 0
        nWhichV = 0
        nWhichBin = 0
        IdealPower = 0

        # 计算欠发损失，此欠发损失已不包括限电损失，限电点在前面已经从欠发点中去除。
        EPLostBadTotal = 0
        EPLost = 0

        nBadTotal = 0

        LostBadPercent = 0

        EPOverTotal = 0
        EPOver = 0
        nOverTotal = 0

        for i in range(nCounter1):
            if Dzwind_and_power_dfSel[i] == 1:
                nWhichBin = 0
                for m in range(base_wind_and_power_count - 1):
                    if DzMarch809[i, 0] > base_wind_and_power_df.loc[m, self.rated_wind_speed] \
                            and DzMarch809[i, 0] <= base_wind_and_power_df.loc[m + 1, self.rated_wind_speed]:
                        nWhichBin = m
                        break

                if nWhichBin > base_wind_and_power_count - 1 or nWhichBin == 0:
                    continue

                IdealPower = (DzMarch809[i, 0] - base_wind_and_power_df.loc[nWhichBin, self.rated_wind_speed]) / (
                        base_wind_and_power_df.loc[nWhichBin + 1, self.rated_wind_speed] - base_wind_and_power_df.loc[
                    nWhichBin, self.rated_wind_speed]) * (
                                     base_wind_and_power_df.loc[nWhichBin + 1, self.rated_capacity] -
                                     base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]) + \
                             base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]
                EPLost = abs(IdealPower - DzMarch809[i, 1]) / 6
                EPLostBadTotal = EPLostBadTotal + EPLost
                nBadTotal = nBadTotal + 1

            # 额定风速以上超发电量
            if Dzwind_and_power_dfSel[i] == 3:
                EPOver = (DzMarch809[i, 1] - PRated) / 6
                EPOverTotal = EPOverTotal + EPOver
                nOverTotal = nOverTotal + 1

        print("EPLost", EPLost)
        print("nBadTotal", nBadTotal)
        print("EPLostBadTotal", EPLostBadTotal)
        print("EPOverTotal", EPOverTotal)
        print("nOverTotal", nOverTotal)

        # 功率曲线未达标损失
        EPLostPerformTotal = 0
        nWhichBinI = 0
        IdealPower = 0

        for i in range(nCounterVP):

            for m in range(base_wind_and_power_count - 1):
                if PVDot[i, 0] > base_wind_and_power_df.loc[m, self.rated_wind_speed] and PVDot[i, 0] <= \
                        base_wind_and_power_df.loc[m + 1, self.rated_wind_speed]:
                    nWhichBinI = m
                    break

            if nWhichBinI > base_wind_and_power_count - 1 or nWhichBinI == 0:
                continue

            IdealPower = (PVDot[i, 0] - base_wind_and_power_df.loc[nWhichBinI, self.rated_wind_speed]) / (
                    base_wind_and_power_df.loc[nWhichBinI + 1, self.rated_wind_speed] - base_wind_and_power_df.loc[
                nWhichBinI, self.rated_wind_speed]) * \
                         (base_wind_and_power_df.loc[nWhichBinI + 1, self.rated_capacity] -
                          base_wind_and_power_df.loc[nWhichBinI, self.rated_capacity]) + \
                         base_wind_and_power_df.loc[nWhichBinI, self.rated_capacity]

            EPLostPerformTotal = EPLostPerformTotal + (IdealPower - PVDot[i, 1]) / 6

        print("EPLostPerformTotal", EPLostPerformTotal)

        # 限电损失
        EPLostLimitTotal = 0
        EPLost = 0
        nLimitTotal = 0

        PVLimit = np.zeros([nCounter1, 2])

        for i in range(nCounter1):
            if Dzwind_and_power_dfSel[i] == 4:
                nWhichBin = 0
                for m in range(base_wind_and_power_count - 1):
                    if DzMarch809[i, 0] > base_wind_and_power_df.loc[m, self.rated_wind_speed] and DzMarch809[i, 0] <= \
                            base_wind_and_power_df.loc[m + 1, self.rated_wind_speed]:
                        nWhichBin = m
                        break

                # 插值计算对应设计功率
                if nWhichBin > base_wind_and_power_count - 1 or nWhichBin == 0:
                    continue

                IdealPower = (DzMarch809[i, 0] - base_wind_and_power_df.loc[nWhichBin, self.rated_wind_speed]) / (
                        base_wind_and_power_df.loc[nWhichBin + 1, self.rated_wind_speed] -
                        base_wind_and_power_df.loc[nWhichBin, self.rated_wind_speed]) * (
                                     base_wind_and_power_df.loc[nWhichBin + 1, self.rated_capacity] -
                                     base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]) + \
                             base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]
                EPLost = np.abs(IdealPower - DzMarch809[i, 1]) / 6
                EPLostLimitTotal = EPLostLimitTotal + EPLost

                PVLimit[nLimitTotal, :] = DzMarch809[i, :]
                nLimitTotal = nLimitTotal + 1

        nLimitTotal = nLimitTotal - 1

        print("nLimitTotal", nLimitTotal)

        # 欠发和限点损失总和
        EPLostBadLimitTotal = EPLostBadTotal + EPLostLimitTotal

        # 如果功率曲线未达标损失为正
        if EPLostPerformTotal >= 0:
            EPIdealTotal = EPActualTotal + EPLostStopTotal + EPLostLimitTotal + EPLostBadTotal + EPLostPerformTotal

        # 如果功率曲线未达标损失为负
        if EPLostPerformTotal < 0:
            EPIdealTotal = EPActualTotal + EPLostStopTotal + EPLostLimitTotal + EPLostBadTotal

        print("EPIdealTotal", EPIdealTotal)
        # 可以比较求和得到的应发功率EPIdealTotal与理论计算得到的应发功率EPIdealTotalAAA的差别
        # 需要去除的超发功率：（1）功率主带左侧的超发点；（2）额定风速以上的超发点。
        RemoveOverEP = 0
        nType2 = 0
        for i in range(nCounter1):
            if Dzwind_and_power_dfSel[i] == 2:  # 功率主带左侧的超发坏点
                nWhichBin = 0
                for m in range(base_wind_and_power_count - 1):
                    if base_wind_and_power_df.loc[m, self.rated_wind_speed] < DzMarch809[i, 0] <= base_wind_and_power_df.loc[m + 1, self.rated_wind_speed]:
                        nWhichBin = m
                        break

                if nWhichBin > base_wind_and_power_count - 1 or nWhichBin == 0:
                    continue

                IdealPower = (DzMarch809[i, 0] - base_wind_and_power_df.loc[nWhichBin, self.rated_wind_speed]) / (
                        base_wind_and_power_df.loc[nWhichBin + 1, self.rated_wind_speed] - base_wind_and_power_df.loc[
                    nWhichBin, self.rated_wind_speed]) * (
                                     base_wind_and_power_df.loc[nWhichBin + 1, self.rated_capacity] -
                                     base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]) + \
                             base_wind_and_power_df.loc[nWhichBin, self.rated_capacity]

                RemoveOverEP = RemoveOverEP + (DzMarch809[i, 1] - IdealPower) / 6
                nType2 = nType2 + 1

        print("RemoveOverEP", RemoveOverEP)
        print("nType2", nType2)
        # 额定功率以上的超发点
        nTypeOver = 0
        for i in range(nCounter1):
            if DzMarch809[i, 1] > PRated:
                RemoveOverEP = RemoveOverEP + (DzMarch809[i, 1] - PRated) / 6
                nTypeOver = nTypeOver + 1

        print("RemoveOverEP", RemoveOverEP)
        print("nTypeOver", nTypeOver)

    def run(self):
        # Implement your class identification logic here
        self.identifier()


if __name__ == '__main__':
    test = ClassIdentifier('test', r"D:\中能智能\matlib计算相关\好点坏点matlib计算\A01.csv", index='时间',
                           wind_velocity='风速',
                           active_power='功率')

    test.run()