package com.njcn.prepare.harmonic.pojo.mysql.po.line;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.github.jeffreyning.mybatisplus.anno.MppMultiId;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

import java.util.Date;

/**
 * Description:
 * 接口文档访问地址：http://serverIP:port/swagger-ui.html
 * Date: 2022/10/25  10:33【需求编号】
 *
 * @author clam
 * @version V1.0.0
 */
@ApiModel(value = "com-njcn-prepare-harmonic-pojo-po-line-RMpHarmonicPReportDPO")
@TableName(value = "r_mp_harmonic_p_report_d")
public class RMpHarmonicPReportDPO {


    /**
     * 监测点ID
     */
    @MppMultiId(value = "measurement_point_id")
    @ApiModelProperty(value = "监测点ID")
    private String measurementPointId;

    /**
     * 生成数据的时间,每日统计一次
     */
    @MppMultiId(value = "data_date")
    @ApiModelProperty(value = "生成数据的时间,每日统计一次")
    private Date dataDate;

    /**
     * 相别："A" "B" "C" "ABC" "T"  配网部分相别的数据采用T标志存储
     */
    @MppMultiId(value = "phase")
    @ApiModelProperty(value = "相别：'A' 'B' 'C' 'ABC' 'T'  配网部分相别的数据采用T标志存储")
    private String phase;

    /**
     * 基波无功功率-最大值
     */
    @TableField(value = "FUNDAMENTAL_RATEOFWORK_MAX")
    @ApiModelProperty(value = "基波无功功率-最大值")
    private Double fundamentalRateofworkMax;

    /**
     * 基波无功功率-最小值
     */
    @TableField(value = "FUNDAMENTAL_RATEOFWORK_Min")
    @ApiModelProperty(value = "基波无功功率-最小值")
    private Double fundamentalRateofworkMin;

    /**
     * 基波无功功率-平均值
     */
    @TableField(value = "FUNDAMENTAL_RATEOFWORK_avg")
    @ApiModelProperty(value = "基波无功功率-平均值")
    private Double fundamentalRateofworkAvg;

    /**
     * 基波无功功率-95值
     */
    @TableField(value = "FUNDAMENTAL_RATEOFWORK_95")
    @ApiModelProperty(value = "基波无功功率-95值")
    private Double fundamentalRateofwork95;

    /**
     * 基波有功功率-最大值
     */
    @TableField(value = "FUNDAMENTAL_ACTIVE_POWER_MAX")
    @ApiModelProperty(value = "基波有功功率-最大值")
    private Double fundamentalActivePowerMax;

    /**
     * 基波有功功率-最小值
     */
    @TableField(value = "FUNDAMENTAL_ACTIVE_POWER_Min")
    @ApiModelProperty(value = "基波有功功率-最小值")
    private Double fundamentalActivePowerMin;

    /**
     * 基波有功功率-平均值
     */
    @TableField(value = "FUNDAMENTAL_ACTIVE_POWER_avg")
    @ApiModelProperty(value = "基波有功功率-平均值")
    private Double fundamentalActivePowerAvg;

    /**
     * 基波有功功率-95值
     */
    @TableField(value = "FUNDAMENTAL_ACTIVE_POWER_95")
    @ApiModelProperty(value = "基波有功功率-95值")
    private Double fundamentalActivePower95;

