generatorSpeedTorqueAnalyst.py 21 KB

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