generatorSpeedPowerAnalyst.py 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486
  1. import os
  2. from datetime import datetime
  3. import numpy as np
  4. import pandas as pd
  5. import plotly.express as px
  6. import plotly.graph_objects as go
  7. from algorithmContract.confBusiness import *
  8. from algorithmContract.contract import Contract
  9. from behavior.analystWithGoodPoint import AnalystWithGoodPoint
  10. class GeneratorSpeedPowerAnalyst(AnalystWithGoodPoint):
  11. """
  12. 风电机组发电机转速-有功功率分析
  13. """
  14. def typeAnalyst(self):
  15. return "speed_power"
  16. def turbinesAnalysis(self, outputAnalysisDir, conf: Contract, turbineCodes):
  17. dictionary = self.processTurbineData(turbineCodes, conf, [
  18. Field_DeviceCode, Field_Time,Field_RotorSpeed,Field_GeneratorSpeed, Field_WindSpeed, Field_ActiverPower])
  19. dataFrameOfTurbines = self.userDataFrame(
  20. dictionary, conf.dataContract.configAnalysis, self)
  21. # 检查所需列是否存在
  22. required_columns = {Field_CodeOfTurbine,Field_RotorSpeed,Field_GeneratorSpeed,Field_ActiverPower}
  23. if not required_columns.issubset(dataFrameOfTurbines.columns):
  24. raise ValueError(f"DataFrame缺少必要的列。需要的列有: {required_columns}")
  25. turbrineInfos = self.common.getTurbineInfos(
  26. conf.dataContract.dataFilter.powerFarmID, turbineCodes, self.turbineInfo)
  27. groupedOfTurbineModel = turbrineInfos.groupby(Field_MillTypeCode)
  28. returnDatas = []
  29. for turbineModelCode, group in groupedOfTurbineModel:
  30. currTurbineCodes = group[Field_CodeOfTurbine].unique().tolist()
  31. currTurbineModeInfo = self.common.getTurbineModelByCode(
  32. turbineModelCode, self.turbineModelInfo)
  33. currDataFrameOfTurbines = dataFrameOfTurbines[dataFrameOfTurbines[Field_CodeOfTurbine].isin(
  34. currTurbineCodes)]
  35. # 将 currTurbineInfos 转换为字典
  36. currTurbineInfos_dict = turbrineInfos.set_index(Field_CodeOfTurbine)[Field_NameOfTurbine].to_dict()
  37. # 使用 map 函数来填充 Field_NameOfTurbine 列
  38. currDataFrameOfTurbines[Field_NameOfTurbine] = currDataFrameOfTurbines[Field_CodeOfTurbine].map(currTurbineInfos_dict).fillna("")
  39. result2D = self.drawScatter2DMonthly(
  40. currDataFrameOfTurbines, outputAnalysisDir, conf,currTurbineModeInfo)
  41. returnDatas.extend(result2D)
  42. result3D = self.drawScatterGraph(
  43. currDataFrameOfTurbines, outputAnalysisDir, conf,currTurbineModeInfo)
  44. returnDatas.extend(result3D)
  45. resultTotal = self.drawScatterGraphForTurbines(
  46. currDataFrameOfTurbines, outputAnalysisDir, conf, currTurbineModeInfo)
  47. returnDatas.extend(resultTotal)
  48. returnDataFrame = pd.DataFrame(returnDatas)
  49. return returnDataFrame
  50. def drawScatter2DMonthlyOfTurbine(self, dataFrame: pd.DataFrame, outputAnalysisDir: str, conf: Contract, name: str,turbineModelInfo: pd.Series):
  51. # 设置颜色条参数
  52. dataFrame = dataFrame.sort_values(by=Field_YearMonth)
  53. # 绘制 Plotly 散点图
  54. fig = go.Figure(data=go.Scatter(
  55. x=dataFrame[Field_GeneratorSpeed],
  56. y=dataFrame[Field_ActiverPower],
  57. mode='markers',
  58. marker=dict(
  59. color=dataFrame[Field_UnixYearMonth],
  60. colorscale='Rainbow',
  61. size=3,
  62. opacity=0.7,
  63. colorbar=dict(
  64. tickvals=np.linspace(
  65. dataFrame[Field_UnixYearMonth].min(), dataFrame[Field_UnixYearMonth].max(), 6),
  66. ticktext=[datetime.fromtimestamp(ts).strftime('%Y-%m') for ts in np.linspace(
  67. dataFrame[Field_UnixYearMonth].min(), dataFrame[Field_UnixYearMonth].max(), 6)],
  68. thickness=18,
  69. len=1, # 设置颜色条的长度,使其占据整个图的高度
  70. outlinecolor='rgba(255,255,255,0)'
  71. ),
  72. showscale=True
  73. ),
  74. showlegend=False
  75. ))
  76. # # 设置固定散点大小
  77. # fig.update_traces(marker=dict(size=3))
  78. # 如果需要颜色轴的刻度和标签
  79. # 以下是以比例方式进行色彩的可视化处理
  80. fig.update_layout(
  81. title={
  82. "text": f'月度发电机转速功率散点图: {name[0]}',
  83. # "x": 0.5
  84. },
  85. xaxis=dict(
  86. title='发电机转速',
  87. dtick=self.axisStepGeneratorSpeed,
  88. range=[self.axisLowerLimitGeneratorSpeed,
  89. self.axisUpperLimitGeneratorSpeed],
  90. tickangle=-45
  91. ),
  92. yaxis=dict(
  93. title='功率',
  94. dtick=self.axisStepActivePower,
  95. range=[self.axisLowerLimitActivePower,
  96. self.axisUpperLimitActivePower],
  97. ),
  98. coloraxis=dict(
  99. colorbar=dict(
  100. title="时间",
  101. ticks="outside",
  102. len=1, # 设置颜色条的长度,使其占据整个图的高度
  103. thickness=20, # 调整颜色条的宽度
  104. orientation='v', # 设置颜色条为垂直方向
  105. tickmode='array', # 确保刻度按顺序排列
  106. tickvals=dataFrame[Field_YearMonth].unique(
  107. ).tolist(), # 确保刻度为唯一的年月
  108. ticktext=dataFrame[Field_YearMonth].unique(
  109. ).tolist() # 以%Y-%m格式显示标签
  110. )
  111. )
  112. )
  113. # 确保从 Series 中提取的是具体的值
  114. engineTypeCode = turbineModelInfo.get(Field_MillTypeCode, "")
  115. if isinstance(engineTypeCode, pd.Series):
  116. engineTypeCode = engineTypeCode.iloc[0]
  117. engineTypeName = turbineModelInfo.get(Field_MachineTypeCode, "")
  118. if isinstance(engineTypeName, pd.Series):
  119. engineTypeName = engineTypeName.iloc[0]
  120. print(dataFrame[Field_UnixYearMonth].head())
  121. print(dataFrame[Field_UnixYearMonth].dtype)
  122. n_dataFrame = pd.DataFrame({
  123. 'DateTime': pd.to_datetime(dataFrame[Field_UnixYearMonth], unit='s').dt.strftime('%Y-%m-%d %H:%M:%S')
  124. })
  125. # 使用 apply() 对每个元素调用 datetime.fromtimestamp
  126. dataFrame[Field_UnixYearMonth]= dataFrame[Field_UnixYearMonth].apply(lambda x: datetime.fromtimestamp(x).strftime('%Y-%m'))
  127. scada = self.getTimeGranularitys(conf)[0]
  128. # 构建最终的JSON对象
  129. json_output = {
  130. "field_code": self.currPowerFarmInfo[Field_PowerFarmCode],
  131. "scada": scada,
  132. "analysisTypeCode": "发电机转速和有功功率分析",
  133. "engineCode": engineTypeCode,
  134. "engineTypeName": engineTypeName,
  135. "xaixs": "发电机转速(r/min)",
  136. "yaixs": "功率(kW)",
  137. "data": [{
  138. "engineName": name[0],
  139. "engineCode": name[1],
  140. "title":f' 月度发电机转速功率散点图:{name[0]}',
  141. "xData": dataFrame[Field_GeneratorSpeed].tolist(),
  142. "yData":dataFrame[Field_ActiverPower].tolist(),
  143. "timeData": n_dataFrame['DateTime'].tolist(),
  144. "color": dataFrame[Field_UnixYearMonth].tolist(),
  145. "colorbartitle": "时间",
  146. "mode":'markers'
  147. }]
  148. }
  149. # 保存图片
  150. # outputFilePathPNG = os.path.join(
  151. # outputAnalysisDir, f"{name[0]}.png")
  152. # fig.write_image(outputFilePathPNG, width=800, height=600, scale=3)
  153. # # 保存html
  154. # outputFileHtml = os.path.join(outputAnalysisDir, f"{name[0]}.html")
  155. # fig.write_html(outputFileHtml)
  156. # 将JSON对象保存到文件
  157. output_json_path = os.path.join(outputAnalysisDir, f"speed_power{name[0]}.json")
  158. with open(output_json_path, 'w', encoding='utf-8') as f:
  159. import json
  160. json.dump(json_output, f, ensure_ascii=False, indent=4)
  161. result = []
  162. # 如果需要返回DataFrame,可以包含文件路径
  163. result.append({
  164. Field_Return_TypeAnalyst: self.typeAnalyst(),
  165. Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  166. Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  167. Field_CodeOfTurbine: dataFrame[Field_CodeOfTurbine].iloc[0],
  168. Field_Return_FilePath: output_json_path,
  169. Field_Return_IsSaveDatabase: True
  170. })
  171. # result.append({
  172. # Field_Return_TypeAnalyst: self.typeAnalyst(),
  173. # Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  174. # Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  175. # Field_CodeOfTurbine: dataFrame[Field_CodeOfTurbine].iloc[0],
  176. # Field_Return_FilePath: outputFilePathPNG,
  177. # Field_Return_IsSaveDatabase: False
  178. # })
  179. # result.append({
  180. # Field_Return_TypeAnalyst: self.typeAnalyst(),
  181. # Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  182. # Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  183. # Field_CodeOfTurbine: dataFrame[Field_CodeOfTurbine].iloc[0],
  184. # Field_Return_FilePath: outputFileHtml,
  185. # Field_Return_IsSaveDatabase: True
  186. # })
  187. return result
  188. def drawScatterGraphOfTurbine(self, dataFrame: pd.DataFrame, outputAnalysisDir: str, conf: Contract, name: str,turbineModelInfo: pd.Series):
  189. # 创建3D散点图
  190. fig = px.scatter_3d(dataFrame,
  191. x=Field_GeneratorSpeed,
  192. y=Field_YearMonth,
  193. z=Field_ActiverPower,
  194. color=Field_YearMonth,
  195. labels={Field_GeneratorSpeed: '发电机转速',
  196. Field_YearMonth: '时间', Field_ActiverPower: '功率'}
  197. )
  198. # 设置固定散点大小
  199. fig.update_traces(marker=dict(size=1.5))
  200. # 更新图形的布局
  201. fig.update_layout(
  202. title={
  203. "text": f'月度发电机转速功率3D散点图: {name[0]}',
  204. # "x": 0.5
  205. },
  206. scene=dict(
  207. xaxis=dict(
  208. title='发电机转速',
  209. dtick=self.axisStepGeneratorSpeed, # 设置y轴刻度间隔
  210. range=[self.axisLowerLimitGeneratorSpeed,
  211. self.axisUpperLimitGeneratorSpeed], # 设置y轴的范围
  212. showgrid=True, # 显示网格线
  213. ),
  214. yaxis=dict(
  215. title='时间',
  216. tickformat='%Y-%m', # 日期格式,
  217. dtick='M1', # 每月一个刻度
  218. showgrid=True, # 显示网格线
  219. ),
  220. zaxis=dict(
  221. title='功率',
  222. dtick=self.axisStepActivePower,
  223. range=[self.axisLowerLimitActivePower,
  224. self.axisUpperLimitActivePower],
  225. showgrid=True, # 显示网格线
  226. )
  227. ),
  228. scene_camera=dict(
  229. up=dict(x=0, y=0, z=1), # 保持相机向上方向不变
  230. center=dict(x=0, y=0, z=0), # 保持相机中心位置不变
  231. eye=dict(x=-1.8, y=-1.8, z=1.2) # 调整eye属性以实现水平旋转180°
  232. ),
  233. # 设置图例标题
  234. # legend_title_text='Time',
  235. legend=dict(
  236. orientation="h",
  237. itemsizing="constant", # Use constant size for legend items
  238. itemwidth=80 # Set the width of legend items to 50 pixels
  239. )
  240. )
  241. # 确保从 Series 中提取的是具体的值
  242. engineTypeCode = turbineModelInfo.get(Field_MillTypeCode, "")
  243. if isinstance(engineTypeCode, pd.Series):
  244. engineTypeCode = engineTypeCode.iloc[0]
  245. engineTypeName = turbineModelInfo.get(Field_MachineTypeCode, "")
  246. if isinstance(engineTypeName, pd.Series):
  247. engineTypeName = engineTypeName.iloc[0]
  248. # 构建最终的JSON对象
  249. json_output = {
  250. "analysisTypeCode": "发电机转速和有功功率分析",
  251. "engineCode": engineTypeCode,
  252. "engineTypeName": engineTypeName,
  253. "xaixs": "发电机转速(r/min)",
  254. "yaixs": "时间",
  255. "zaixs": "有功功率(kW)",
  256. "data": [{
  257. "engineName": name[0],
  258. "engineCode": name[1],
  259. "title":f' 月度发电机转速功率3D散点图:{name[0]}',
  260. "xData": dataFrame[Field_GeneratorSpeed].tolist(),
  261. "yData":dataFrame[Field_YearMonth].tolist(),
  262. "zData":dataFrame[Field_ActiverPower].tolist(),
  263. "color": dataFrame[Field_YearMonth].tolist(),
  264. "mode":'markers'
  265. }]
  266. }
  267. # # 保存图像
  268. # outputFileHtml = os.path.join(
  269. # outputAnalysisDir, "{}_3D.html".format(name[0]))
  270. # fig.write_html(outputFileHtml)
  271. result = []
  272. # 将JSON对象保存到文件
  273. output_json_path = os.path.join(outputAnalysisDir, f"3D_{name[0]}.json")
  274. with open(output_json_path, 'w', encoding='utf-8') as f:
  275. import json
  276. json.dump(json_output, f, ensure_ascii=False, indent=4)
  277. # 如果需要返回DataFrame,可以包含文件路径
  278. result.append({
  279. Field_Return_TypeAnalyst: self.typeAnalyst(),
  280. Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  281. Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  282. Field_CodeOfTurbine: name[1],
  283. Field_Return_FilePath: output_json_path,
  284. Field_Return_IsSaveDatabase: True
  285. })
  286. # result.append({
  287. # Field_Return_TypeAnalyst: self.typeAnalyst(),
  288. # Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  289. # Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  290. # Field_CodeOfTurbine: dataFrame[Field_CodeOfTurbine].iloc[0],
  291. # Field_Return_FilePath: outputFileHtml,
  292. # Field_Return_IsSaveDatabase: True
  293. # })
  294. return result
  295. def drawScatter2DMonthly(self, dataFrameMerge: pd.DataFrame, outputAnalysisDir, conf: Contract,turbineModelInfo: pd.Series):
  296. """
  297. 生成每台风电机组二维有功功率、发电机转速散点图表
  298. """
  299. results = []
  300. grouped = dataFrameMerge.groupby(
  301. [Field_NameOfTurbine, Field_CodeOfTurbine])
  302. for name, group in grouped:
  303. result = self.drawScatter2DMonthlyOfTurbine(
  304. group, outputAnalysisDir, conf, name,turbineModelInfo)
  305. results.extend(result)
  306. return results
  307. def drawScatterGraph(self, dataFrame: pd.DataFrame, outputAnalysisDir: str, conf: Contract,turbineModelInfo: pd.Series):
  308. """
  309. 绘制风速-功率分布图并保存为文件。
  310. 参数:
  311. dataFrameMerge (pd.DataFrame): 包含数据的DataFrame,需要包含设备名、风速和功率列。
  312. outputAnalysisDir (str): 分析输出目录。
  313. confData (Contract): 配置
  314. """
  315. results = []
  316. dataFrame = dataFrame[(dataFrame[Field_ActiverPower] > 0)].sort_values(
  317. by=Field_YearMonth)
  318. grouped = dataFrame.groupby(
  319. [Field_NameOfTurbine, Field_CodeOfTurbine])
  320. # 遍历每个设备的数据
  321. for name, group in grouped:
  322. if len(group[Field_YearMonth].unique()) > 1:
  323. result = self.drawScatterGraphOfTurbine(
  324. group, outputAnalysisDir, conf, name,turbineModelInfo)
  325. results.extend(result)
  326. return results
  327. def drawScatterGraphForTurbines(self, dataFrame: pd.DataFrame, outputAnalysisDir, conf: Contract, turbineModelInfo: pd.Series):
  328. """
  329. 绘制风速-功率分布图并保存为文件。 (须按照机型分组)
  330. 参数:
  331. dataFrameMerge (pd.DataFrame): 包含数据的DataFrame,需要包含设备名、风速和功率列。
  332. outputAnalysisDir (str): 分析输出目录。
  333. confData (Contract): 配置
  334. """
  335. dataFrame = dataFrame[(dataFrame[Field_ActiverPower] > 0)].sort_values(by=Field_NameOfTurbine)
  336. # 创建3D散点图
  337. fig = px.scatter_3d(dataFrame,
  338. x=Field_GeneratorSpeed,
  339. y=Field_NameOfTurbine,
  340. z=Field_ActiverPower,
  341. color=Field_NameOfTurbine,
  342. labels={Field_GeneratorSpeed: '发电机转速',
  343. Field_NameOfTurbine: '风机', Field_ActiverPower: '功率'},
  344. )
  345. # 设置固定散点大小
  346. fig.update_traces(marker=dict(size=1.5))
  347. # 更新图形的布局
  348. fig.update_layout(
  349. title={
  350. "text": f'风机发电机转速功率3D散点图-{turbineModelInfo[Field_MachineTypeCode]}',
  351. "x": 0.5
  352. },
  353. scene=dict(
  354. xaxis=dict(
  355. title='发电机转速',
  356. dtick=self.axisStepGeneratorSpeed, # 设置y轴刻度间隔
  357. range=[self.axisLowerLimitGeneratorSpeed,
  358. self.axisUpperLimitGeneratorSpeed], # 设置y轴的范围
  359. showgrid=True, # 显示网格线
  360. ),
  361. yaxis=dict(
  362. title='机组',
  363. showgrid=True, # 显示网格线
  364. ),
  365. zaxis=dict(
  366. title='功率',
  367. dtick=self.axisStepActivePower,
  368. range=[self.axisLowerLimitActivePower,
  369. self.axisUpperLimitActivePower],
  370. showgrid=True, # 显示网格线
  371. )
  372. ),
  373. scene_camera=dict(
  374. up=dict(x=0, y=0, z=1), # 保持相机向上方向不变
  375. center=dict(x=0, y=0, z=0), # 保持相机中心位置不变
  376. eye=dict(x=-1.8, y=-1.8, z=1.2) # 调整eye属性以实现水平旋转180°
  377. ),
  378. # 设置图例标题
  379. # legend_title_text='Turbine'
  380. legend=dict(
  381. orientation="h",
  382. itemsizing="constant", # Use constant size for legend items
  383. itemwidth=80 # Set the width of legend items to 50 pixels
  384. )
  385. )
  386. # 确保从 Series 中提取的是具体的值
  387. engineTypeCode = turbineModelInfo.get(Field_MillTypeCode, "")
  388. if isinstance(engineTypeCode, pd.Series):
  389. engineTypeCode = engineTypeCode.iloc[0]
  390. engineTypeName = turbineModelInfo.get(Field_MachineTypeCode, "")
  391. if isinstance(engineTypeName, pd.Series):
  392. engineTypeName = engineTypeName.iloc[0]
  393. # 构建最终的JSON对象
  394. json_output = {
  395. "analysisTypeCode": "发电机转速和有功功率分析",
  396. "engineCode": engineTypeCode,
  397. "engineTypeName": engineTypeName,
  398. "xaixs": "发电机转速(r/min)",
  399. "yaixs": "机组",
  400. "zaixs": "有功功率(kw)",
  401. "data": [{
  402. "title":f'风机发电机转速功率3D散点图-{turbineModelInfo[Field_MachineTypeCode]}',
  403. "xData": dataFrame[Field_GeneratorSpeed].tolist(),
  404. "yData":dataFrame[Field_NameOfTurbine].tolist(),
  405. "zData":dataFrame[Field_ActiverPower].tolist(),
  406. "color": dataFrame[Field_NameOfTurbine].tolist(),
  407. "mode":'markers'
  408. }]
  409. }
  410. # # 保存图像
  411. # outputFileHtml = os.path.join(
  412. # outputAnalysisDir, "{}-{}.html".format(self.typeAnalyst(),turbineModelInfo[Field_MillTypeCode]))
  413. # fig.write_html(outputFileHtml)
  414. result = []
  415. # 将JSON对象保存到文件
  416. output_json_path = os.path.join(outputAnalysisDir, f"total_3D_{turbineModelInfo[Field_MillTypeCode]}.json")
  417. with open(output_json_path, 'w', encoding='utf-8') as f:
  418. import json
  419. json.dump(json_output, f, ensure_ascii=False, indent=4)
  420. # 如果需要返回DataFrame,可以包含文件路径
  421. result.append({
  422. Field_Return_TypeAnalyst: self.typeAnalyst(),
  423. Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  424. Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  425. Field_CodeOfTurbine:Const_Output_Total,
  426. Field_MillTypeCode:turbineModelInfo[Field_MillTypeCode],
  427. Field_Return_FilePath: output_json_path,
  428. Field_Return_IsSaveDatabase: True
  429. })
  430. # result.append({
  431. # Field_Return_TypeAnalyst: self.typeAnalyst(),
  432. # Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  433. # Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  434. # Field_CodeOfTurbine: Const_Output_Total,
  435. # Field_Return_FilePath: outputFileHtml,
  436. # Field_Return_IsSaveDatabase: True
  437. # })
  438. return result