    /**
     * 2次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_2_MAX")
    @ApiModelProperty(value = "2次谐波有功功率-最大值")
    private Double harmonicActivePower2Max;

    /**
     * 2次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_2_MIN")
    @ApiModelProperty(value = "2次谐波有功功率-最小值")
    private Double harmonicActivePower2Min;

    /**
     * 2次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_2_AVG")
    @ApiModelProperty(value = "2次谐波有功功率-平均值")
    private Double harmonicActivePower2Avg;

    /**
     * 2次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_2_95")
    @ApiModelProperty(value = "2次谐波有功功率-95值")
    private Double harmonicActivePower295;

    /**
     * 3次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_3_MAX")
    @ApiModelProperty(value = "3次谐波有功功率-最大值")
    private Double harmonicActivePower3Max;

    /**
     * 3次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_3_MIN")
    @ApiModelProperty(value = "3次谐波有功功率-最小值")
    private Double harmonicActivePower3Min;

    /**
     * 3次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_3_AVG")
    @ApiModelProperty(value = "3次谐波有功功率-平均值")
    private Double harmonicActivePower3Avg;

    /**
     * 3次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_3_95")
    @ApiModelProperty(value = "3次谐波有功功率-95值")
    private Double harmonicActivePower395;

    /**
     * 4次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_4_MAX")
    @ApiModelProperty(value = "4次谐波有功功率-最大值")
    private Double harmonicActivePower4Max;

    /**
     * 4次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_4_MIN")
    @ApiModelProperty(value = "4次谐波有功功率-最小值")
    private Double harmonicActivePower4Min;

    /**
     * 4次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_4_AVG")
    @ApiModelProperty(value = "4次谐波有功功率-平均值")
    private Double harmonicActivePower4Avg;

    /**
     * 4次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_4_95")
    @ApiModelProperty(value = "4次谐波有功功率-95值")
    private Double harmonicActivePower495;

    /**
     * 5次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_5_MAX")
    @ApiModelProperty(value = "5次谐波有功功率-最大值")
    private Double harmonicActivePower5Max;

    /**
     * 5次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_5_MIN")
    @ApiModelProperty(value = "5次谐波有功功率-最小值")
    private Double harmonicActivePower5Min;

    /**
     * 5次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_5_AVG")
    @ApiModelProperty(value = "5次谐波有功功率-平均值")
    private Double harmonicActivePower5Avg;

    /**
     * 5次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_5_95")
    @ApiModelProperty(value = "5次谐波有功功率-95值")
    private Double harmonicActivePower595;

    /**
     * 6次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_6_MAX")
    @ApiModelProperty(value = "6次谐波有功功率-最大值")
    private Double harmonicActivePower6Max;

    /**
     * 6次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_6_MIN")
    @ApiModelProperty(value = "6次谐波有功功率-最小值")
    private Double harmonicActivePower6Min;

    /**
     * 6次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_6_AVG")
    @ApiModelProperty(value = "6次谐波有功功率-平均值")
    private Double harmonicActivePower6Avg;

    /**
     * 6次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_6_95")
    @ApiModelProperty(value = "6次谐波有功功率-95值")
    private Double harmonicActivePower695;

    /**
     * 7次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_7_MAX")
    @ApiModelProperty(value = "7次谐波有功功率-最大值")
    private Double harmonicActivePower7Max;

    /**
     * 7次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_7_MIN")
    @ApiModelProperty(value = "7次谐波有功功率-最小值")
    private Double harmonicActivePower7Min;

    /**
     * 7次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_7_AVG")
    @ApiModelProperty(value = "7次谐波有功功率-平均值")
    private Double harmonicActivePower7Avg;

    /**
     * 7次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_7_95")
    @ApiModelProperty(value = "7次谐波有功功率-95值")
    private Double harmonicActivePower795;

    /**
     * 8次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_8_MAX")
    @ApiModelProperty(value = "8次谐波有功功率-最大值")
    private Double harmonicActivePower8Max;

    /**
     * 8次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_8_MIN")
    @ApiModelProperty(value = "8次谐波有功功率-最小值")
    private Double harmonicActivePower8Min;

    /**
     * 8次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_8_AVG")
    @ApiModelProperty(value = "8次谐波有功功率-平均值")
    private Double harmonicActivePower8Avg;

    /**
     * 8次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_8_95")
    @ApiModelProperty(value = "8次谐波有功功率-95值")
    private Double harmonicActivePower895;

    /**
     * 9次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_9_MAX")
    @ApiModelProperty(value = "9次谐波有功功率-最大值")
    private Double harmonicActivePower9Max;

    /**
     * 9次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_9_MIN")
    @ApiModelProperty(value = "9次谐波有功功率-最小值")
    private Double harmonicActivePower9Min;

    /**
     * 9次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_9_AVG")
    @ApiModelProperty(value = "9次谐波有功功率-平均值")
    private Double harmonicActivePower9Avg;

    /**
     * 9次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_9_95")
    @ApiModelProperty(value = "9次谐波有功功率-95值")
    private Double harmonicActivePower995;

    /**
     * 10次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_10_MAX")
    @ApiModelProperty(value = "10次谐波有功功率-最大值")
    private Double harmonicActivePower10Max;

    /**
     * 10次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_10_MIN")
    @ApiModelProperty(value = "10次谐波有功功率-最小值")
    private Double harmonicActivePower10Min;

    /**
     * 10次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_10_AVG")
    @ApiModelProperty(value = "10次谐波有功功率-平均值")
    private Double harmonicActivePower10Avg;

    /**
     * 10次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_10_95")
    @ApiModelProperty(value = "10次谐波有功功率-95值")
    private Double harmonicActivePower1095;

    /**
     * 11次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_11_MAX")
    @ApiModelProperty(value = "11次谐波有功功率-最大值")
    private Double harmonicActivePower11Max;

    /**
     * 11次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_11_MIN")
    @ApiModelProperty(value = "11次谐波有功功率-最小值")
    private Double harmonicActivePower11Min;

    /**
     * 11次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_11_AVG")
    @ApiModelProperty(value = "11次谐波有功功率-平均值")
    private Double harmonicActivePower11Avg;

    /**
     * 11次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_11_95")
    @ApiModelProperty(value = "11次谐波有功功率-95值")
    private Double harmonicActivePower1195;

    /**
     * 12次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_12_MAX")
    @ApiModelProperty(value = "12次谐波有功功率-最大值")
    private Double harmonicActivePower12Max;

    /**
     * 12次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_12_MIN")
    @ApiModelProperty(value = "12次谐波有功功率-最小值")
    private Double harmonicActivePower12Min;

    /**
     * 12次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_12_AVG")
    @ApiModelProperty(value = "12次谐波有功功率-平均值")
    private Double harmonicActivePower12Avg;

    /**
     * 12次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_12_95")
    @ApiModelProperty(value = "12次谐波有功功率-95值")
    private Double harmonicActivePower1295;

    /**
     * 13次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_13_MAX")
    @ApiModelProperty(value = "13次谐波有功功率-最大值")
    private Double harmonicActivePower13Max;

    /**
     * 13次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_13_MIN")
    @ApiModelProperty(value = "13次谐波有功功率-最小值")
    private Double harmonicActivePower13Min;

    /**
     * 13次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_13_AVG")
    @ApiModelProperty(value = "13次谐波有功功率-平均值")
    private Double harmonicActivePower13Avg;

    /**
     * 13次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_13_95")
    @ApiModelProperty(value = "13次谐波有功功率-95值")
    private Double harmonicActivePower1395;

    /**
     * 14次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_14_MAX")
    @ApiModelProperty(value = "14次谐波有功功率-最大值")
    private Double harmonicActivePower14Max;

    /**
     * 14次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_14_MIN")
    @ApiModelProperty(value = "14次谐波有功功率-最小值")
    private Double harmonicActivePower14Min;

    /**
     * 14次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_14_AVG")
    @ApiModelProperty(value = "14次谐波有功功率-平均值")
    private Double harmonicActivePower14Avg;

    /**
     * 14次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_14_95")
    @ApiModelProperty(value = "14次谐波有功功率-95值")
    private Double harmonicActivePower1495;

    /**
     * 15次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_15_MAX")
    @ApiModelProperty(value = "15次谐波有功功率-最大值")
    private Double harmonicActivePower15Max;

    /**
     * 15次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_15_MIN")
    @ApiModelProperty(value = "15次谐波有功功率-最小值")
    private Double harmonicActivePower15Min;

    /**
     * 15次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_15_AVG")
    @ApiModelProperty(value = "15次谐波有功功率-平均值")
    private Double harmonicActivePower15Avg;

    /**
     * 15次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_15_95")
    @ApiModelProperty(value = "15次谐波有功功率-95值")
    private Double harmonicActivePower1595;

    /**
     * 16次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_16_MAX")
    @ApiModelProperty(value = "16次谐波有功功率-最大值")
    private Double harmonicActivePower16Max;

    /**
     * 16次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_16_MIN")
    @ApiModelProperty(value = "16次谐波有功功率-最小值")
    private Double harmonicActivePower16Min;

    /**
     * 16次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_16_AVG")
    @ApiModelProperty(value = "16次谐波有功功率-平均值")
    private Double harmonicActivePower16Avg;

    /**
     * 16次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_16_95")
    @ApiModelProperty(value = "16次谐波有功功率-95值")
    private Double harmonicActivePower1695;

    /**
     * 17次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_17_MAX")
    @ApiModelProperty(value = "17次谐波有功功率-最大值")
    private Double harmonicActivePower17Max;

    /**
     * 17次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_17_MIN")
    @ApiModelProperty(value = "17次谐波有功功率-最小值")
    private Double harmonicActivePower17Min;

    /**
     * 17次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_17_AVG")
    @ApiModelProperty(value = "17次谐波有功功率-平均值")
    private Double harmonicActivePower17Avg;

    /**
     * 17次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_17_95")
    @ApiModelProperty(value = "17次谐波有功功率-95值")
    private Double harmonicActivePower1795;

    /**
     * 18次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_18_MAX")
    @ApiModelProperty(value = "18次谐波有功功率-最大值")
    private Double harmonicActivePower18Max;

    /**
     * 18次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_18_MIN")
    @ApiModelProperty(value = "18次谐波有功功率-最小值")
    private Double harmonicActivePower18Min;

    /**
     * 18次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_18_AVG")
    @ApiModelProperty(value = "18次谐波有功功率-平均值")
    private Double harmonicActivePower18Avg;

    /**
     * 18次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_18_95")
    @ApiModelProperty(value = "18次谐波有功功率-95值")
    private Double harmonicActivePower1895;

    /**
     * 19次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_19_MAX")
    @ApiModelProperty(value = "19次谐波有功功率-最大值")
    private Double harmonicActivePower19Max;

    /**
     * 19次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_19_MIN")
    @ApiModelProperty(value = "19次谐波有功功率-最小值")
    private Double harmonicActivePower19Min;

    /**
     * 19次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_19_AVG")
    @ApiModelProperty(value = "19次谐波有功功率-平均值")
    private Double harmonicActivePower19Avg;

    /**
     * 19次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_19_95")
    @ApiModelProperty(value = "19次谐波有功功率-95值")
    private Double harmonicActivePower1995;

    /**
     * 20次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_20_MAX")
    @ApiModelProperty(value = "20次谐波有功功率-最大值")
    private Double harmonicActivePower20Max;

    /**
     * 20次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_20_MIN")
    @ApiModelProperty(value = "20次谐波有功功率-最小值")
    private Double harmonicActivePower20Min;

    /**
     * 20次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_20_AVG")
    @ApiModelProperty(value = "20次谐波有功功率-平均值")
    private Double harmonicActivePower20Avg;

    /**
     * 20次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_20_95")
    @ApiModelProperty(value = "20次谐波有功功率-95值")
    private Double harmonicActivePower2095;

    /**
     * 21次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_21_MAX")
    @ApiModelProperty(value = "21次谐波有功功率-最大值")
    private Double harmonicActivePower21Max;

    /**
     * 21次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_21_MIN")
    @ApiModelProperty(value = "21次谐波有功功率-最小值")
    private Double harmonicActivePower21Min;

    /**
     * 21次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_21_AVG")
    @ApiModelProperty(value = "21次谐波有功功率-平均值")
    private Double harmonicActivePower21Avg;

    /**
     * 21次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_21_95")
    @ApiModelProperty(value = "21次谐波有功功率-95值")
    private Double harmonicActivePower2195;

    /**
     * 22次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_22_MAX")
    @ApiModelProperty(value = "22次谐波有功功率-最大值")
    private Double harmonicActivePower22Max;

    /**
     * 22次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_22_MIN")
    @ApiModelProperty(value = "22次谐波有功功率-最小值")
    private Double harmonicActivePower22Min;

    /**
     * 22次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_22_AVG")
    @ApiModelProperty(value = "22次谐波有功功率-平均值")
    private Double harmonicActivePower22Avg;

    /**
     * 22次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_22_95")
    @ApiModelProperty(value = "22次谐波有功功率-95值")
    private Double harmonicActivePower2295;

    /**
     * 23次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_23_MAX")
    @ApiModelProperty(value = "23次谐波有功功率-最大值")
    private Double harmonicActivePower23Max;

    /**
     * 23次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_23_MIN")
    @ApiModelProperty(value = "23次谐波有功功率-最小值")
    private Double harmonicActivePower23Min;

    /**
     * 23次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_23_AVG")
    @ApiModelProperty(value = "23次谐波有功功率-平均值")
    private Double harmonicActivePower23Avg;

    /**
     * 23次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_23_95")
    @ApiModelProperty(value = "23次谐波有功功率-95值")
    private Double harmonicActivePower2395;

    /**
     * 24次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_24_MAX")
    @ApiModelProperty(value = "24次谐波有功功率-最大值")
    private Double harmonicActivePower24Max;

    /**
     * 24次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_24_MIN")
    @ApiModelProperty(value = "24次谐波有功功率-最小值")
    private Double harmonicActivePower24Min;

    /**
     * 24次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_24_AVG")
    @ApiModelProperty(value = "24次谐波有功功率-平均值")
    private Double harmonicActivePower24Avg;

    /**
     * 24次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_24_95")
    @ApiModelProperty(value = "24次谐波有功功率-95值")
    private Double harmonicActivePower2495;

    /**
     * 25次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_25_MAX")
    @ApiModelProperty(value = "25次谐波有功功率-最大值")
    private Double harmonicActivePower25Max;

    /**
     * 25次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_25_MIN")
    @ApiModelProperty(value = "25次谐波有功功率-最小值")
    private Double harmonicActivePower25Min;

    /**
     * 25次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_25_AVG")
    @ApiModelProperty(value = "25次谐波有功功率-平均值")
    private Double harmonicActivePower25Avg;

    /**
     * 25次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_25_95")
    @ApiModelProperty(value = "25次谐波有功功率-95值")
    private Double harmonicActivePower2595;

    /**
     * 26次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_26_MAX")
    @ApiModelProperty(value = "26次谐波有功功率-最大值")
    private Double harmonicActivePower26Max;

    /**
     * 26次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_26_MIN")
    @ApiModelProperty(value = "26次谐波有功功率-最小值")
    private Double harmonicActivePower26Min;

    /**
     * 26次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_26_AVG")
    @ApiModelProperty(value = "26次谐波有功功率-平均值")
    private Double harmonicActivePower26Avg;

    /**
     * 26次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_26_95")
    @ApiModelProperty(value = "26次谐波有功功率-95值")
    private Double harmonicActivePower2695;

    /**
     * 27次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_27_MAX")
    @ApiModelProperty(value = "27次谐波有功功率-最大值")
    private Double harmonicActivePower27Max;

    /**
     * 27次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_27_MIN")
    @ApiModelProperty(value = "27次谐波有功功率-最小值")
    private Double harmonicActivePower27Min;

    /**
     * 27次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_27_AVG")
    @ApiModelProperty(value = "27次谐波有功功率-平均值")
    private Double harmonicActivePower27Avg;

    /**
     * 27次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_27_95")
    @ApiModelProperty(value = "27次谐波有功功率-95值")
    private Double harmonicActivePower2795;

    /**
     * 28次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_28_MAX")
    @ApiModelProperty(value = "28次谐波有功功率-最大值")
    private Double harmonicActivePower28Max;

    /**
     * 28次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_28_MIN")
    @ApiModelProperty(value = "28次谐波有功功率-最小值")
    private Double harmonicActivePower28Min;

    /**
     * 28次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_28_AVG")
    @ApiModelProperty(value = "28次谐波有功功率-平均值")
    private Double harmonicActivePower28Avg;

    /**
     * 28次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_28_95")
    @ApiModelProperty(value = "28次谐波有功功率-95值")
    private Double harmonicActivePower2895;

    /**
     * 29次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_29_MAX")
    @ApiModelProperty(value = "29次谐波有功功率-最大值")
    private Double harmonicActivePower29Max;

    /**
     * 29次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_29_MIN")
    @ApiModelProperty(value = "29次谐波有功功率-最小值")
    private Double harmonicActivePower29Min;

    /**
     * 29次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_29_AVG")
    @ApiModelProperty(value = "29次谐波有功功率-平均值")
    private Double harmonicActivePower29Avg;

    /**
     * 29次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_29_95")
    @ApiModelProperty(value = "29次谐波有功功率-95值")
    private Double harmonicActivePower2995;

    /**
     * 30次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_30_MAX")
    @ApiModelProperty(value = "30次谐波有功功率-最大值")
    private Double harmonicActivePower30Max;

    /**
     * 30次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_30_MIN")
    @ApiModelProperty(value = "30次谐波有功功率-最小值")
    private Double harmonicActivePower30Min;

    /**
     * 30次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_30_AVG")
    @ApiModelProperty(value = "30次谐波有功功率-平均值")
    private Double harmonicActivePower30Avg;

    /**
     * 30次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_30_95")
    @ApiModelProperty(value = "30次谐波有功功率-95值")
    private Double harmonicActivePower3095;

    /**
     * 31次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_31_MAX")
    @ApiModelProperty(value = "31次谐波有功功率-最大值")
    private Double harmonicActivePower31Max;

    /**
     * 31次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_31_MIN")
    @ApiModelProperty(value = "31次谐波有功功率-最小值")
    private Double harmonicActivePower31Min;

    /**
     * 31次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_31_AVG")
    @ApiModelProperty(value = "31次谐波有功功率-平均值")
    private Double harmonicActivePower31Avg;

    /**
     * 31次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_31_95")
    @ApiModelProperty(value = "31次谐波有功功率-95值")
    private Double harmonicActivePower3195;

    /**
     * 32次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_32_MAX")
    @ApiModelProperty(value = "32次谐波有功功率-最大值")
    private Double harmonicActivePower32Max;

    /**
     * 32次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_32_MIN")
    @ApiModelProperty(value = "32次谐波有功功率-最小值")
    private Double harmonicActivePower32Min;

    /**
     * 32次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_32_AVG")
    @ApiModelProperty(value = "32次谐波有功功率-平均值")
    private Double harmonicActivePower32Avg;

    /**
     * 32次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_32_95")
    @ApiModelProperty(value = "32次谐波有功功率-95值")
    private Double harmonicActivePower3295;

    /**
     * 33次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_33_MAX")
    @ApiModelProperty(value = "33次谐波有功功率-最大值")
    private Double harmonicActivePower33Max;

    /**
     * 33次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_33_MIN")
    @ApiModelProperty(value = "33次谐波有功功率-最小值")
    private Double harmonicActivePower33Min;

    /**
     * 33次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_33_AVG")
    @ApiModelProperty(value = "33次谐波有功功率-平均值")
    private Double harmonicActivePower33Avg;

    /**
     * 33次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_33_95")
    @ApiModelProperty(value = "33次谐波有功功率-95值")
    private Double harmonicActivePower3395;

    /**
     * 34次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_34_MAX")
    @ApiModelProperty(value = "34次谐波有功功率-最大值")
    private Double harmonicActivePower34Max;

    /**
     * 34次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_34_MIN")
    @ApiModelProperty(value = "34次谐波有功功率-最小值")
    private Double harmonicActivePower34Min;

    /**
     * 34次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_34_AVG")
    @ApiModelProperty(value = "34次谐波有功功率-平均值")
    private Double harmonicActivePower34Avg;

    /**
     * 34次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_34_95")
    @ApiModelProperty(value = "34次谐波有功功率-95值")
    private Double harmonicActivePower3495;

    /**
     * 35次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_35_MAX")
    @ApiModelProperty(value = "35次谐波有功功率-最大值")
    private Double harmonicActivePower35Max;

    /**
     * 35次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_35_MIN")
    @ApiModelProperty(value = "35次谐波有功功率-最小值")
    private Double harmonicActivePower35Min;

    /**
     * 35次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_35_AVG")
    @ApiModelProperty(value = "35次谐波有功功率-平均值")
    private Double harmonicActivePower35Avg;

    /**
     * 35次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_35_95")
    @ApiModelProperty(value = "35次谐波有功功率-95值")
    private Double harmonicActivePower3595;

    /**
     * 36次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_36_MAX")
    @ApiModelProperty(value = "36次谐波有功功率-最大值")
    private Double harmonicActivePower36Max;

    /**
     * 36次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_36_MIN")
    @ApiModelProperty(value = "36次谐波有功功率-最小值")
    private Double harmonicActivePower36Min;

    /**
     * 36次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_36_AVG")
    @ApiModelProperty(value = "36次谐波有功功率-平均值")
    private Double harmonicActivePower36Avg;

    /**
     * 36次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_36_95")
    @ApiModelProperty(value = "36次谐波有功功率-95值")
    private Double harmonicActivePower3695;

    /**
     * 37次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_37_MAX")
    @ApiModelProperty(value = "37次谐波有功功率-最大值")
    private Double harmonicActivePower37Max;

    /**
     * 37次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_37_MIN")
    @ApiModelProperty(value = "37次谐波有功功率-最小值")
    private Double harmonicActivePower37Min;

    /**
     * 37次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_37_AVG")
    @ApiModelProperty(value = "37次谐波有功功率-平均值")
    private Double harmonicActivePower37Avg;

    /**
     * 37次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_37_95")
    @ApiModelProperty(value = "37次谐波有功功率-95值")
    private Double harmonicActivePower3795;

    /**
     * 38次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_38_MAX")
    @ApiModelProperty(value = "38次谐波有功功率-最大值")
    private Double harmonicActivePower38Max;

    /**
     * 38次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_38_MIN")
    @ApiModelProperty(value = "38次谐波有功功率-最小值")
    private Double harmonicActivePower38Min;

    /**
     * 38次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_38_AVG")
    @ApiModelProperty(value = "38次谐波有功功率-平均值")
    private Double harmonicActivePower38Avg;

    /**
     * 38次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_38_95")
    @ApiModelProperty(value = "38次谐波有功功率-95值")
    private Double harmonicActivePower3895;

    /**
     * 39次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_39_MAX")
    @ApiModelProperty(value = "39次谐波有功功率-最大值")
    private Double harmonicActivePower39Max;

    /**
     * 39次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_39_MIN")
    @ApiModelProperty(value = "39次谐波有功功率-最小值")
    private Double harmonicActivePower39Min;

    /**
     * 39次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_39_AVG")
    @ApiModelProperty(value = "39次谐波有功功率-平均值")
    private Double harmonicActivePower39Avg;

    /**
     * 39次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_39_95")
    @ApiModelProperty(value = "39次谐波有功功率-95值")
    private Double harmonicActivePower3995;

    /**
     * 40次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_40_MAX")
    @ApiModelProperty(value = "40次谐波有功功率-最大值")
    private Double harmonicActivePower40Max;

    /**
     * 40次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_40_MIN")
    @ApiModelProperty(value = "40次谐波有功功率-最小值")
    private Double harmonicActivePower40Min;

    /**
     * 40次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_40_AVG")
    @ApiModelProperty(value = "40次谐波有功功率-平均值")
    private Double harmonicActivePower40Avg;

    /**
     * 40次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_40_95")
    @ApiModelProperty(value = "40次谐波有功功率-95值")
    private Double harmonicActivePower4095;

    /**
     * 41次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_41_MAX")
    @ApiModelProperty(value = "41次谐波有功功率-最大值")
    private Double harmonicActivePower41Max;

    /**
     * 41次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_41_MIN")
    @ApiModelProperty(value = "41次谐波有功功率-最小值")
    private Double harmonicActivePower41Min;

    /**
     * 41次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_41_AVG")
    @ApiModelProperty(value = "41次谐波有功功率-平均值")
    private Double harmonicActivePower41Avg;

    /**
     * 41次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_41_95")
    @ApiModelProperty(value = "41次谐波有功功率-95值")
    private Double harmonicActivePower4195;

    /**
     * 42次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_42_MAX")
    @ApiModelProperty(value = "42次谐波有功功率-最大值")
    private Double harmonicActivePower42Max;

    /**
     * 42次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_42_MIN")
    @ApiModelProperty(value = "42次谐波有功功率-最小值")
    private Double harmonicActivePower42Min;

    /**
     * 42次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_42_AVG")
    @ApiModelProperty(value = "42次谐波有功功率-平均值")
    private Double harmonicActivePower42Avg;

    /**
     * 42次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_42_95")
    @ApiModelProperty(value = "42次谐波有功功率-95值")
    private Double harmonicActivePower4295;

    /**
     * 43次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_43_MAX")
    @ApiModelProperty(value = "43次谐波有功功率-最大值")
    private Double harmonicActivePower43Max;

    /**
     * 43次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_43_MIN")
    @ApiModelProperty(value = "43次谐波有功功率-最小值")
    private Double harmonicActivePower43Min;

    /**
     * 43次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_43_AVG")
    @ApiModelProperty(value = "43次谐波有功功率-平均值")
    private Double harmonicActivePower43Avg;

    /**
     * 43次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_43_95")
    @ApiModelProperty(value = "43次谐波有功功率-95值")
    private Double harmonicActivePower4395;

    /**
     * 44次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_44_MAX")
    @ApiModelProperty(value = "44次谐波有功功率-最大值")
    private Double harmonicActivePower44Max;

    /**
     * 44次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_44_MIN")
    @ApiModelProperty(value = "44次谐波有功功率-最小值")
    private Double harmonicActivePower44Min;

    /**
     * 44次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_44_AVG")
    @ApiModelProperty(value = "44次谐波有功功率-平均值")
    private Double harmonicActivePower44Avg;

    /**
     * 44次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_44_95")
    @ApiModelProperty(value = "44次谐波有功功率-95值")
    private Double harmonicActivePower4495;

    /**
     * 45次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_45_MAX")
    @ApiModelProperty(value = "45次谐波有功功率-最大值")
    private Double harmonicActivePower45Max;

    /**
     * 45次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_45_MIN")
    @ApiModelProperty(value = "45次谐波有功功率-最小值")
    private Double harmonicActivePower45Min;

    /**
     * 45次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_45_AVG")
    @ApiModelProperty(value = "45次谐波有功功率-平均值")
    private Double harmonicActivePower45Avg;

    /**
     * 45次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_45_95")
    @ApiModelProperty(value = "45次谐波有功功率-95值")
    private Double harmonicActivePower4595;

    /**
     * 46次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_46_MAX")
    @ApiModelProperty(value = "46次谐波有功功率-最大值")
    private Double harmonicActivePower46Max;

    /**
     * 46次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_46_MIN")
    @ApiModelProperty(value = "46次谐波有功功率-最小值")
    private Double harmonicActivePower46Min;

    /**
     * 46次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_46_AVG")
    @ApiModelProperty(value = "46次谐波有功功率-平均值")
    private Double harmonicActivePower46Avg;

    /**
     * 46次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_46_95")
    @ApiModelProperty(value = "46次谐波有功功率-95值")
    private Double harmonicActivePower4695;

    /**
     * 47次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_47_MAX")
    @ApiModelProperty(value = "47次谐波有功功率-最大值")
    private Double harmonicActivePower47Max;

    /**
     * 47次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_47_MIN")
    @ApiModelProperty(value = "47次谐波有功功率-最小值")
    private Double harmonicActivePower47Min;

    /**
     * 47次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_47_AVG")
    @ApiModelProperty(value = "47次谐波有功功率-平均值")
    private Double harmonicActivePower47Avg;

    /**
     * 47次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_47_95")
    @ApiModelProperty(value = "47次谐波有功功率-95值")
    private Double harmonicActivePower4795;

    /**
     * 48次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_48_MAX")
    @ApiModelProperty(value = "48次谐波有功功率-最大值")
    private Double harmonicActivePower48Max;

    /**
     * 48次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_48_MIN")
    @ApiModelProperty(value = "48次谐波有功功率-最小值")
    private Double harmonicActivePower48Min;

    /**
     * 48次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_48_AVG")
    @ApiModelProperty(value = "48次谐波有功功率-平均值")
    private Double harmonicActivePower48Avg;

    /**
     * 48次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_48_95")
    @ApiModelProperty(value = "48次谐波有功功率-95值")
    private Double harmonicActivePower4895;

    /**
     * 49次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_49_MAX")
    @ApiModelProperty(value = "49次谐波有功功率-最大值")
    private Double harmonicActivePower49Max;

    /**
     * 49次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_49_MIN")
    @ApiModelProperty(value = "49次谐波有功功率-最小值")
    private Double harmonicActivePower49Min;

    /**
     * 49次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_49_AVG")
    @ApiModelProperty(value = "49次谐波有功功率-平均值")
    private Double harmonicActivePower49Avg;

    /**
     * 49次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_49_95")
    @ApiModelProperty(value = "49次谐波有功功率-95值")
    private Double harmonicActivePower4995;

    /**
     * 50次谐波有功功率-最大值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_50_MAX")
    @ApiModelProperty(value = "50次谐波有功功率-最大值")
    private Double harmonicActivePower50Max;

    /**
     * 50次谐波有功功率-最小值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_50_MIN")
    @ApiModelProperty(value = "50次谐波有功功率-最小值")
    private Double harmonicActivePower50Min;

    /**
     * 50次谐波有功功率-平均值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_50_AVG")
    @ApiModelProperty(value = "50次谐波有功功率-平均值")
    private Double harmonicActivePower50Avg;

    /**
     * 50次谐波有功功率-95值
     */
    @TableField(value = "HARMONIC_ACTIVE_POWER_50_95")
    @ApiModelProperty(value = "50次谐波有功功率-95值")
    private Double harmonicActivePower5095;

