WTOAAM/dataAnalysisBehavior/common/commonBusiness.py

import pandas as pd
import numpy as np
import chardet  
from algorithmContract.confBusiness import *


class CommonBusiness:
    def getFloat32(self):
        return "float32"

    def isNone(self, value):
        return value is None

    def getUseColumns(self, confData: ConfBusiness):
        useColumns = []

        if not self.isNone(confData.field_turbine_time):
            useColumns.append(confData.field_turbine_time)

        if not self.isNone(confData.field_turbine_name):
            useColumns.append(confData.field_turbine_name)

        if not self.isNone(confData.field_wind_speed):
            useColumns.append(confData.field_wind_speed)

        if not self.isNone(confData.field_power):
            useColumns.append(confData.field_power)

        if not self.isNone(confData.field_pitch_angle1):
            useColumns.append(confData.field_pitch_angle1)

        if not self.isNone(confData.field_rotor_speed):
            useColumns.append(confData.field_rotor_speed)

        if not self.isNone(confData.field_gen_speed):
            useColumns.append(confData.field_gen_speed)

        if not self.isNone(confData.field_torque):
            useColumns.append(confData.field_torque)

        if not self.isNone(confData.field_wind_dir):
            useColumns.append(confData.field_wind_dir)

        if not self.isNone(confData.field_angle_included):
            useColumns.append(confData.field_angle_included)

        if not self.isNone(confData.field_nacelle_pos):
            useColumns.append(confData.field_nacelle_pos)

        if not self.isNone(confData.field_env_temp):
            useColumns.append(confData.field_env_temp)

        if not self.isNone(confData.field_nacelle_temp):
            useColumns.append(confData.field_nacelle_temp)

        if not self.isNone(confData.field_turbine_state):
            useColumns.append(confData.field_turbine_state)

        if not self.isNone(confData.field_Cabin_Vibrate_X):
            useColumns.append(confData.field_Cabin_Vibrate_X)

        if not self.isNone(confData.field_Cabin_Vibrate_Y):
            useColumns.append(confData.field_Cabin_Vibrate_Y)

        if not self.isNone(confData.field_activePowerSet):
            useColumns.append(confData.field_activePowerSet)

        if not self.isNone(confData.field_activePowerAvailable):
            useColumns.append(confData.field_activePowerAvailable)

        if not self.isNone(confData.field_temperature_large_components):
            temperature_cols = confData.field_temperature_large_components.split(
                ',')
            for temperatureColumn in temperature_cols:
                useColumns.append(temperatureColumn)

        return useColumns

    def recalculationOfGeneratorSpeedforShow(self, dataFrame: pd.DataFrame, confData: ConfBusiness):
        if not self.isNone(confData.value_gen_speed_multiple) and confData.field_gen_speed in dataFrame.columns:
            dataFrame[confData.field_gen_speed] = dataFrame[confData.field_gen_speed] * \
                confData.value_gen_speed_multiple
            dataFrame[Field_GeneratorTorque] = dataFrame[confData.field_gen_speed]

    def contractGuaranteePowerCurveData(self, csvPowerCurveFilePath, confData: ConfBusiness):
        with open(csvPowerCurveFilePath, 'rb') as f:  
            result = chardet.detect(f.read())  
        
        dataFrameGuaranteePowerCurve = pd.read_csv(csvPowerCurveFilePath, encoding= result['encoding'] )

        return dataFrameGuaranteePowerCurve

    def calculateTSR(self, dataFrame: pd.DataFrame, confData: ConfBusiness):
        """
        使用叶轮/主轴转速、风速、叶轮直径，计算叶尖速比(TSR)
        """
        # Calculate tsr
        if not self.isNone(confData.rotor_diameter) \
           and not self.isNone(confData.field_wind_speed) and confData.field_wind_speed in dataFrame.columns \
           and not self.isNone(confData.field_rotor_speed) and confData.field_rotor_speed in dataFrame.columns:
            dataFrame[confData.field_rotor_speed] = pd.to_numeric(
                dataFrame[confData.field_rotor_speed], errors='coerce')
            dataFrame[confData.field_wind_speed] = pd.to_numeric(
                dataFrame[confData.field_wind_speed], errors='coerce')

            rotor_diameter = pd.to_numeric(
                confData.rotor_diameter, errors='coerce')
            
            dataFrame[Field_PowerFloor] = dataFrame[confData.field_power].apply(  
                lambda x: int(x / 10) * 10 if pd.notnull(x) else np.nan  # 保留NaN值  
            )

            dataFrame[Field_TSR] = (dataFrame[confData.field_rotor_speed] * 0.104667 *
                                    (rotor_diameter / 2)) / dataFrame[confData.field_wind_speed]
            
    def calculateCp2(self,dataFrame: pd.DataFrame,airDensity,rotorDiameter,fieldWindSpeed,fieldActivePower):
        """
        使用有功功率、风速、空气密度、叶轮直径，计算风能利用系数(Cp)
        """
        # Calculate cp
        if not self.isNone(airDensity) and not self.isNone(rotorDiameter) \
           and not self.isNone(fieldWindSpeed) and fieldWindSpeed in dataFrame.columns \
           and not self.isNone(fieldActivePower) and fieldActivePower in dataFrame.columns:
            dataFrame[fieldActivePower] = pd.to_numeric(
                dataFrame[fieldActivePower], errors='coerce')
            dataFrame[fieldWindSpeed] = pd.to_numeric(
                dataFrame[fieldWindSpeed], errors='coerce')

            rotor_diameter = pd.to_numeric(
                rotorDiameter, errors='coerce')
            air_density = pd.to_numeric(airDensity, errors='coerce')

            dataFrame[Field_PowerFloor] = dataFrame[fieldActivePower].apply(  
                lambda x: int(x / 10) * 10 if pd.notnull(x) else np.nan  # 保留NaN值  
            )

            dataFrame[Field_Cp] = dataFrame[fieldActivePower] * 1000 / \
                (0.5 * np.pi * air_density *
                 (rotor_diameter ** 2) / 4 * dataFrame[fieldWindSpeed] ** 3)

    def calculateCp(self, dataFrame: pd.DataFrame, confData: ConfBusiness):
        """
        使用有功功率、风速、空气密度、叶轮直径，计算风能利用系数(Cp)
        """
        self.calculateCp2(dataFrame,confData.density_air,confData.rotor_diameter,confData.field_wind_speed,confData.field_power)
        # # Calculate cp
        # if not self.isNone(confData.density_air) and not self.isNone(confData.rotor_diameter) \
        #    and not self.isNone(confData.field_wind_speed) and confData.field_wind_speed in dataFrame.columns \
        #    and not self.isNone(confData.field_power) and confData.field_power in dataFrame.columns:
        #     dataFrame[confData.field_power] = pd.to_numeric(
        #         dataFrame[confData.field_power], errors='coerce')
        #     dataFrame[confData.field_wind_speed] = pd.to_numeric(
        #         dataFrame[confData.field_wind_speed], errors='coerce')

        #     rotor_diameter = pd.to_numeric(
        #         confData.rotor_diameter, errors='coerce')
        #     air_density = pd.to_numeric(confData.density_air, errors='coerce')

        #     dataFrame[Field_PowerFloor] = dataFrame[confData.field_power].apply(  
        #         lambda x: int(x / 10) * 10 if pd.notnull(x) else np.nan  # 保留NaN值  
        #     )

        #     dataFrame[Field_Cp] = dataFrame[confData.field_power] * 1000 / \
        #         (0.5 * np.pi * air_density *
        #          (rotor_diameter ** 2) / 4 * dataFrame[confData.field_wind_speed] ** 3)