generatorSpeedPowerAnalyst.py 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474
  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. # 构建最终的JSON对象
  121. json_output = {
  122. "analysisTypeCode": "发电机转速和有功功率分析",
  123. "engineCode": engineTypeCode,
  124. "engineTypeName": engineTypeName,
  125. "xaixs": "发电机转速(r/min)",
  126. "yaixs": "功率(kw)",
  127. "data": [{
  128. "engineName": name[0],
  129. "engineCode": name[1],
  130. "title":f' 月度发电机转速功率散点图:{name[0]}',
  131. "xData": dataFrame[Field_GeneratorSpeed].tolist(),
  132. "yData":dataFrame[Field_ActiverPower].tolist(),
  133. "color": dataFrame[Field_UnixYearMonth].tolist(),
  134. "colorbartitle": "时间",
  135. "mode":'markers'
  136. }]
  137. }
  138. # 保存图片
  139. outputFilePathPNG = os.path.join(
  140. outputAnalysisDir, f"{name[0]}.png")
  141. fig.write_image(outputFilePathPNG, width=800, height=600, scale=3)
  142. # # 保存html
  143. # outputFileHtml = os.path.join(outputAnalysisDir, f"{name[0]}.html")
  144. # fig.write_html(outputFileHtml)
  145. # 将JSON对象保存到文件
  146. output_json_path = os.path.join(outputAnalysisDir, f"speed_power{name[0]}.json")
  147. with open(output_json_path, 'w', encoding='utf-8') as f:
  148. import json
  149. json.dump(json_output, f, ensure_ascii=False, indent=4)
  150. result = []
  151. # 如果需要返回DataFrame,可以包含文件路径
  152. result.append({
  153. Field_Return_TypeAnalyst: self.typeAnalyst(),
  154. Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  155. Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  156. Field_CodeOfTurbine: dataFrame[Field_CodeOfTurbine].iloc[0],
  157. Field_Return_FilePath: output_json_path,
  158. Field_Return_IsSaveDatabase: True
  159. })
  160. result = []
  161. result.append({
  162. Field_Return_TypeAnalyst: self.typeAnalyst(),
  163. Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  164. Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  165. Field_CodeOfTurbine: dataFrame[Field_CodeOfTurbine].iloc[0],
  166. Field_Return_FilePath: outputFilePathPNG,
  167. Field_Return_IsSaveDatabase: False
  168. })
  169. # result.append({
  170. # Field_Return_TypeAnalyst: self.typeAnalyst(),
  171. # Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  172. # Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  173. # Field_CodeOfTurbine: dataFrame[Field_CodeOfTurbine].iloc[0],
  174. # Field_Return_FilePath: outputFileHtml,
  175. # Field_Return_IsSaveDatabase: True
  176. # })
  177. return result
  178. def drawScatterGraphOfTurbine(self, dataFrame: pd.DataFrame, outputAnalysisDir: str, conf: Contract, name: str,turbineModelInfo: pd.Series):
  179. # 创建3D散点图
  180. fig = px.scatter_3d(dataFrame,
  181. x=Field_GeneratorSpeed,
  182. y=Field_YearMonth,
  183. z=Field_ActiverPower,
  184. color=Field_YearMonth,
  185. labels={Field_GeneratorSpeed: '发电机转速',
  186. Field_YearMonth: '时间', Field_ActiverPower: '功率'}
  187. )
  188. # 设置固定散点大小
  189. fig.update_traces(marker=dict(size=1.5))
  190. # 更新图形的布局
  191. fig.update_layout(
  192. title={
  193. "text": f'月度发电机转速功率3D散点图: {name[0]}',
  194. # "x": 0.5
  195. },
  196. scene=dict(
  197. xaxis=dict(
  198. title='发电机转速',
  199. dtick=self.axisStepGeneratorSpeed, # 设置y轴刻度间隔
  200. range=[self.axisLowerLimitGeneratorSpeed,
  201. self.axisUpperLimitGeneratorSpeed], # 设置y轴的范围
  202. showgrid=True, # 显示网格线
  203. ),
  204. yaxis=dict(
  205. title='时间',
  206. tickformat='%Y-%m', # 日期格式,
  207. dtick='M1', # 每月一个刻度
  208. showgrid=True, # 显示网格线
  209. ),
  210. zaxis=dict(
  211. title='功率',
  212. dtick=self.axisStepActivePower,
  213. range=[self.axisLowerLimitActivePower,
  214. self.axisUpperLimitActivePower],
  215. showgrid=True, # 显示网格线
  216. )
  217. ),
  218. scene_camera=dict(
  219. up=dict(x=0, y=0, z=1), # 保持相机向上方向不变
  220. center=dict(x=0, y=0, z=0), # 保持相机中心位置不变
  221. eye=dict(x=-1.8, y=-1.8, z=1.2) # 调整eye属性以实现水平旋转180°
  222. ),
  223. # 设置图例标题
  224. # legend_title_text='Time',
  225. legend=dict(
  226. orientation="h",
  227. itemsizing="constant", # Use constant size for legend items
  228. itemwidth=80 # Set the width of legend items to 50 pixels
  229. )
  230. )
  231. # 确保从 Series 中提取的是具体的值
  232. engineTypeCode = turbineModelInfo.get(Field_MillTypeCode, "")
  233. if isinstance(engineTypeCode, pd.Series):
  234. engineTypeCode = engineTypeCode.iloc[0]
  235. engineTypeName = turbineModelInfo.get(Field_MachineTypeCode, "")
  236. if isinstance(engineTypeName, pd.Series):
  237. engineTypeName = engineTypeName.iloc[0]
  238. # 构建最终的JSON对象
  239. json_output = {
  240. "analysisTypeCode": "发电机转速和有功功率分析",
  241. "engineCode": engineTypeCode,
  242. "engineTypeName": engineTypeName,
  243. "xaixs": "发电机转速(r/min)",
  244. "yaixs": "时间",
  245. "zaixs": "有功功率(kw)",
  246. "data": [{
  247. "engineName": name[0],
  248. "engineCode": name[1],
  249. "title":f' 月度发电机转速功率3D散点图:{name[0]}',
  250. "xData": dataFrame[Field_GeneratorSpeed].tolist(),
  251. "yData":dataFrame[Field_YearMonth].tolist(),
  252. "zData":dataFrame[Field_ActiverPower].tolist(),
  253. "color": dataFrame[Field_YearMonth].tolist(),
  254. "mode":'markers'
  255. }]
  256. }
  257. # # 保存图像
  258. # outputFileHtml = os.path.join(
  259. # outputAnalysisDir, "{}_3D.html".format(name[0]))
  260. # fig.write_html(outputFileHtml)
  261. result = []
  262. # 将JSON对象保存到文件
  263. output_json_path = os.path.join(outputAnalysisDir, f"3D_{name[0]}.json")
  264. with open(output_json_path, 'w', encoding='utf-8') as f:
  265. import json
  266. json.dump(json_output, f, ensure_ascii=False, indent=4)
  267. # 如果需要返回DataFrame,可以包含文件路径
  268. result.append({
  269. Field_Return_TypeAnalyst: self.typeAnalyst(),
  270. Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  271. Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  272. Field_CodeOfTurbine: name[1],
  273. Field_Return_FilePath: output_json_path,
  274. Field_Return_IsSaveDatabase: True
  275. })
  276. # result.append({
  277. # Field_Return_TypeAnalyst: self.typeAnalyst(),
  278. # Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  279. # Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  280. # Field_CodeOfTurbine: dataFrame[Field_CodeOfTurbine].iloc[0],
  281. # Field_Return_FilePath: outputFileHtml,
  282. # Field_Return_IsSaveDatabase: True
  283. # })
  284. return result
  285. def drawScatter2DMonthly(self, dataFrameMerge: pd.DataFrame, outputAnalysisDir, conf: Contract,turbineModelInfo: pd.Series):
  286. """
  287. 生成每台风电机组二维有功功率、发电机转速散点图表
  288. """
  289. results = []
  290. grouped = dataFrameMerge.groupby(
  291. [Field_NameOfTurbine, Field_CodeOfTurbine])
  292. for name, group in grouped:
  293. result = self.drawScatter2DMonthlyOfTurbine(
  294. group, outputAnalysisDir, conf, name,turbineModelInfo)
  295. results.extend(result)
  296. return results
  297. def drawScatterGraph(self, dataFrame: pd.DataFrame, outputAnalysisDir: str, conf: Contract,turbineModelInfo: pd.Series):
  298. """
  299. 绘制风速-功率分布图并保存为文件。
  300. 参数:
  301. dataFrameMerge (pd.DataFrame): 包含数据的DataFrame,需要包含设备名、风速和功率列。
  302. outputAnalysisDir (str): 分析输出目录。
  303. confData (Contract): 配置
  304. """
  305. results = []
  306. dataFrame = dataFrame[(dataFrame[Field_ActiverPower] > 0)].sort_values(
  307. by=Field_YearMonth)
  308. grouped = dataFrame.groupby(
  309. [Field_NameOfTurbine, Field_CodeOfTurbine])
  310. # 遍历每个设备的数据
  311. for name, group in grouped:
  312. if len(group[Field_YearMonth].unique()) > 1:
  313. result = self.drawScatterGraphOfTurbine(
  314. group, outputAnalysisDir, conf, name,turbineModelInfo)
  315. results.extend(result)
  316. return results
  317. def drawScatterGraphForTurbines(self, dataFrame: pd.DataFrame, outputAnalysisDir, conf: Contract, turbineModelInfo: pd.Series):
  318. """
  319. 绘制风速-功率分布图并保存为文件。 (须按照机型分组)
  320. 参数:
  321. dataFrameMerge (pd.DataFrame): 包含数据的DataFrame,需要包含设备名、风速和功率列。
  322. outputAnalysisDir (str): 分析输出目录。
  323. confData (Contract): 配置
  324. """
  325. dataFrame = dataFrame[(dataFrame[Field_ActiverPower] > 0)].sort_values(by=Field_NameOfTurbine)
  326. # 创建3D散点图
  327. fig = px.scatter_3d(dataFrame,
  328. x=Field_GeneratorSpeed,
  329. y=Field_NameOfTurbine,
  330. z=Field_ActiverPower,
  331. color=Field_NameOfTurbine,
  332. labels={Field_GeneratorSpeed: '发电机转速',
  333. Field_NameOfTurbine: '风机', Field_ActiverPower: '功率'},
  334. )
  335. # 设置固定散点大小
  336. fig.update_traces(marker=dict(size=1.5))
  337. # 更新图形的布局
  338. fig.update_layout(
  339. title={
  340. "text": f'风机发电机转速功率3D散点图-{turbineModelInfo[Field_MachineTypeCode]}',
  341. "x": 0.5
  342. },
  343. scene=dict(
  344. xaxis=dict(
  345. title='发电机转速',
  346. dtick=self.axisStepGeneratorSpeed, # 设置y轴刻度间隔
  347. range=[self.axisLowerLimitGeneratorSpeed,
  348. self.axisUpperLimitGeneratorSpeed], # 设置y轴的范围
  349. showgrid=True, # 显示网格线
  350. ),
  351. yaxis=dict(
  352. title='机组',
  353. showgrid=True, # 显示网格线
  354. ),
  355. zaxis=dict(
  356. title='功率',
  357. dtick=self.axisStepActivePower,
  358. range=[self.axisLowerLimitActivePower,
  359. self.axisUpperLimitActivePower],
  360. showgrid=True, # 显示网格线
  361. )
  362. ),
  363. scene_camera=dict(
  364. up=dict(x=0, y=0, z=1), # 保持相机向上方向不变
  365. center=dict(x=0, y=0, z=0), # 保持相机中心位置不变
  366. eye=dict(x=-1.8, y=-1.8, z=1.2) # 调整eye属性以实现水平旋转180°
  367. ),
  368. # 设置图例标题
  369. # legend_title_text='Turbine'
  370. legend=dict(
  371. orientation="h",
  372. itemsizing="constant", # Use constant size for legend items
  373. itemwidth=80 # Set the width of legend items to 50 pixels
  374. )
  375. )
  376. # 确保从 Series 中提取的是具体的值
  377. engineTypeCode = turbineModelInfo.get(Field_MillTypeCode, "")
  378. if isinstance(engineTypeCode, pd.Series):
  379. engineTypeCode = engineTypeCode.iloc[0]
  380. engineTypeName = turbineModelInfo.get(Field_MachineTypeCode, "")
  381. if isinstance(engineTypeName, pd.Series):
  382. engineTypeName = engineTypeName.iloc[0]
  383. # 构建最终的JSON对象
  384. json_output = {
  385. "analysisTypeCode": "发电机转速和有功功率分析",
  386. "engineCode": engineTypeCode,
  387. "engineTypeName": engineTypeName,
  388. "xaixs": "发电机转速(r/min)",
  389. "yaixs": "机组",
  390. "zaixs": "有功功率(kw)",
  391. "data": [{
  392. "title":f'风机发电机转速功率3D散点图-{turbineModelInfo[Field_MachineTypeCode]}',
  393. "xData": dataFrame[Field_GeneratorSpeed].tolist(),
  394. "yData":dataFrame[Field_NameOfTurbine].tolist(),
  395. "zData":dataFrame[Field_ActiverPower].tolist(),
  396. "color": dataFrame[Field_NameOfTurbine].tolist(),
  397. "mode":'markers'
  398. }]
  399. }
  400. # # 保存图像
  401. # outputFileHtml = os.path.join(
  402. # outputAnalysisDir, "{}-{}.html".format(self.typeAnalyst(),turbineModelInfo[Field_MillTypeCode]))
  403. # fig.write_html(outputFileHtml)
  404. result = []
  405. # 将JSON对象保存到文件
  406. output_json_path = os.path.join(outputAnalysisDir, f"total_3D_{turbineModelInfo[Field_MillTypeCode]}.json")
  407. with open(output_json_path, 'w', encoding='utf-8') as f:
  408. import json
  409. json.dump(json_output, f, ensure_ascii=False, indent=4)
  410. # 如果需要返回DataFrame,可以包含文件路径
  411. result.append({
  412. Field_Return_TypeAnalyst: self.typeAnalyst(),
  413. Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  414. Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  415. Field_CodeOfTurbine:Const_Output_Total,
  416. Field_Return_FilePath: output_json_path,
  417. Field_Return_IsSaveDatabase: True
  418. })
  419. # result.append({
  420. # Field_Return_TypeAnalyst: self.typeAnalyst(),
  421. # Field_PowerFarmCode: conf.dataContract.dataFilter.powerFarmID,
  422. # Field_Return_BatchCode: conf.dataContract.dataFilter.dataBatchNum,
  423. # Field_CodeOfTurbine: Const_Output_Total,
  424. # Field_Return_FilePath: outputFileHtml,
  425. # Field_Return_IsSaveDatabase: True
  426. # })
  427. return result