    /**
     * 获取监测点ID
     *
     * @return measurement_point_id - 监测点ID
     */
    public String getMeasurementPointId() {
        return measurementPointId;
    }

    /**
     * 设置监测点ID
     *
     * @param measurementPointId 监测点ID
     */
    public void setMeasurementPointId(String measurementPointId) {
        this.measurementPointId = measurementPointId;
    }

    /**
     * 获取生成数据的时间,每日统计一次
     *
     * @return data_date - 生成数据的时间,每日统计一次
     */
    public Date getDataDate() {
        return dataDate;
    }

    /**
     * 设置生成数据的时间,每日统计一次
     *
     * @param dataDate 生成数据的时间,每日统计一次
     */
    public void setDataDate(Date dataDate) {
        this.dataDate = dataDate;
    }

    /**
     * 获取相别："A" "B" "C" "ABC" "T"  配网部分相别的数据采用T标志存储
     *
     * @return phase - 相别："A" "B" "C" "ABC" "T"  配网部分相别的数据采用T标志存储
     */
    public String getPhase() {
        return phase;
    }

    /**
     * 设置相别："A" "B" "C" "ABC" "T"  配网部分相别的数据采用T标志存储
     *
     * @param phase 相别："A" "B" "C" "ABC" "T"  配网部分相别的数据采用T标志存储
     */
    public void setPhase(String phase) {
        this.phase = phase;
    }

    /**
     * 获取基波无功功率-最大值
     *
     * @return FUNDAMENTAL_RATEOFWORK_MAX - 基波无功功率-最大值
     */
    public Double getFundamentalRateofworkMax() {
        return fundamentalRateofworkMax;
    }

    /**
     * 设置基波无功功率-最大值
     *
     * @param fundamentalRateofworkMax 基波无功功率-最大值
     */
    public void setFundamentalRateofworkMax(Double fundamentalRateofworkMax) {
        this.fundamentalRateofworkMax = fundamentalRateofworkMax;
    }

    /**
     * 获取基波无功功率-最小值
     *
     * @return FUNDAMENTAL_RATEOFWORK_Min - 基波无功功率-最小值
     */
    public Double getFundamentalRateofworkMin() {
        return fundamentalRateofworkMin;
    }

    /**
     * 设置基波无功功率-最小值
     *
     * @param fundamentalRateofworkMin 基波无功功率-最小值
     */
    public void setFundamentalRateofworkMin(Double fundamentalRateofworkMin) {
        this.fundamentalRateofworkMin = fundamentalRateofworkMin;
    }

    /**
     * 获取基波无功功率-平均值
     *
     * @return FUNDAMENTAL_RATEOFWORK_avg - 基波无功功率-平均值
     */
    public Double getFundamentalRateofworkAvg() {
        return fundamentalRateofworkAvg;
    }

    /**
     * 设置基波无功功率-平均值
     *
     * @param fundamentalRateofworkAvg 基波无功功率-平均值
     */
    public void setFundamentalRateofworkAvg(Double fundamentalRateofworkAvg) {
        this.fundamentalRateofworkAvg = fundamentalRateofworkAvg;
    }

    /**
     * 获取基波无功功率-95值
     *
     * @return FUNDAMENTAL_RATEOFWORK_95 - 基波无功功率-95值
     */
    public Double getFundamentalRateofwork95() {
        return fundamentalRateofwork95;
    }

    /**
     * 设置基波无功功率-95值
     *
     * @param fundamentalRateofwork95 基波无功功率-95值
     */
    public void setFundamentalRateofwork95(Double fundamentalRateofwork95) {
        this.fundamentalRateofwork95 = fundamentalRateofwork95;
    }

    /**
     * 获取基波有功功率-最大值
     *
     * @return FUNDAMENTAL_ACTIVE_POWER_MAX - 基波有功功率-最大值
     */
    public Double getFundamentalActivePowerMax() {
        return fundamentalActivePowerMax;
    }

    /**
     * 设置基波有功功率-最大值
     *
     * @param fundamentalActivePowerMax 基波有功功率-最大值
     */
    public void setFundamentalActivePowerMax(Double fundamentalActivePowerMax) {
        this.fundamentalActivePowerMax = fundamentalActivePowerMax;
    }

    /**
     * 获取基波有功功率-最小值
     *
     * @return FUNDAMENTAL_ACTIVE_POWER_Min - 基波有功功率-最小值
     */
    public Double getFundamentalActivePowerMin() {
        return fundamentalActivePowerMin;
    }

    /**
     * 设置基波有功功率-最小值
     *
     * @param fundamentalActivePowerMin 基波有功功率-最小值
     */
    public void setFundamentalActivePowerMin(Double fundamentalActivePowerMin) {
        this.fundamentalActivePowerMin = fundamentalActivePowerMin;
    }

    /**
     * 获取基波有功功率-平均值
     *
     * @return FUNDAMENTAL_ACTIVE_POWER_avg - 基波有功功率-平均值
     */
    public Double getFundamentalActivePowerAvg() {
        return fundamentalActivePowerAvg;
    }

    /**
     * 设置基波有功功率-平均值
     *
     * @param fundamentalActivePowerAvg 基波有功功率-平均值
     */
    public void setFundamentalActivePowerAvg(Double fundamentalActivePowerAvg) {
        this.fundamentalActivePowerAvg = fundamentalActivePowerAvg;
    }

    /**
     * 获取基波有功功率-95值
     *
     * @return FUNDAMENTAL_ACTIVE_POWER_95 - 基波有功功率-95值
     */
    public Double getFundamentalActivePower95() {
        return fundamentalActivePower95;
    }

    /**
     * 设置基波有功功率-95值
     *
     * @param fundamentalActivePower95 基波有功功率-95值
     */
    public void setFundamentalActivePower95(Double fundamentalActivePower95) {
        this.fundamentalActivePower95 = fundamentalActivePower95;
    }

    /**
     * 获取2次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_2_MAX - 2次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower2Max() {
        return harmonicActivePower2Max;
    }

    /**
     * 设置2次谐波有功功率-最大值
     *
     * @param harmonicActivePower2Max 2次谐波有功功率-最大值
     */
    public void setHarmonicActivePower2Max(Double harmonicActivePower2Max) {
        this.harmonicActivePower2Max = harmonicActivePower2Max;
    }

    /**
     * 获取2次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_2_MIN - 2次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower2Min() {
        return harmonicActivePower2Min;
    }

    /**
     * 设置2次谐波有功功率-最小值
     *
     * @param harmonicActivePower2Min 2次谐波有功功率-最小值
     */
    public void setHarmonicActivePower2Min(Double harmonicActivePower2Min) {
        this.harmonicActivePower2Min = harmonicActivePower2Min;
    }

    /**
     * 获取2次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_2_AVG - 2次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower2Avg() {
        return harmonicActivePower2Avg;
    }

    /**
     * 设置2次谐波有功功率-平均值
     *
     * @param harmonicActivePower2Avg 2次谐波有功功率-平均值
     */
    public void setHarmonicActivePower2Avg(Double harmonicActivePower2Avg) {
        this.harmonicActivePower2Avg = harmonicActivePower2Avg;
    }

    /**
     * 获取2次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_2_95 - 2次谐波有功功率-95值
     */
    public Double getHarmonicActivePower295() {
        return harmonicActivePower295;
    }

    /**
     * 设置2次谐波有功功率-95值
     *
     * @param harmonicActivePower295 2次谐波有功功率-95值
     */
    public void setHarmonicActivePower295(Double harmonicActivePower295) {
        this.harmonicActivePower295 = harmonicActivePower295;
    }

    /**
     * 获取3次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_3_MAX - 3次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower3Max() {
        return harmonicActivePower3Max;
    }

    /**
     * 设置3次谐波有功功率-最大值
     *
     * @param harmonicActivePower3Max 3次谐波有功功率-最大值
     */
    public void setHarmonicActivePower3Max(Double harmonicActivePower3Max) {
        this.harmonicActivePower3Max = harmonicActivePower3Max;
    }

    /**
     * 获取3次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_3_MIN - 3次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower3Min() {
        return harmonicActivePower3Min;
    }

    /**
     * 设置3次谐波有功功率-最小值
     *
     * @param harmonicActivePower3Min 3次谐波有功功率-最小值
     */
    public void setHarmonicActivePower3Min(Double harmonicActivePower3Min) {
        this.harmonicActivePower3Min = harmonicActivePower3Min;
    }

    /**
     * 获取3次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_3_AVG - 3次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower3Avg() {
        return harmonicActivePower3Avg;
    }

    /**
     * 设置3次谐波有功功率-平均值
     *
     * @param harmonicActivePower3Avg 3次谐波有功功率-平均值
     */
    public void setHarmonicActivePower3Avg(Double harmonicActivePower3Avg) {
        this.harmonicActivePower3Avg = harmonicActivePower3Avg;
    }

    /**
     * 获取3次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_3_95 - 3次谐波有功功率-95值
     */
    public Double getHarmonicActivePower395() {
        return harmonicActivePower395;
    }

    /**
     * 设置3次谐波有功功率-95值
     *
     * @param harmonicActivePower395 3次谐波有功功率-95值
     */
    public void setHarmonicActivePower395(Double harmonicActivePower395) {
        this.harmonicActivePower395 = harmonicActivePower395;
    }

    /**
     * 获取4次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_4_MAX - 4次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower4Max() {
        return harmonicActivePower4Max;
    }

    /**
     * 设置4次谐波有功功率-最大值
     *
     * @param harmonicActivePower4Max 4次谐波有功功率-最大值
     */
    public void setHarmonicActivePower4Max(Double harmonicActivePower4Max) {
        this.harmonicActivePower4Max = harmonicActivePower4Max;
    }

    /**
     * 获取4次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_4_MIN - 4次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower4Min() {
        return harmonicActivePower4Min;
    }

    /**
     * 设置4次谐波有功功率-最小值
     *
     * @param harmonicActivePower4Min 4次谐波有功功率-最小值
     */
    public void setHarmonicActivePower4Min(Double harmonicActivePower4Min) {
        this.harmonicActivePower4Min = harmonicActivePower4Min;
    }

    /**
     * 获取4次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_4_AVG - 4次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower4Avg() {
        return harmonicActivePower4Avg;
    }

    /**
     * 设置4次谐波有功功率-平均值
     *
     * @param harmonicActivePower4Avg 4次谐波有功功率-平均值
     */
    public void setHarmonicActivePower4Avg(Double harmonicActivePower4Avg) {
        this.harmonicActivePower4Avg = harmonicActivePower4Avg;
    }

    /**
     * 获取4次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_4_95 - 4次谐波有功功率-95值
     */
    public Double getHarmonicActivePower495() {
        return harmonicActivePower495;
    }

    /**
     * 设置4次谐波有功功率-95值
     *
     * @param harmonicActivePower495 4次谐波有功功率-95值
     */
    public void setHarmonicActivePower495(Double harmonicActivePower495) {
        this.harmonicActivePower495 = harmonicActivePower495;
    }

    /**
     * 获取5次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_5_MAX - 5次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower5Max() {
        return harmonicActivePower5Max;
    }

    /**
     * 设置5次谐波有功功率-最大值
     *
     * @param harmonicActivePower5Max 5次谐波有功功率-最大值
     */
    public void setHarmonicActivePower5Max(Double harmonicActivePower5Max) {
        this.harmonicActivePower5Max = harmonicActivePower5Max;
    }

    /**
     * 获取5次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_5_MIN - 5次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower5Min() {
        return harmonicActivePower5Min;
    }

    /**
     * 设置5次谐波有功功率-最小值
     *
     * @param harmonicActivePower5Min 5次谐波有功功率-最小值
     */
    public void setHarmonicActivePower5Min(Double harmonicActivePower5Min) {
        this.harmonicActivePower5Min = harmonicActivePower5Min;
    }

    /**
     * 获取5次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_5_AVG - 5次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower5Avg() {
        return harmonicActivePower5Avg;
    }

    /**
     * 设置5次谐波有功功率-平均值
     *
     * @param harmonicActivePower5Avg 5次谐波有功功率-平均值
     */
    public void setHarmonicActivePower5Avg(Double harmonicActivePower5Avg) {
        this.harmonicActivePower5Avg = harmonicActivePower5Avg;
    }

    /**
     * 获取5次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_5_95 - 5次谐波有功功率-95值
     */
    public Double getHarmonicActivePower595() {
        return harmonicActivePower595;
    }

