generatorSpeedPowerAnalyst.py 21 KB

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