123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755 |
- 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()
|