    /**
     * 设置5次谐波有功功率-95值
     *
     * @param harmonicActivePower595 5次谐波有功功率-95值
     */
    public void setHarmonicActivePower595(Double harmonicActivePower595) {
        this.harmonicActivePower595 = harmonicActivePower595;
    }

    /**
     * 获取6次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_6_MAX - 6次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower6Max() {
        return harmonicActivePower6Max;
    }

    /**
     * 设置6次谐波有功功率-最大值
     *
     * @param harmonicActivePower6Max 6次谐波有功功率-最大值
     */
    public void setHarmonicActivePower6Max(Double harmonicActivePower6Max) {
        this.harmonicActivePower6Max = harmonicActivePower6Max;
    }

    /**
     * 获取6次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_6_MIN - 6次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower6Min() {
        return harmonicActivePower6Min;
    }

    /**
     * 设置6次谐波有功功率-最小值
     *
     * @param harmonicActivePower6Min 6次谐波有功功率-最小值
     */
    public void setHarmonicActivePower6Min(Double harmonicActivePower6Min) {
        this.harmonicActivePower6Min = harmonicActivePower6Min;
    }

    /**
     * 获取6次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_6_AVG - 6次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower6Avg() {
        return harmonicActivePower6Avg;
    }

    /**
     * 设置6次谐波有功功率-平均值
     *
     * @param harmonicActivePower6Avg 6次谐波有功功率-平均值
     */
    public void setHarmonicActivePower6Avg(Double harmonicActivePower6Avg) {
        this.harmonicActivePower6Avg = harmonicActivePower6Avg;
    }

    /**
     * 获取6次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_6_95 - 6次谐波有功功率-95值
     */
    public Double getHarmonicActivePower695() {
        return harmonicActivePower695;
    }

    /**
     * 设置6次谐波有功功率-95值
     *
     * @param harmonicActivePower695 6次谐波有功功率-95值
     */
    public void setHarmonicActivePower695(Double harmonicActivePower695) {
        this.harmonicActivePower695 = harmonicActivePower695;
    }

    /**
     * 获取7次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_7_MAX - 7次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower7Max() {
        return harmonicActivePower7Max;
    }

    /**
     * 设置7次谐波有功功率-最大值
     *
     * @param harmonicActivePower7Max 7次谐波有功功率-最大值
     */
    public void setHarmonicActivePower7Max(Double harmonicActivePower7Max) {
        this.harmonicActivePower7Max = harmonicActivePower7Max;
    }

    /**
     * 获取7次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_7_MIN - 7次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower7Min() {
        return harmonicActivePower7Min;
    }

    /**
     * 设置7次谐波有功功率-最小值
     *
     * @param harmonicActivePower7Min 7次谐波有功功率-最小值
     */
    public void setHarmonicActivePower7Min(Double harmonicActivePower7Min) {
        this.harmonicActivePower7Min = harmonicActivePower7Min;
    }

    /**
     * 获取7次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_7_AVG - 7次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower7Avg() {
        return harmonicActivePower7Avg;
    }

    /**
     * 设置7次谐波有功功率-平均值
     *
     * @param harmonicActivePower7Avg 7次谐波有功功率-平均值
     */
    public void setHarmonicActivePower7Avg(Double harmonicActivePower7Avg) {
        this.harmonicActivePower7Avg = harmonicActivePower7Avg;
    }

    /**
     * 获取7次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_7_95 - 7次谐波有功功率-95值
     */
    public Double getHarmonicActivePower795() {
        return harmonicActivePower795;
    }

    /**
     * 设置7次谐波有功功率-95值
     *
     * @param harmonicActivePower795 7次谐波有功功率-95值
     */
    public void setHarmonicActivePower795(Double harmonicActivePower795) {
        this.harmonicActivePower795 = harmonicActivePower795;
    }

    /**
     * 获取8次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_8_MAX - 8次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower8Max() {
        return harmonicActivePower8Max;
    }

    /**
     * 设置8次谐波有功功率-最大值
     *
     * @param harmonicActivePower8Max 8次谐波有功功率-最大值
     */
    public void setHarmonicActivePower8Max(Double harmonicActivePower8Max) {
        this.harmonicActivePower8Max = harmonicActivePower8Max;
    }

    /**
     * 获取8次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_8_MIN - 8次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower8Min() {
        return harmonicActivePower8Min;
    }

    /**
     * 设置8次谐波有功功率-最小值
     *
     * @param harmonicActivePower8Min 8次谐波有功功率-最小值
     */
    public void setHarmonicActivePower8Min(Double harmonicActivePower8Min) {
        this.harmonicActivePower8Min = harmonicActivePower8Min;
    }

    /**
     * 获取8次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_8_AVG - 8次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower8Avg() {
        return harmonicActivePower8Avg;
    }

    /**
     * 设置8次谐波有功功率-平均值
     *
     * @param harmonicActivePower8Avg 8次谐波有功功率-平均值
     */
    public void setHarmonicActivePower8Avg(Double harmonicActivePower8Avg) {
        this.harmonicActivePower8Avg = harmonicActivePower8Avg;
    }

    /**
     * 获取8次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_8_95 - 8次谐波有功功率-95值
     */
    public Double getHarmonicActivePower895() {
        return harmonicActivePower895;
    }

    /**
     * 设置8次谐波有功功率-95值
     *
     * @param harmonicActivePower895 8次谐波有功功率-95值
     */
    public void setHarmonicActivePower895(Double harmonicActivePower895) {
        this.harmonicActivePower895 = harmonicActivePower895;
    }

    /**
     * 获取9次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_9_MAX - 9次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower9Max() {
        return harmonicActivePower9Max;
    }

    /**
     * 设置9次谐波有功功率-最大值
     *
     * @param harmonicActivePower9Max 9次谐波有功功率-最大值
     */
    public void setHarmonicActivePower9Max(Double harmonicActivePower9Max) {
        this.harmonicActivePower9Max = harmonicActivePower9Max;
    }

    /**
     * 获取9次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_9_MIN - 9次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower9Min() {
        return harmonicActivePower9Min;
    }

    /**
     * 设置9次谐波有功功率-最小值
     *
     * @param harmonicActivePower9Min 9次谐波有功功率-最小值
     */
    public void setHarmonicActivePower9Min(Double harmonicActivePower9Min) {
        this.harmonicActivePower9Min = harmonicActivePower9Min;
    }

    /**
     * 获取9次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_9_AVG - 9次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower9Avg() {
        return harmonicActivePower9Avg;
    }

    /**
     * 设置9次谐波有功功率-平均值
     *
     * @param harmonicActivePower9Avg 9次谐波有功功率-平均值
     */
    public void setHarmonicActivePower9Avg(Double harmonicActivePower9Avg) {
        this.harmonicActivePower9Avg = harmonicActivePower9Avg;
    }

    /**
     * 获取9次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_9_95 - 9次谐波有功功率-95值
     */
    public Double getHarmonicActivePower995() {
        return harmonicActivePower995;
    }

    /**
     * 设置9次谐波有功功率-95值
     *
     * @param harmonicActivePower995 9次谐波有功功率-95值
     */
    public void setHarmonicActivePower995(Double harmonicActivePower995) {
        this.harmonicActivePower995 = harmonicActivePower995;
    }

    /**
     * 获取10次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_10_MAX - 10次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower10Max() {
        return harmonicActivePower10Max;
    }

    /**
     * 设置10次谐波有功功率-最大值
     *
     * @param harmonicActivePower10Max 10次谐波有功功率-最大值
     */
    public void setHarmonicActivePower10Max(Double harmonicActivePower10Max) {
        this.harmonicActivePower10Max = harmonicActivePower10Max;
    }

    /**
     * 获取10次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_10_MIN - 10次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower10Min() {
        return harmonicActivePower10Min;
    }

    /**
     * 设置10次谐波有功功率-最小值
     *
     * @param harmonicActivePower10Min 10次谐波有功功率-最小值
     */
    public void setHarmonicActivePower10Min(Double harmonicActivePower10Min) {
        this.harmonicActivePower10Min = harmonicActivePower10Min;
    }

    /**
     * 获取10次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_10_AVG - 10次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower10Avg() {
        return harmonicActivePower10Avg;
    }

    /**
     * 设置10次谐波有功功率-平均值
     *
     * @param harmonicActivePower10Avg 10次谐波有功功率-平均值
     */
    public void setHarmonicActivePower10Avg(Double harmonicActivePower10Avg) {
        this.harmonicActivePower10Avg = harmonicActivePower10Avg;
    }

    /**
     * 获取10次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_10_95 - 10次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1095() {
        return harmonicActivePower1095;
    }

    /**
     * 设置10次谐波有功功率-95值
     *
     * @param harmonicActivePower1095 10次谐波有功功率-95值
     */
    public void setHarmonicActivePower1095(Double harmonicActivePower1095) {
        this.harmonicActivePower1095 = harmonicActivePower1095;
    }

    /**
     * 获取11次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_11_MAX - 11次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower11Max() {
        return harmonicActivePower11Max;
    }

    /**
     * 设置11次谐波有功功率-最大值
     *
     * @param harmonicActivePower11Max 11次谐波有功功率-最大值
     */
    public void setHarmonicActivePower11Max(Double harmonicActivePower11Max) {
        this.harmonicActivePower11Max = harmonicActivePower11Max;
    }

    /**
     * 获取11次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_11_MIN - 11次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower11Min() {
        return harmonicActivePower11Min;
    }

    /**
     * 设置11次谐波有功功率-最小值
     *
     * @param harmonicActivePower11Min 11次谐波有功功率-最小值
     */
    public void setHarmonicActivePower11Min(Double harmonicActivePower11Min) {
        this.harmonicActivePower11Min = harmonicActivePower11Min;
    }

    /**
     * 获取11次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_11_AVG - 11次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower11Avg() {
        return harmonicActivePower11Avg;
    }

    /**
     * 设置11次谐波有功功率-平均值
     *
     * @param harmonicActivePower11Avg 11次谐波有功功率-平均值
     */
    public void setHarmonicActivePower11Avg(Double harmonicActivePower11Avg) {
        this.harmonicActivePower11Avg = harmonicActivePower11Avg;
    }

    /**
     * 获取11次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_11_95 - 11次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1195() {
        return harmonicActivePower1195;
    }

    /**
     * 设置11次谐波有功功率-95值
     *
     * @param harmonicActivePower1195 11次谐波有功功率-95值
     */
    public void setHarmonicActivePower1195(Double harmonicActivePower1195) {
        this.harmonicActivePower1195 = harmonicActivePower1195;
    }

    /**
     * 获取12次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_12_MAX - 12次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower12Max() {
        return harmonicActivePower12Max;
    }

    /**
     * 设置12次谐波有功功率-最大值
     *
     * @param harmonicActivePower12Max 12次谐波有功功率-最大值
     */
    public void setHarmonicActivePower12Max(Double harmonicActivePower12Max) {
        this.harmonicActivePower12Max = harmonicActivePower12Max;
    }

    /**
     * 获取12次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_12_MIN - 12次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower12Min() {
        return harmonicActivePower12Min;
    }

    /**
     * 设置12次谐波有功功率-最小值
     *
     * @param harmonicActivePower12Min 12次谐波有功功率-最小值
     */
    public void setHarmonicActivePower12Min(Double harmonicActivePower12Min) {
        this.harmonicActivePower12Min = harmonicActivePower12Min;
    }

    /**
     * 获取12次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_12_AVG - 12次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower12Avg() {
        return harmonicActivePower12Avg;
    }

    /**
     * 设置12次谐波有功功率-平均值
     *
     * @param harmonicActivePower12Avg 12次谐波有功功率-平均值
     */
    public void setHarmonicActivePower12Avg(Double harmonicActivePower12Avg) {
        this.harmonicActivePower12Avg = harmonicActivePower12Avg;
    }

    /**
     * 获取12次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_12_95 - 12次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1295() {
        return harmonicActivePower1295;
    }

    /**
     * 设置12次谐波有功功率-95值
     *
     * @param harmonicActivePower1295 12次谐波有功功率-95值
     */
    public void setHarmonicActivePower1295(Double harmonicActivePower1295) {
        this.harmonicActivePower1295 = harmonicActivePower1295;
    }

    /**
     * 获取13次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_13_MAX - 13次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower13Max() {
        return harmonicActivePower13Max;
    }

    /**
     * 设置13次谐波有功功率-最大值
     *
     * @param harmonicActivePower13Max 13次谐波有功功率-最大值
     */
    public void setHarmonicActivePower13Max(Double harmonicActivePower13Max) {
        this.harmonicActivePower13Max = harmonicActivePower13Max;
    }

    /**
     * 获取13次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_13_MIN - 13次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower13Min() {
        return harmonicActivePower13Min;
    }

    /**
     * 设置13次谐波有功功率-最小值
     *
     * @param harmonicActivePower13Min 13次谐波有功功率-最小值
     */
    public void setHarmonicActivePower13Min(Double harmonicActivePower13Min) {
        this.harmonicActivePower13Min = harmonicActivePower13Min;
    }

    /**
     * 获取13次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_13_AVG - 13次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower13Avg() {
        return harmonicActivePower13Avg;
    }

    /**
     * 设置13次谐波有功功率-平均值
     *
     * @param harmonicActivePower13Avg 13次谐波有功功率-平均值
     */
    public void setHarmonicActivePower13Avg(Double harmonicActivePower13Avg) {
        this.harmonicActivePower13Avg = harmonicActivePower13Avg;
    }

    /**
     * 获取13次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_13_95 - 13次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1395() {
        return harmonicActivePower1395;
    }

    /**
     * 设置13次谐波有功功率-95值
     *
     * @param harmonicActivePower1395 13次谐波有功功率-95值
     */
    public void setHarmonicActivePower1395(Double harmonicActivePower1395) {
        this.harmonicActivePower1395 = harmonicActivePower1395;
    }

    /**
     * 获取14次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_14_MAX - 14次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower14Max() {
        return harmonicActivePower14Max;
    }

    /**
     * 设置14次谐波有功功率-最大值
     *
     * @param harmonicActivePower14Max 14次谐波有功功率-最大值
     */
    public void setHarmonicActivePower14Max(Double harmonicActivePower14Max) {
        this.harmonicActivePower14Max = harmonicActivePower14Max;
    }

    /**
     * 获取14次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_14_MIN - 14次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower14Min() {
        return harmonicActivePower14Min;
    }

    /**
     * 设置14次谐波有功功率-最小值
     *
     * @param harmonicActivePower14Min 14次谐波有功功率-最小值
     */
    public void setHarmonicActivePower14Min(Double harmonicActivePower14Min) {
        this.harmonicActivePower14Min = harmonicActivePower14Min;
    }

    /**
     * 获取14次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_14_AVG - 14次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower14Avg() {
        return harmonicActivePower14Avg;
    }

    /**
     * 设置14次谐波有功功率-平均值
     *
     * @param harmonicActivePower14Avg 14次谐波有功功率-平均值
     */
    public void setHarmonicActivePower14Avg(Double harmonicActivePower14Avg) {
        this.harmonicActivePower14Avg = harmonicActivePower14Avg;
    }

    /**
     * 获取14次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_14_95 - 14次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1495() {
        return harmonicActivePower1495;
    }

    /**
     * 设置14次谐波有功功率-95值
     *
     * @param harmonicActivePower1495 14次谐波有功功率-95值
     */
    public void setHarmonicActivePower1495(Double harmonicActivePower1495) {
        this.harmonicActivePower1495 = harmonicActivePower1495;
    }

    /**
     * 获取15次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_15_MAX - 15次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower15Max() {
        return harmonicActivePower15Max;
    }

    /**
     * 设置15次谐波有功功率-最大值
     *
     * @param harmonicActivePower15Max 15次谐波有功功率-最大值
     */
    public void setHarmonicActivePower15Max(Double harmonicActivePower15Max) {
        this.harmonicActivePower15Max = harmonicActivePower15Max;
    }

    /**
     * 获取15次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_15_MIN - 15次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower15Min() {
        return harmonicActivePower15Min;
    }

    /**
     * 设置15次谐波有功功率-最小值
     *
     * @param harmonicActivePower15Min 15次谐波有功功率-最小值
     */
    public void setHarmonicActivePower15Min(Double harmonicActivePower15Min) {
        this.harmonicActivePower15Min = harmonicActivePower15Min;
    }

    /**
     * 获取15次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_15_AVG - 15次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower15Avg() {
        return harmonicActivePower15Avg;
    }

    /**
     * 设置15次谐波有功功率-平均值
     *
     * @param harmonicActivePower15Avg 15次谐波有功功率-平均值
     */
    public void setHarmonicActivePower15Avg(Double harmonicActivePower15Avg) {
        this.harmonicActivePower15Avg = harmonicActivePower15Avg;
    }

    /**
     * 获取15次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_15_95 - 15次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1595() {
        return harmonicActivePower1595;
    }

    /**
     * 设置15次谐波有功功率-95值
     *
     * @param harmonicActivePower1595 15次谐波有功功率-95值
     */
    public void setHarmonicActivePower1595(Double harmonicActivePower1595) {
        this.harmonicActivePower1595 = harmonicActivePower1595;
    }

    /**
     * 获取16次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_16_MAX - 16次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower16Max() {
        return harmonicActivePower16Max;
    }

    /**
     * 设置16次谐波有功功率-最大值
     *
     * @param harmonicActivePower16Max 16次谐波有功功率-最大值
     */
    public void setHarmonicActivePower16Max(Double harmonicActivePower16Max) {
        this.harmonicActivePower16Max = harmonicActivePower16Max;
    }

    /**
     * 获取16次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_16_MIN - 16次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower16Min() {
        return harmonicActivePower16Min;
    }

    /**
     * 设置16次谐波有功功率-最小值
     *
     * @param harmonicActivePower16Min 16次谐波有功功率-最小值
     */
    public void setHarmonicActivePower16Min(Double harmonicActivePower16Min) {
        this.harmonicActivePower16Min = harmonicActivePower16Min;
    }

    /**
     * 获取16次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_16_AVG - 16次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower16Avg() {
        return harmonicActivePower16Avg;
    }

    /**
     * 设置16次谐波有功功率-平均值
     *
     * @param harmonicActivePower16Avg 16次谐波有功功率-平均值
     */
    public void setHarmonicActivePower16Avg(Double harmonicActivePower16Avg) {
        this.harmonicActivePower16Avg = harmonicActivePower16Avg;
    }

    /**
     * 获取16次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_16_95 - 16次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1695() {
        return harmonicActivePower1695;
    }

    /**
     * 设置16次谐波有功功率-95值
     *
     * @param harmonicActivePower1695 16次谐波有功功率-95值
     */
    public void setHarmonicActivePower1695(Double harmonicActivePower1695) {
        this.harmonicActivePower1695 = harmonicActivePower1695;
    }

    /**
     * 获取17次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_17_MAX - 17次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower17Max() {
        return harmonicActivePower17Max;
    }

    /**
     * 设置17次谐波有功功率-最大值
     *
     * @param harmonicActivePower17Max 17次谐波有功功率-最大值
     */
    public void setHarmonicActivePower17Max(Double harmonicActivePower17Max) {
        this.harmonicActivePower17Max = harmonicActivePower17Max;
    }

    /**
     * 获取17次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_17_MIN - 17次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower17Min() {
        return harmonicActivePower17Min;
    }

    /**
     * 设置17次谐波有功功率-最小值
     *
     * @param harmonicActivePower17Min 17次谐波有功功率-最小值
     */
    public void setHarmonicActivePower17Min(Double harmonicActivePower17Min) {
        this.harmonicActivePower17Min = harmonicActivePower17Min;
    }

    /**
     * 获取17次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_17_AVG - 17次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower17Avg() {
        return harmonicActivePower17Avg;
    }

    /**
     * 设置17次谐波有功功率-平均值
     *
     * @param harmonicActivePower17Avg 17次谐波有功功率-平均值
     */
    public void setHarmonicActivePower17Avg(Double harmonicActivePower17Avg) {
        this.harmonicActivePower17Avg = harmonicActivePower17Avg;
    }

    /**
     * 获取17次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_17_95 - 17次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1795() {
        return harmonicActivePower1795;
    }

    /**
     * 设置17次谐波有功功率-95值
     *
     * @param harmonicActivePower1795 17次谐波有功功率-95值
     */
    public void setHarmonicActivePower1795(Double harmonicActivePower1795) {
        this.harmonicActivePower1795 = harmonicActivePower1795;
    }

    /**
     * 获取18次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_18_MAX - 18次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower18Max() {
        return harmonicActivePower18Max;
    }

    /**
     * 设置18次谐波有功功率-最大值
     *
     * @param harmonicActivePower18Max 18次谐波有功功率-最大值
     */
    public void setHarmonicActivePower18Max(Double harmonicActivePower18Max) {
        this.harmonicActivePower18Max = harmonicActivePower18Max;
    }

    /**
     * 获取18次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_18_MIN - 18次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower18Min() {
        return harmonicActivePower18Min;
    }

    /**
     * 设置18次谐波有功功率-最小值
     *
     * @param harmonicActivePower18Min 18次谐波有功功率-最小值
     */
    public void setHarmonicActivePower18Min(Double harmonicActivePower18Min) {
        this.harmonicActivePower18Min = harmonicActivePower18Min;
    }

    /**
     * 获取18次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_18_AVG - 18次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower18Avg() {
        return harmonicActivePower18Avg;
    }

    /**
     * 设置18次谐波有功功率-平均值
     *
     * @param harmonicActivePower18Avg 18次谐波有功功率-平均值
     */
    public void setHarmonicActivePower18Avg(Double harmonicActivePower18Avg) {
        this.harmonicActivePower18Avg = harmonicActivePower18Avg;
    }

    /**
     * 获取18次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_18_95 - 18次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1895() {
        return harmonicActivePower1895;
    }

    /**
     * 设置18次谐波有功功率-95值
     *
     * @param harmonicActivePower1895 18次谐波有功功率-95值
     */
    public void setHarmonicActivePower1895(Double harmonicActivePower1895) {
        this.harmonicActivePower1895 = harmonicActivePower1895;
    }

    /**
     * 获取19次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_19_MAX - 19次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower19Max() {
        return harmonicActivePower19Max;
    }

    /**
     * 设置19次谐波有功功率-最大值
     *
     * @param harmonicActivePower19Max 19次谐波有功功率-最大值
     */
    public void setHarmonicActivePower19Max(Double harmonicActivePower19Max) {
        this.harmonicActivePower19Max = harmonicActivePower19Max;
    }

    /**
     * 获取19次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_19_MIN - 19次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower19Min() {
        return harmonicActivePower19Min;
    }

    /**
     * 设置19次谐波有功功率-最小值
     *
     * @param harmonicActivePower19Min 19次谐波有功功率-最小值
     */
    public void setHarmonicActivePower19Min(Double harmonicActivePower19Min) {
        this.harmonicActivePower19Min = harmonicActivePower19Min;
    }

    /**
     * 获取19次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_19_AVG - 19次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower19Avg() {
        return harmonicActivePower19Avg;
    }

    /**
     * 设置19次谐波有功功率-平均值
     *
     * @param harmonicActivePower19Avg 19次谐波有功功率-平均值
     */
    public void setHarmonicActivePower19Avg(Double harmonicActivePower19Avg) {
        this.harmonicActivePower19Avg = harmonicActivePower19Avg;
    }

    /**
     * 获取19次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_19_95 - 19次谐波有功功率-95值
     */
    public Double getHarmonicActivePower1995() {
        return harmonicActivePower1995;
    }

    /**
     * 设置19次谐波有功功率-95值
     *
     * @param harmonicActivePower1995 19次谐波有功功率-95值
     */
    public void setHarmonicActivePower1995(Double harmonicActivePower1995) {
        this.harmonicActivePower1995 = harmonicActivePower1995;
    }

    /**
     * 获取20次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_20_MAX - 20次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower20Max() {
        return harmonicActivePower20Max;
    }

    /**
     * 设置20次谐波有功功率-最大值
     *
     * @param harmonicActivePower20Max 20次谐波有功功率-最大值
     */
    public void setHarmonicActivePower20Max(Double harmonicActivePower20Max) {
        this.harmonicActivePower20Max = harmonicActivePower20Max;
    }

    /**
     * 获取20次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_20_MIN - 20次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower20Min() {
        return harmonicActivePower20Min;
    }

    /**
     * 设置20次谐波有功功率-最小值
     *
     * @param harmonicActivePower20Min 20次谐波有功功率-最小值
     */
    public void setHarmonicActivePower20Min(Double harmonicActivePower20Min) {
        this.harmonicActivePower20Min = harmonicActivePower20Min;
    }

    /**
     * 获取20次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_20_AVG - 20次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower20Avg() {
        return harmonicActivePower20Avg;
    }

    /**
     * 设置20次谐波有功功率-平均值
     *
     * @param harmonicActivePower20Avg 20次谐波有功功率-平均值
     */
    public void setHarmonicActivePower20Avg(Double harmonicActivePower20Avg) {
        this.harmonicActivePower20Avg = harmonicActivePower20Avg;
    }

    /**
     * 获取20次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_20_95 - 20次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2095() {
        return harmonicActivePower2095;
    }

    /**
     * 设置20次谐波有功功率-95值
     *
     * @param harmonicActivePower2095 20次谐波有功功率-95值
     */
    public void setHarmonicActivePower2095(Double harmonicActivePower2095) {
        this.harmonicActivePower2095 = harmonicActivePower2095;
    }

    /**
     * 获取21次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_21_MAX - 21次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower21Max() {
        return harmonicActivePower21Max;
    }

    /**
     * 设置21次谐波有功功率-最大值
     *
     * @param harmonicActivePower21Max 21次谐波有功功率-最大值
     */
    public void setHarmonicActivePower21Max(Double harmonicActivePower21Max) {
        this.harmonicActivePower21Max = harmonicActivePower21Max;
    }

    /**
     * 获取21次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_21_MIN - 21次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower21Min() {
        return harmonicActivePower21Min;
    }

    /**
     * 设置21次谐波有功功率-最小值
     *
     * @param harmonicActivePower21Min 21次谐波有功功率-最小值
     */
    public void setHarmonicActivePower21Min(Double harmonicActivePower21Min) {
        this.harmonicActivePower21Min = harmonicActivePower21Min;
    }

    /**
     * 获取21次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_21_AVG - 21次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower21Avg() {
        return harmonicActivePower21Avg;
    }

    /**
     * 设置21次谐波有功功率-平均值
     *
     * @param harmonicActivePower21Avg 21次谐波有功功率-平均值
     */
    public void setHarmonicActivePower21Avg(Double harmonicActivePower21Avg) {
        this.harmonicActivePower21Avg = harmonicActivePower21Avg;
    }

    /**
     * 获取21次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_21_95 - 21次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2195() {
        return harmonicActivePower2195;
    }

    /**
     * 设置21次谐波有功功率-95值
     *
     * @param harmonicActivePower2195 21次谐波有功功率-95值
     */
    public void setHarmonicActivePower2195(Double harmonicActivePower2195) {
        this.harmonicActivePower2195 = harmonicActivePower2195;
    }

    /**
     * 获取22次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_22_MAX - 22次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower22Max() {
        return harmonicActivePower22Max;
    }

    /**
     * 设置22次谐波有功功率-最大值
     *
     * @param harmonicActivePower22Max 22次谐波有功功率-最大值
     */
    public void setHarmonicActivePower22Max(Double harmonicActivePower22Max) {
        this.harmonicActivePower22Max = harmonicActivePower22Max;
    }

    /**
     * 获取22次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_22_MIN - 22次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower22Min() {
        return harmonicActivePower22Min;
    }

    /**
     * 设置22次谐波有功功率-最小值
     *
     * @param harmonicActivePower22Min 22次谐波有功功率-最小值
     */
    public void setHarmonicActivePower22Min(Double harmonicActivePower22Min) {
        this.harmonicActivePower22Min = harmonicActivePower22Min;
    }

    /**
     * 获取22次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_22_AVG - 22次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower22Avg() {
        return harmonicActivePower22Avg;
    }

    /**
     * 设置22次谐波有功功率-平均值
     *
     * @param harmonicActivePower22Avg 22次谐波有功功率-平均值
     */
    public void setHarmonicActivePower22Avg(Double harmonicActivePower22Avg) {
        this.harmonicActivePower22Avg = harmonicActivePower22Avg;
    }

    /**
     * 获取22次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_22_95 - 22次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2295() {
        return harmonicActivePower2295;
    }

    /**
     * 设置22次谐波有功功率-95值
     *
     * @param harmonicActivePower2295 22次谐波有功功率-95值
     */
    public void setHarmonicActivePower2295(Double harmonicActivePower2295) {
        this.harmonicActivePower2295 = harmonicActivePower2295;
    }

    /**
     * 获取23次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_23_MAX - 23次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower23Max() {
        return harmonicActivePower23Max;
    }

    /**
     * 设置23次谐波有功功率-最大值
     *
     * @param harmonicActivePower23Max 23次谐波有功功率-最大值
     */
    public void setHarmonicActivePower23Max(Double harmonicActivePower23Max) {
        this.harmonicActivePower23Max = harmonicActivePower23Max;
    }

    /**
     * 获取23次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_23_MIN - 23次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower23Min() {
        return harmonicActivePower23Min;
    }

    /**
     * 设置23次谐波有功功率-最小值
     *
     * @param harmonicActivePower23Min 23次谐波有功功率-最小值
     */
    public void setHarmonicActivePower23Min(Double harmonicActivePower23Min) {
        this.harmonicActivePower23Min = harmonicActivePower23Min;
    }

    /**
     * 获取23次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_23_AVG - 23次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower23Avg() {
        return harmonicActivePower23Avg;
    }

    /**
     * 设置23次谐波有功功率-平均值
     *
     * @param harmonicActivePower23Avg 23次谐波有功功率-平均值
     */
    public void setHarmonicActivePower23Avg(Double harmonicActivePower23Avg) {
        this.harmonicActivePower23Avg = harmonicActivePower23Avg;
    }

    /**
     * 获取23次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_23_95 - 23次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2395() {
        return harmonicActivePower2395;
    }

    /**
     * 设置23次谐波有功功率-95值
     *
     * @param harmonicActivePower2395 23次谐波有功功率-95值
     */
    public void setHarmonicActivePower2395(Double harmonicActivePower2395) {
        this.harmonicActivePower2395 = harmonicActivePower2395;
    }

    /**
     * 获取24次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_24_MAX - 24次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower24Max() {
        return harmonicActivePower24Max;
    }

    /**
     * 设置24次谐波有功功率-最大值
     *
     * @param harmonicActivePower24Max 24次谐波有功功率-最大值
     */
    public void setHarmonicActivePower24Max(Double harmonicActivePower24Max) {
        this.harmonicActivePower24Max = harmonicActivePower24Max;
    }

    /**
     * 获取24次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_24_MIN - 24次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower24Min() {
        return harmonicActivePower24Min;
    }

    /**
     * 设置24次谐波有功功率-最小值
     *
     * @param harmonicActivePower24Min 24次谐波有功功率-最小值
     */
    public void setHarmonicActivePower24Min(Double harmonicActivePower24Min) {
        this.harmonicActivePower24Min = harmonicActivePower24Min;
    }

    /**
     * 获取24次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_24_AVG - 24次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower24Avg() {
        return harmonicActivePower24Avg;
    }

    /**
     * 设置24次谐波有功功率-平均值
     *
     * @param harmonicActivePower24Avg 24次谐波有功功率-平均值
     */
    public void setHarmonicActivePower24Avg(Double harmonicActivePower24Avg) {
        this.harmonicActivePower24Avg = harmonicActivePower24Avg;
    }

    /**
     * 获取24次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_24_95 - 24次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2495() {
        return harmonicActivePower2495;
    }

    /**
     * 设置24次谐波有功功率-95值
     *
     * @param harmonicActivePower2495 24次谐波有功功率-95值
     */
    public void setHarmonicActivePower2495(Double harmonicActivePower2495) {
        this.harmonicActivePower2495 = harmonicActivePower2495;
    }

    /**
     * 获取25次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_25_MAX - 25次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower25Max() {
        return harmonicActivePower25Max;
    }

    /**
     * 设置25次谐波有功功率-最大值
     *
     * @param harmonicActivePower25Max 25次谐波有功功率-最大值
     */
    public void setHarmonicActivePower25Max(Double harmonicActivePower25Max) {
        this.harmonicActivePower25Max = harmonicActivePower25Max;
    }

    /**
     * 获取25次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_25_MIN - 25次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower25Min() {
        return harmonicActivePower25Min;
    }

    /**
     * 设置25次谐波有功功率-最小值
     *
     * @param harmonicActivePower25Min 25次谐波有功功率-最小值
     */
    public void setHarmonicActivePower25Min(Double harmonicActivePower25Min) {
        this.harmonicActivePower25Min = harmonicActivePower25Min;
    }

    /**
     * 获取25次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_25_AVG - 25次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower25Avg() {
        return harmonicActivePower25Avg;
    }

    /**
     * 设置25次谐波有功功率-平均值
     *
     * @param harmonicActivePower25Avg 25次谐波有功功率-平均值
     */
    public void setHarmonicActivePower25Avg(Double harmonicActivePower25Avg) {
        this.harmonicActivePower25Avg = harmonicActivePower25Avg;
    }

    /**
     * 获取25次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_25_95 - 25次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2595() {
        return harmonicActivePower2595;
    }

    /**
     * 设置25次谐波有功功率-95值
     *
     * @param harmonicActivePower2595 25次谐波有功功率-95值
     */
    public void setHarmonicActivePower2595(Double harmonicActivePower2595) {
        this.harmonicActivePower2595 = harmonicActivePower2595;
    }

    /**
     * 获取26次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_26_MAX - 26次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower26Max() {
        return harmonicActivePower26Max;
    }

    /**
     * 设置26次谐波有功功率-最大值
     *
     * @param harmonicActivePower26Max 26次谐波有功功率-最大值
     */
    public void setHarmonicActivePower26Max(Double harmonicActivePower26Max) {
        this.harmonicActivePower26Max = harmonicActivePower26Max;
    }

    /**
     * 获取26次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_26_MIN - 26次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower26Min() {
        return harmonicActivePower26Min;
    }

    /**
     * 设置26次谐波有功功率-最小值
     *
     * @param harmonicActivePower26Min 26次谐波有功功率-最小值
     */
    public void setHarmonicActivePower26Min(Double harmonicActivePower26Min) {
        this.harmonicActivePower26Min = harmonicActivePower26Min;
    }

    /**
     * 获取26次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_26_AVG - 26次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower26Avg() {
        return harmonicActivePower26Avg;
    }

    /**
     * 设置26次谐波有功功率-平均值
     *
     * @param harmonicActivePower26Avg 26次谐波有功功率-平均值
     */
    public void setHarmonicActivePower26Avg(Double harmonicActivePower26Avg) {
        this.harmonicActivePower26Avg = harmonicActivePower26Avg;
    }

    /**
     * 获取26次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_26_95 - 26次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2695() {
        return harmonicActivePower2695;
    }

    /**
     * 设置26次谐波有功功率-95值
     *
     * @param harmonicActivePower2695 26次谐波有功功率-95值
     */
    public void setHarmonicActivePower2695(Double harmonicActivePower2695) {
        this.harmonicActivePower2695 = harmonicActivePower2695;
    }

    /**
     * 获取27次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_27_MAX - 27次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower27Max() {
        return harmonicActivePower27Max;
    }

    /**
     * 设置27次谐波有功功率-最大值
     *
     * @param harmonicActivePower27Max 27次谐波有功功率-最大值
     */
    public void setHarmonicActivePower27Max(Double harmonicActivePower27Max) {
        this.harmonicActivePower27Max = harmonicActivePower27Max;
    }

    /**
     * 获取27次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_27_MIN - 27次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower27Min() {
        return harmonicActivePower27Min;
    }

    /**
     * 设置27次谐波有功功率-最小值
     *
     * @param harmonicActivePower27Min 27次谐波有功功率-最小值
     */
    public void setHarmonicActivePower27Min(Double harmonicActivePower27Min) {
        this.harmonicActivePower27Min = harmonicActivePower27Min;
    }

    /**
     * 获取27次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_27_AVG - 27次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower27Avg() {
        return harmonicActivePower27Avg;
    }

    /**
     * 设置27次谐波有功功率-平均值
     *
     * @param harmonicActivePower27Avg 27次谐波有功功率-平均值
     */
    public void setHarmonicActivePower27Avg(Double harmonicActivePower27Avg) {
        this.harmonicActivePower27Avg = harmonicActivePower27Avg;
    }

    /**
     * 获取27次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_27_95 - 27次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2795() {
        return harmonicActivePower2795;
    }

    /**
     * 设置27次谐波有功功率-95值
     *
     * @param harmonicActivePower2795 27次谐波有功功率-95值
     */
    public void setHarmonicActivePower2795(Double harmonicActivePower2795) {
        this.harmonicActivePower2795 = harmonicActivePower2795;
    }

    /**
     * 获取28次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_28_MAX - 28次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower28Max() {
        return harmonicActivePower28Max;
    }

    /**
     * 设置28次谐波有功功率-最大值
     *
     * @param harmonicActivePower28Max 28次谐波有功功率-最大值
     */
    public void setHarmonicActivePower28Max(Double harmonicActivePower28Max) {
        this.harmonicActivePower28Max = harmonicActivePower28Max;
    }

    /**
     * 获取28次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_28_MIN - 28次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower28Min() {
        return harmonicActivePower28Min;
    }

    /**
     * 设置28次谐波有功功率-最小值
     *
     * @param harmonicActivePower28Min 28次谐波有功功率-最小值
     */
    public void setHarmonicActivePower28Min(Double harmonicActivePower28Min) {
        this.harmonicActivePower28Min = harmonicActivePower28Min;
    }

    /**
     * 获取28次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_28_AVG - 28次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower28Avg() {
        return harmonicActivePower28Avg;
    }

    /**
     * 设置28次谐波有功功率-平均值
     *
     * @param harmonicActivePower28Avg 28次谐波有功功率-平均值
     */
    public void setHarmonicActivePower28Avg(Double harmonicActivePower28Avg) {
        this.harmonicActivePower28Avg = harmonicActivePower28Avg;
    }

    /**
     * 获取28次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_28_95 - 28次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2895() {
        return harmonicActivePower2895;
    }

    /**
     * 设置28次谐波有功功率-95值
     *
     * @param harmonicActivePower2895 28次谐波有功功率-95值
     */
    public void setHarmonicActivePower2895(Double harmonicActivePower2895) {
        this.harmonicActivePower2895 = harmonicActivePower2895;
    }

    /**
     * 获取29次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_29_MAX - 29次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower29Max() {
        return harmonicActivePower29Max;
    }

    /**
     * 设置29次谐波有功功率-最大值
     *
     * @param harmonicActivePower29Max 29次谐波有功功率-最大值
     */
    public void setHarmonicActivePower29Max(Double harmonicActivePower29Max) {
        this.harmonicActivePower29Max = harmonicActivePower29Max;
    }

    /**
     * 获取29次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_29_MIN - 29次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower29Min() {
        return harmonicActivePower29Min;
    }

    /**
     * 设置29次谐波有功功率-最小值
     *
     * @param harmonicActivePower29Min 29次谐波有功功率-最小值
     */
    public void setHarmonicActivePower29Min(Double harmonicActivePower29Min) {
        this.harmonicActivePower29Min = harmonicActivePower29Min;
    }

    /**
     * 获取29次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_29_AVG - 29次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower29Avg() {
        return harmonicActivePower29Avg;
    }

    /**
     * 设置29次谐波有功功率-平均值
     *
     * @param harmonicActivePower29Avg 29次谐波有功功率-平均值
     */
    public void setHarmonicActivePower29Avg(Double harmonicActivePower29Avg) {
        this.harmonicActivePower29Avg = harmonicActivePower29Avg;
    }

    /**
     * 获取29次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_29_95 - 29次谐波有功功率-95值
     */
    public Double getHarmonicActivePower2995() {
        return harmonicActivePower2995;
    }

    /**
     * 设置29次谐波有功功率-95值
     *
     * @param harmonicActivePower2995 29次谐波有功功率-95值
     */
    public void setHarmonicActivePower2995(Double harmonicActivePower2995) {
        this.harmonicActivePower2995 = harmonicActivePower2995;
    }

    /**
     * 获取30次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_30_MAX - 30次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower30Max() {
        return harmonicActivePower30Max;
    }

    /**
     * 设置30次谐波有功功率-最大值
     *
     * @param harmonicActivePower30Max 30次谐波有功功率-最大值
     */
    public void setHarmonicActivePower30Max(Double harmonicActivePower30Max) {
        this.harmonicActivePower30Max = harmonicActivePower30Max;
    }

    /**
     * 获取30次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_30_MIN - 30次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower30Min() {
        return harmonicActivePower30Min;
    }

    /**
     * 设置30次谐波有功功率-最小值
     *
     * @param harmonicActivePower30Min 30次谐波有功功率-最小值
     */
    public void setHarmonicActivePower30Min(Double harmonicActivePower30Min) {
        this.harmonicActivePower30Min = harmonicActivePower30Min;
    }

    /**
     * 获取30次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_30_AVG - 30次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower30Avg() {
        return harmonicActivePower30Avg;
    }

    /**
     * 设置30次谐波有功功率-平均值
     *
     * @param harmonicActivePower30Avg 30次谐波有功功率-平均值
     */
    public void setHarmonicActivePower30Avg(Double harmonicActivePower30Avg) {
        this.harmonicActivePower30Avg = harmonicActivePower30Avg;
    }

    /**
     * 获取30次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_30_95 - 30次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3095() {
        return harmonicActivePower3095;
    }

    /**
     * 设置30次谐波有功功率-95值
     *
     * @param harmonicActivePower3095 30次谐波有功功率-95值
     */
    public void setHarmonicActivePower3095(Double harmonicActivePower3095) {
        this.harmonicActivePower3095 = harmonicActivePower3095;
    }

    /**
     * 获取31次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_31_MAX - 31次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower31Max() {
        return harmonicActivePower31Max;
    }

    /**
     * 设置31次谐波有功功率-最大值
     *
     * @param harmonicActivePower31Max 31次谐波有功功率-最大值
     */
    public void setHarmonicActivePower31Max(Double harmonicActivePower31Max) {
        this.harmonicActivePower31Max = harmonicActivePower31Max;
    }

    /**
     * 获取31次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_31_MIN - 31次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower31Min() {
        return harmonicActivePower31Min;
    }

    /**
     * 设置31次谐波有功功率-最小值
     *
     * @param harmonicActivePower31Min 31次谐波有功功率-最小值
     */
    public void setHarmonicActivePower31Min(Double harmonicActivePower31Min) {
        this.harmonicActivePower31Min = harmonicActivePower31Min;
    }

    /**
     * 获取31次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_31_AVG - 31次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower31Avg() {
        return harmonicActivePower31Avg;
    }

    /**
     * 设置31次谐波有功功率-平均值
     *
     * @param harmonicActivePower31Avg 31次谐波有功功率-平均值
     */
    public void setHarmonicActivePower31Avg(Double harmonicActivePower31Avg) {
        this.harmonicActivePower31Avg = harmonicActivePower31Avg;
    }

    /**
     * 获取31次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_31_95 - 31次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3195() {
        return harmonicActivePower3195;
    }

    /**
     * 设置31次谐波有功功率-95值
     *
     * @param harmonicActivePower3195 31次谐波有功功率-95值
     */
    public void setHarmonicActivePower3195(Double harmonicActivePower3195) {
        this.harmonicActivePower3195 = harmonicActivePower3195;
    }

    /**
     * 获取32次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_32_MAX - 32次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower32Max() {
        return harmonicActivePower32Max;
    }

    /**
     * 设置32次谐波有功功率-最大值
     *
     * @param harmonicActivePower32Max 32次谐波有功功率-最大值
     */
    public void setHarmonicActivePower32Max(Double harmonicActivePower32Max) {
        this.harmonicActivePower32Max = harmonicActivePower32Max;
    }

    /**
     * 获取32次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_32_MIN - 32次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower32Min() {
        return harmonicActivePower32Min;
    }

    /**
     * 设置32次谐波有功功率-最小值
     *
     * @param harmonicActivePower32Min 32次谐波有功功率-最小值
     */
    public void setHarmonicActivePower32Min(Double harmonicActivePower32Min) {
        this.harmonicActivePower32Min = harmonicActivePower32Min;
    }

    /**
     * 获取32次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_32_AVG - 32次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower32Avg() {
        return harmonicActivePower32Avg;
    }

    /**
     * 设置32次谐波有功功率-平均值
     *
     * @param harmonicActivePower32Avg 32次谐波有功功率-平均值
     */
    public void setHarmonicActivePower32Avg(Double harmonicActivePower32Avg) {
        this.harmonicActivePower32Avg = harmonicActivePower32Avg;
    }

    /**
     * 获取32次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_32_95 - 32次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3295() {
        return harmonicActivePower3295;
    }

    /**
     * 设置32次谐波有功功率-95值
     *
     * @param harmonicActivePower3295 32次谐波有功功率-95值
     */
    public void setHarmonicActivePower3295(Double harmonicActivePower3295) {
        this.harmonicActivePower3295 = harmonicActivePower3295;
    }

    /**
     * 获取33次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_33_MAX - 33次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower33Max() {
        return harmonicActivePower33Max;
    }

    /**
     * 设置33次谐波有功功率-最大值
     *
     * @param harmonicActivePower33Max 33次谐波有功功率-最大值
     */
    public void setHarmonicActivePower33Max(Double harmonicActivePower33Max) {
        this.harmonicActivePower33Max = harmonicActivePower33Max;
    }

    /**
     * 获取33次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_33_MIN - 33次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower33Min() {
        return harmonicActivePower33Min;
    }

    /**
     * 设置33次谐波有功功率-最小值
     *
     * @param harmonicActivePower33Min 33次谐波有功功率-最小值
     */
    public void setHarmonicActivePower33Min(Double harmonicActivePower33Min) {
        this.harmonicActivePower33Min = harmonicActivePower33Min;
    }

    /**
     * 获取33次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_33_AVG - 33次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower33Avg() {
        return harmonicActivePower33Avg;
    }

    /**
     * 设置33次谐波有功功率-平均值
     *
     * @param harmonicActivePower33Avg 33次谐波有功功率-平均值
     */
    public void setHarmonicActivePower33Avg(Double harmonicActivePower33Avg) {
        this.harmonicActivePower33Avg = harmonicActivePower33Avg;
    }

    /**
     * 获取33次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_33_95 - 33次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3395() {
        return harmonicActivePower3395;
    }

    /**
     * 设置33次谐波有功功率-95值
     *
     * @param harmonicActivePower3395 33次谐波有功功率-95值
     */
    public void setHarmonicActivePower3395(Double harmonicActivePower3395) {
        this.harmonicActivePower3395 = harmonicActivePower3395;
    }

    /**
     * 获取34次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_34_MAX - 34次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower34Max() {
        return harmonicActivePower34Max;
    }

    /**
     * 设置34次谐波有功功率-最大值
     *
     * @param harmonicActivePower34Max 34次谐波有功功率-最大值
     */
    public void setHarmonicActivePower34Max(Double harmonicActivePower34Max) {
        this.harmonicActivePower34Max = harmonicActivePower34Max;
    }

    /**
     * 获取34次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_34_MIN - 34次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower34Min() {
        return harmonicActivePower34Min;
    }

    /**
     * 设置34次谐波有功功率-最小值
     *
     * @param harmonicActivePower34Min 34次谐波有功功率-最小值
     */
    public void setHarmonicActivePower34Min(Double harmonicActivePower34Min) {
        this.harmonicActivePower34Min = harmonicActivePower34Min;
    }

    /**
     * 获取34次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_34_AVG - 34次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower34Avg() {
        return harmonicActivePower34Avg;
    }

    /**
     * 设置34次谐波有功功率-平均值
     *
     * @param harmonicActivePower34Avg 34次谐波有功功率-平均值
     */
    public void setHarmonicActivePower34Avg(Double harmonicActivePower34Avg) {
        this.harmonicActivePower34Avg = harmonicActivePower34Avg;
    }

    /**
     * 获取34次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_34_95 - 34次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3495() {
        return harmonicActivePower3495;
    }

    /**
     * 设置34次谐波有功功率-95值
     *
     * @param harmonicActivePower3495 34次谐波有功功率-95值
     */
    public void setHarmonicActivePower3495(Double harmonicActivePower3495) {
        this.harmonicActivePower3495 = harmonicActivePower3495;
    }

    /**
     * 获取35次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_35_MAX - 35次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower35Max() {
        return harmonicActivePower35Max;
    }

    /**
     * 设置35次谐波有功功率-最大值
     *
     * @param harmonicActivePower35Max 35次谐波有功功率-最大值
     */
    public void setHarmonicActivePower35Max(Double harmonicActivePower35Max) {
        this.harmonicActivePower35Max = harmonicActivePower35Max;
    }

    /**
     * 获取35次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_35_MIN - 35次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower35Min() {
        return harmonicActivePower35Min;
    }

    /**
     * 设置35次谐波有功功率-最小值
     *
     * @param harmonicActivePower35Min 35次谐波有功功率-最小值
     */
    public void setHarmonicActivePower35Min(Double harmonicActivePower35Min) {
        this.harmonicActivePower35Min = harmonicActivePower35Min;
    }

    /**
     * 获取35次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_35_AVG - 35次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower35Avg() {
        return harmonicActivePower35Avg;
    }

    /**
     * 设置35次谐波有功功率-平均值
     *
     * @param harmonicActivePower35Avg 35次谐波有功功率-平均值
     */
    public void setHarmonicActivePower35Avg(Double harmonicActivePower35Avg) {
        this.harmonicActivePower35Avg = harmonicActivePower35Avg;
    }

    /**
     * 获取35次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_35_95 - 35次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3595() {
        return harmonicActivePower3595;
    }

    /**
     * 设置35次谐波有功功率-95值
     *
     * @param harmonicActivePower3595 35次谐波有功功率-95值
     */
    public void setHarmonicActivePower3595(Double harmonicActivePower3595) {
        this.harmonicActivePower3595 = harmonicActivePower3595;
    }

    /**
     * 获取36次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_36_MAX - 36次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower36Max() {
        return harmonicActivePower36Max;
    }

    /**
     * 设置36次谐波有功功率-最大值
     *
     * @param harmonicActivePower36Max 36次谐波有功功率-最大值
     */
    public void setHarmonicActivePower36Max(Double harmonicActivePower36Max) {
        this.harmonicActivePower36Max = harmonicActivePower36Max;
    }

    /**
     * 获取36次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_36_MIN - 36次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower36Min() {
        return harmonicActivePower36Min;
    }

    /**
     * 设置36次谐波有功功率-最小值
     *
     * @param harmonicActivePower36Min 36次谐波有功功率-最小值
     */
    public void setHarmonicActivePower36Min(Double harmonicActivePower36Min) {
        this.harmonicActivePower36Min = harmonicActivePower36Min;
    }

    /**
     * 获取36次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_36_AVG - 36次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower36Avg() {
        return harmonicActivePower36Avg;
    }

    /**
     * 设置36次谐波有功功率-平均值
     *
     * @param harmonicActivePower36Avg 36次谐波有功功率-平均值
     */
    public void setHarmonicActivePower36Avg(Double harmonicActivePower36Avg) {
        this.harmonicActivePower36Avg = harmonicActivePower36Avg;
    }

    /**
     * 获取36次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_36_95 - 36次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3695() {
        return harmonicActivePower3695;
    }

    /**
     * 设置36次谐波有功功率-95值
     *
     * @param harmonicActivePower3695 36次谐波有功功率-95值
     */
    public void setHarmonicActivePower3695(Double harmonicActivePower3695) {
        this.harmonicActivePower3695 = harmonicActivePower3695;
    }

    /**
     * 获取37次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_37_MAX - 37次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower37Max() {
        return harmonicActivePower37Max;
    }

    /**
     * 设置37次谐波有功功率-最大值
     *
     * @param harmonicActivePower37Max 37次谐波有功功率-最大值
     */
    public void setHarmonicActivePower37Max(Double harmonicActivePower37Max) {
        this.harmonicActivePower37Max = harmonicActivePower37Max;
    }

    /**
     * 获取37次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_37_MIN - 37次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower37Min() {
        return harmonicActivePower37Min;
    }

    /**
     * 设置37次谐波有功功率-最小值
     *
     * @param harmonicActivePower37Min 37次谐波有功功率-最小值
     */
    public void setHarmonicActivePower37Min(Double harmonicActivePower37Min) {
        this.harmonicActivePower37Min = harmonicActivePower37Min;
    }

    /**
     * 获取37次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_37_AVG - 37次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower37Avg() {
        return harmonicActivePower37Avg;
    }

    /**
     * 设置37次谐波有功功率-平均值
     *
     * @param harmonicActivePower37Avg 37次谐波有功功率-平均值
     */
    public void setHarmonicActivePower37Avg(Double harmonicActivePower37Avg) {
        this.harmonicActivePower37Avg = harmonicActivePower37Avg;
    }

    /**
     * 获取37次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_37_95 - 37次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3795() {
        return harmonicActivePower3795;
    }

    /**
     * 设置37次谐波有功功率-95值
     *
     * @param harmonicActivePower3795 37次谐波有功功率-95值
     */
    public void setHarmonicActivePower3795(Double harmonicActivePower3795) {
        this.harmonicActivePower3795 = harmonicActivePower3795;
    }

    /**
     * 获取38次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_38_MAX - 38次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower38Max() {
        return harmonicActivePower38Max;
    }

    /**
     * 设置38次谐波有功功率-最大值
     *
     * @param harmonicActivePower38Max 38次谐波有功功率-最大值
     */
    public void setHarmonicActivePower38Max(Double harmonicActivePower38Max) {
        this.harmonicActivePower38Max = harmonicActivePower38Max;
    }

    /**
     * 获取38次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_38_MIN - 38次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower38Min() {
        return harmonicActivePower38Min;
    }

    /**
     * 设置38次谐波有功功率-最小值
     *
     * @param harmonicActivePower38Min 38次谐波有功功率-最小值
     */
    public void setHarmonicActivePower38Min(Double harmonicActivePower38Min) {
        this.harmonicActivePower38Min = harmonicActivePower38Min;
    }

    /**
     * 获取38次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_38_AVG - 38次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower38Avg() {
        return harmonicActivePower38Avg;
    }

    /**
     * 设置38次谐波有功功率-平均值
     *
     * @param harmonicActivePower38Avg 38次谐波有功功率-平均值
     */
    public void setHarmonicActivePower38Avg(Double harmonicActivePower38Avg) {
        this.harmonicActivePower38Avg = harmonicActivePower38Avg;
    }

    /**
     * 获取38次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_38_95 - 38次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3895() {
        return harmonicActivePower3895;
    }

    /**
     * 设置38次谐波有功功率-95值
     *
     * @param harmonicActivePower3895 38次谐波有功功率-95值
     */
    public void setHarmonicActivePower3895(Double harmonicActivePower3895) {
        this.harmonicActivePower3895 = harmonicActivePower3895;
    }

    /**
     * 获取39次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_39_MAX - 39次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower39Max() {
        return harmonicActivePower39Max;
    }

    /**
     * 设置39次谐波有功功率-最大值
     *
     * @param harmonicActivePower39Max 39次谐波有功功率-最大值
     */
    public void setHarmonicActivePower39Max(Double harmonicActivePower39Max) {
        this.harmonicActivePower39Max = harmonicActivePower39Max;
    }

    /**
     * 获取39次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_39_MIN - 39次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower39Min() {
        return harmonicActivePower39Min;
    }

    /**
     * 设置39次谐波有功功率-最小值
     *
     * @param harmonicActivePower39Min 39次谐波有功功率-最小值
     */
    public void setHarmonicActivePower39Min(Double harmonicActivePower39Min) {
        this.harmonicActivePower39Min = harmonicActivePower39Min;
    }

    /**
     * 获取39次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_39_AVG - 39次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower39Avg() {
        return harmonicActivePower39Avg;
    }

    /**
     * 设置39次谐波有功功率-平均值
     *
     * @param harmonicActivePower39Avg 39次谐波有功功率-平均值
     */
    public void setHarmonicActivePower39Avg(Double harmonicActivePower39Avg) {
        this.harmonicActivePower39Avg = harmonicActivePower39Avg;
    }

    /**
     * 获取39次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_39_95 - 39次谐波有功功率-95值
     */
    public Double getHarmonicActivePower3995() {
        return harmonicActivePower3995;
    }

    /**
     * 设置39次谐波有功功率-95值
     *
     * @param harmonicActivePower3995 39次谐波有功功率-95值
     */
    public void setHarmonicActivePower3995(Double harmonicActivePower3995) {
        this.harmonicActivePower3995 = harmonicActivePower3995;
    }

    /**
     * 获取40次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_40_MAX - 40次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower40Max() {
        return harmonicActivePower40Max;
    }

    /**
     * 设置40次谐波有功功率-最大值
     *
     * @param harmonicActivePower40Max 40次谐波有功功率-最大值
     */
    public void setHarmonicActivePower40Max(Double harmonicActivePower40Max) {
        this.harmonicActivePower40Max = harmonicActivePower40Max;
    }

    /**
     * 获取40次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_40_MIN - 40次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower40Min() {
        return harmonicActivePower40Min;
    }

    /**
     * 设置40次谐波有功功率-最小值
     *
     * @param harmonicActivePower40Min 40次谐波有功功率-最小值
     */
    public void setHarmonicActivePower40Min(Double harmonicActivePower40Min) {
        this.harmonicActivePower40Min = harmonicActivePower40Min;
    }

    /**
     * 获取40次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_40_AVG - 40次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower40Avg() {
        return harmonicActivePower40Avg;
    }

    /**
     * 设置40次谐波有功功率-平均值
     *
     * @param harmonicActivePower40Avg 40次谐波有功功率-平均值
     */
    public void setHarmonicActivePower40Avg(Double harmonicActivePower40Avg) {
        this.harmonicActivePower40Avg = harmonicActivePower40Avg;
    }

    /**
     * 获取40次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_40_95 - 40次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4095() {
        return harmonicActivePower4095;
    }

    /**
     * 设置40次谐波有功功率-95值
     *
     * @param harmonicActivePower4095 40次谐波有功功率-95值
     */
    public void setHarmonicActivePower4095(Double harmonicActivePower4095) {
        this.harmonicActivePower4095 = harmonicActivePower4095;
    }

    /**
     * 获取41次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_41_MAX - 41次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower41Max() {
        return harmonicActivePower41Max;
    }

    /**
     * 设置41次谐波有功功率-最大值
     *
     * @param harmonicActivePower41Max 41次谐波有功功率-最大值
     */
    public void setHarmonicActivePower41Max(Double harmonicActivePower41Max) {
        this.harmonicActivePower41Max = harmonicActivePower41Max;
    }

    /**
     * 获取41次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_41_MIN - 41次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower41Min() {
        return harmonicActivePower41Min;
    }

    /**
     * 设置41次谐波有功功率-最小值
     *
     * @param harmonicActivePower41Min 41次谐波有功功率-最小值
     */
    public void setHarmonicActivePower41Min(Double harmonicActivePower41Min) {
        this.harmonicActivePower41Min = harmonicActivePower41Min;
    }

    /**
     * 获取41次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_41_AVG - 41次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower41Avg() {
        return harmonicActivePower41Avg;
    }

    /**
     * 设置41次谐波有功功率-平均值
     *
     * @param harmonicActivePower41Avg 41次谐波有功功率-平均值
     */
    public void setHarmonicActivePower41Avg(Double harmonicActivePower41Avg) {
        this.harmonicActivePower41Avg = harmonicActivePower41Avg;
    }

    /**
     * 获取41次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_41_95 - 41次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4195() {
        return harmonicActivePower4195;
    }

    /**
     * 设置41次谐波有功功率-95值
     *
     * @param harmonicActivePower4195 41次谐波有功功率-95值
     */
    public void setHarmonicActivePower4195(Double harmonicActivePower4195) {
        this.harmonicActivePower4195 = harmonicActivePower4195;
    }

    /**
     * 获取42次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_42_MAX - 42次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower42Max() {
        return harmonicActivePower42Max;
    }

    /**
     * 设置42次谐波有功功率-最大值
     *
     * @param harmonicActivePower42Max 42次谐波有功功率-最大值
     */
    public void setHarmonicActivePower42Max(Double harmonicActivePower42Max) {
        this.harmonicActivePower42Max = harmonicActivePower42Max;
    }

    /**
     * 获取42次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_42_MIN - 42次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower42Min() {
        return harmonicActivePower42Min;
    }

    /**
     * 设置42次谐波有功功率-最小值
     *
     * @param harmonicActivePower42Min 42次谐波有功功率-最小值
     */
    public void setHarmonicActivePower42Min(Double harmonicActivePower42Min) {
        this.harmonicActivePower42Min = harmonicActivePower42Min;
    }

    /**
     * 获取42次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_42_AVG - 42次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower42Avg() {
        return harmonicActivePower42Avg;
    }

    /**
     * 设置42次谐波有功功率-平均值
     *
     * @param harmonicActivePower42Avg 42次谐波有功功率-平均值
     */
    public void setHarmonicActivePower42Avg(Double harmonicActivePower42Avg) {
        this.harmonicActivePower42Avg = harmonicActivePower42Avg;
    }

    /**
     * 获取42次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_42_95 - 42次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4295() {
        return harmonicActivePower4295;
    }

    /**
     * 设置42次谐波有功功率-95值
     *
     * @param harmonicActivePower4295 42次谐波有功功率-95值
     */
    public void setHarmonicActivePower4295(Double harmonicActivePower4295) {
        this.harmonicActivePower4295 = harmonicActivePower4295;
    }

    /**
     * 获取43次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_43_MAX - 43次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower43Max() {
        return harmonicActivePower43Max;
    }

    /**
     * 设置43次谐波有功功率-最大值
     *
     * @param harmonicActivePower43Max 43次谐波有功功率-最大值
     */
    public void setHarmonicActivePower43Max(Double harmonicActivePower43Max) {
        this.harmonicActivePower43Max = harmonicActivePower43Max;
    }

    /**
     * 获取43次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_43_MIN - 43次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower43Min() {
        return harmonicActivePower43Min;
    }

    /**
     * 设置43次谐波有功功率-最小值
     *
     * @param harmonicActivePower43Min 43次谐波有功功率-最小值
     */
    public void setHarmonicActivePower43Min(Double harmonicActivePower43Min) {
        this.harmonicActivePower43Min = harmonicActivePower43Min;
    }

    /**
     * 获取43次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_43_AVG - 43次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower43Avg() {
        return harmonicActivePower43Avg;
    }

    /**
     * 设置43次谐波有功功率-平均值
     *
     * @param harmonicActivePower43Avg 43次谐波有功功率-平均值
     */
    public void setHarmonicActivePower43Avg(Double harmonicActivePower43Avg) {
        this.harmonicActivePower43Avg = harmonicActivePower43Avg;
    }

    /**
     * 获取43次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_43_95 - 43次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4395() {
        return harmonicActivePower4395;
    }

    /**
     * 设置43次谐波有功功率-95值
     *
     * @param harmonicActivePower4395 43次谐波有功功率-95值
     */
    public void setHarmonicActivePower4395(Double harmonicActivePower4395) {
        this.harmonicActivePower4395 = harmonicActivePower4395;
    }

    /**
     * 获取44次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_44_MAX - 44次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower44Max() {
        return harmonicActivePower44Max;
    }

    /**
     * 设置44次谐波有功功率-最大值
     *
     * @param harmonicActivePower44Max 44次谐波有功功率-最大值
     */
    public void setHarmonicActivePower44Max(Double harmonicActivePower44Max) {
        this.harmonicActivePower44Max = harmonicActivePower44Max;
    }

    /**
     * 获取44次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_44_MIN - 44次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower44Min() {
        return harmonicActivePower44Min;
    }

    /**
     * 设置44次谐波有功功率-最小值
     *
     * @param harmonicActivePower44Min 44次谐波有功功率-最小值
     */
    public void setHarmonicActivePower44Min(Double harmonicActivePower44Min) {
        this.harmonicActivePower44Min = harmonicActivePower44Min;
    }

    /**
     * 获取44次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_44_AVG - 44次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower44Avg() {
        return harmonicActivePower44Avg;
    }

    /**
     * 设置44次谐波有功功率-平均值
     *
     * @param harmonicActivePower44Avg 44次谐波有功功率-平均值
     */
    public void setHarmonicActivePower44Avg(Double harmonicActivePower44Avg) {
        this.harmonicActivePower44Avg = harmonicActivePower44Avg;
    }

    /**
     * 获取44次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_44_95 - 44次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4495() {
        return harmonicActivePower4495;
    }

    /**
     * 设置44次谐波有功功率-95值
     *
     * @param harmonicActivePower4495 44次谐波有功功率-95值
     */
    public void setHarmonicActivePower4495(Double harmonicActivePower4495) {
        this.harmonicActivePower4495 = harmonicActivePower4495;
    }

    /**
     * 获取45次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_45_MAX - 45次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower45Max() {
        return harmonicActivePower45Max;
    }

    /**
     * 设置45次谐波有功功率-最大值
     *
     * @param harmonicActivePower45Max 45次谐波有功功率-最大值
     */
    public void setHarmonicActivePower45Max(Double harmonicActivePower45Max) {
        this.harmonicActivePower45Max = harmonicActivePower45Max;
    }

    /**
     * 获取45次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_45_MIN - 45次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower45Min() {
        return harmonicActivePower45Min;
    }

    /**
     * 设置45次谐波有功功率-最小值
     *
     * @param harmonicActivePower45Min 45次谐波有功功率-最小值
     */
    public void setHarmonicActivePower45Min(Double harmonicActivePower45Min) {
        this.harmonicActivePower45Min = harmonicActivePower45Min;
    }

    /**
     * 获取45次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_45_AVG - 45次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower45Avg() {
        return harmonicActivePower45Avg;
    }

    /**
     * 设置45次谐波有功功率-平均值
     *
     * @param harmonicActivePower45Avg 45次谐波有功功率-平均值
     */
    public void setHarmonicActivePower45Avg(Double harmonicActivePower45Avg) {
        this.harmonicActivePower45Avg = harmonicActivePower45Avg;
    }

    /**
     * 获取45次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_45_95 - 45次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4595() {
        return harmonicActivePower4595;
    }

    /**
     * 设置45次谐波有功功率-95值
     *
     * @param harmonicActivePower4595 45次谐波有功功率-95值
     */
    public void setHarmonicActivePower4595(Double harmonicActivePower4595) {
        this.harmonicActivePower4595 = harmonicActivePower4595;
    }

    /**
     * 获取46次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_46_MAX - 46次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower46Max() {
        return harmonicActivePower46Max;
    }

    /**
     * 设置46次谐波有功功率-最大值
     *
     * @param harmonicActivePower46Max 46次谐波有功功率-最大值
     */
    public void setHarmonicActivePower46Max(Double harmonicActivePower46Max) {
        this.harmonicActivePower46Max = harmonicActivePower46Max;
    }

    /**
     * 获取46次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_46_MIN - 46次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower46Min() {
        return harmonicActivePower46Min;
    }

    /**
     * 设置46次谐波有功功率-最小值
     *
     * @param harmonicActivePower46Min 46次谐波有功功率-最小值
     */
    public void setHarmonicActivePower46Min(Double harmonicActivePower46Min) {
        this.harmonicActivePower46Min = harmonicActivePower46Min;
    }

    /**
     * 获取46次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_46_AVG - 46次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower46Avg() {
        return harmonicActivePower46Avg;
    }

    /**
     * 设置46次谐波有功功率-平均值
     *
     * @param harmonicActivePower46Avg 46次谐波有功功率-平均值
     */
    public void setHarmonicActivePower46Avg(Double harmonicActivePower46Avg) {
        this.harmonicActivePower46Avg = harmonicActivePower46Avg;
    }

    /**
     * 获取46次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_46_95 - 46次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4695() {
        return harmonicActivePower4695;
    }

    /**
     * 设置46次谐波有功功率-95值
     *
     * @param harmonicActivePower4695 46次谐波有功功率-95值
     */
    public void setHarmonicActivePower4695(Double harmonicActivePower4695) {
        this.harmonicActivePower4695 = harmonicActivePower4695;
    }

    /**
     * 获取47次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_47_MAX - 47次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower47Max() {
        return harmonicActivePower47Max;
    }

    /**
     * 设置47次谐波有功功率-最大值
     *
     * @param harmonicActivePower47Max 47次谐波有功功率-最大值
     */
    public void setHarmonicActivePower47Max(Double harmonicActivePower47Max) {
        this.harmonicActivePower47Max = harmonicActivePower47Max;
    }

    /**
     * 获取47次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_47_MIN - 47次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower47Min() {
        return harmonicActivePower47Min;
    }

    /**
     * 设置47次谐波有功功率-最小值
     *
     * @param harmonicActivePower47Min 47次谐波有功功率-最小值
     */
    public void setHarmonicActivePower47Min(Double harmonicActivePower47Min) {
        this.harmonicActivePower47Min = harmonicActivePower47Min;
    }

    /**
     * 获取47次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_47_AVG - 47次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower47Avg() {
        return harmonicActivePower47Avg;
    }

    /**
     * 设置47次谐波有功功率-平均值
     *
     * @param harmonicActivePower47Avg 47次谐波有功功率-平均值
     */
    public void setHarmonicActivePower47Avg(Double harmonicActivePower47Avg) {
        this.harmonicActivePower47Avg = harmonicActivePower47Avg;
    }

    /**
     * 获取47次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_47_95 - 47次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4795() {
        return harmonicActivePower4795;
    }

    /**
     * 设置47次谐波有功功率-95值
     *
     * @param harmonicActivePower4795 47次谐波有功功率-95值
     */
    public void setHarmonicActivePower4795(Double harmonicActivePower4795) {
        this.harmonicActivePower4795 = harmonicActivePower4795;
    }

    /**
     * 获取48次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_48_MAX - 48次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower48Max() {
        return harmonicActivePower48Max;
    }

    /**
     * 设置48次谐波有功功率-最大值
     *
     * @param harmonicActivePower48Max 48次谐波有功功率-最大值
     */
    public void setHarmonicActivePower48Max(Double harmonicActivePower48Max) {
        this.harmonicActivePower48Max = harmonicActivePower48Max;
    }

    /**
     * 获取48次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_48_MIN - 48次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower48Min() {
        return harmonicActivePower48Min;
    }

    /**
     * 设置48次谐波有功功率-最小值
     *
     * @param harmonicActivePower48Min 48次谐波有功功率-最小值
     */
    public void setHarmonicActivePower48Min(Double harmonicActivePower48Min) {
        this.harmonicActivePower48Min = harmonicActivePower48Min;
    }

    /**
     * 获取48次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_48_AVG - 48次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower48Avg() {
        return harmonicActivePower48Avg;
    }

    /**
     * 设置48次谐波有功功率-平均值
     *
     * @param harmonicActivePower48Avg 48次谐波有功功率-平均值
     */
    public void setHarmonicActivePower48Avg(Double harmonicActivePower48Avg) {
        this.harmonicActivePower48Avg = harmonicActivePower48Avg;
    }

    /**
     * 获取48次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_48_95 - 48次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4895() {
        return harmonicActivePower4895;
    }

    /**
     * 设置48次谐波有功功率-95值
     *
     * @param harmonicActivePower4895 48次谐波有功功率-95值
     */
    public void setHarmonicActivePower4895(Double harmonicActivePower4895) {
        this.harmonicActivePower4895 = harmonicActivePower4895;
    }

    /**
     * 获取49次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_49_MAX - 49次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower49Max() {
        return harmonicActivePower49Max;
    }

    /**
     * 设置49次谐波有功功率-最大值
     *
     * @param harmonicActivePower49Max 49次谐波有功功率-最大值
     */
    public void setHarmonicActivePower49Max(Double harmonicActivePower49Max) {
        this.harmonicActivePower49Max = harmonicActivePower49Max;
    }

    /**
     * 获取49次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_49_MIN - 49次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower49Min() {
        return harmonicActivePower49Min;
    }

    /**
     * 设置49次谐波有功功率-最小值
     *
     * @param harmonicActivePower49Min 49次谐波有功功率-最小值
     */
    public void setHarmonicActivePower49Min(Double harmonicActivePower49Min) {
        this.harmonicActivePower49Min = harmonicActivePower49Min;
    }

    /**
     * 获取49次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_49_AVG - 49次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower49Avg() {
        return harmonicActivePower49Avg;
    }

    /**
     * 设置49次谐波有功功率-平均值
     *
     * @param harmonicActivePower49Avg 49次谐波有功功率-平均值
     */
    public void setHarmonicActivePower49Avg(Double harmonicActivePower49Avg) {
        this.harmonicActivePower49Avg = harmonicActivePower49Avg;
    }

    /**
     * 获取49次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_49_95 - 49次谐波有功功率-95值
     */
    public Double getHarmonicActivePower4995() {
        return harmonicActivePower4995;
    }

    /**
     * 设置49次谐波有功功率-95值
     *
     * @param harmonicActivePower4995 49次谐波有功功率-95值
     */
    public void setHarmonicActivePower4995(Double harmonicActivePower4995) {
        this.harmonicActivePower4995 = harmonicActivePower4995;
    }

    /**
     * 获取50次谐波有功功率-最大值
     *
     * @return HARMONIC_ACTIVE_POWER_50_MAX - 50次谐波有功功率-最大值
     */
    public Double getHarmonicActivePower50Max() {
        return harmonicActivePower50Max;
    }

    /**
     * 设置50次谐波有功功率-最大值
     *
     * @param harmonicActivePower50Max 50次谐波有功功率-最大值
     */
    public void setHarmonicActivePower50Max(Double harmonicActivePower50Max) {
        this.harmonicActivePower50Max = harmonicActivePower50Max;
    }

    /**
     * 获取50次谐波有功功率-最小值
     *
     * @return HARMONIC_ACTIVE_POWER_50_MIN - 50次谐波有功功率-最小值
     */
    public Double getHarmonicActivePower50Min() {
        return harmonicActivePower50Min;
    }

    /**
     * 设置50次谐波有功功率-最小值
     *
     * @param harmonicActivePower50Min 50次谐波有功功率-最小值
     */
    public void setHarmonicActivePower50Min(Double harmonicActivePower50Min) {
        this.harmonicActivePower50Min = harmonicActivePower50Min;
    }

    /**
     * 获取50次谐波有功功率-平均值
     *
     * @return HARMONIC_ACTIVE_POWER_50_AVG - 50次谐波有功功率-平均值
     */
    public Double getHarmonicActivePower50Avg() {
        return harmonicActivePower50Avg;
    }

    /**
     * 设置50次谐波有功功率-平均值
     *
     * @param harmonicActivePower50Avg 50次谐波有功功率-平均值
     */
    public void setHarmonicActivePower50Avg(Double harmonicActivePower50Avg) {
        this.harmonicActivePower50Avg = harmonicActivePower50Avg;
    }

    /**
     * 获取50次谐波有功功率-95值
     *
     * @return HARMONIC_ACTIVE_POWER_50_95 - 50次谐波有功功率-95值
     */
    public Double getHarmonicActivePower5095() {
        return harmonicActivePower5095;
    }

    /**
     * 设置50次谐波有功功率-95值
     *
     * @param harmonicActivePower5095 50次谐波有功功率-95值
     */
    public void setHarmonicActivePower5095(Double harmonicActivePower5095) {
        this.harmonicActivePower5095 = harmonicActivePower5095;
    }
}