package com.pqs9000.pojo.responsibility;

/**
 * @author xuyang
 * @date 2020/10/30 14:34
 */

public class OverLimitMonitor {

    //省公司
    private String provinceCompany;

    //地市公司
    private String cityCompany;

    //监测点id
    private int monitorId;

    //监测点名称
    private String monitorName;

    //监测点对象类型
    private String monitorType;

    //电网侧变电站名称
    private String powerSubstationName;

    //监测点对象名称
    private String objName;

    //监测点电压等级
    private String monitorVoltageLevel;

    //变电站名称
    private String plantName;

    //变电站电压等级
    private String plantVolageLevel;

    //短路容量
    private Float dlcMp;

    //设备容量
    private Float devcMp;

    //协议容量
    private Float xycMp;

    //超标天数
    private int overLimitDay;

    //电压偏差超标天数
    private int overVoltageDeviationDay;
    //电压偏差最大幅值
    private double maxVoltageDeviationData;
    //电压偏差限值
    private double limitVoltageDeviationData;
    //电压偏差最大幅值和电压偏差限值的差值
    private double diffVoltageDeviationData;

    //谐波电流超标天数
    private int overHarmonicCurrentDay;
    //谐波电流最大幅值
    private double maxHarmonicCurrentData;
    //谐波电流限值
    private double limitHarmonicCurrentData;
    //谐波电流最大幅值与限值的差值
    private double diffHarmonicCurrentData;

    //谐波电压超标天数
    private int overLimitHarmVDay;
    //谐波电压最大幅值
    private double maxLimitHarmVData;
    //谐波电压限值
    private double limitHarmVData;
    //谐波电压最大幅值与限值的差值
    private double diffHarmVData;

    //电压总谐波畸变率超标天数
    private int overVoltageDistortionDay;
    //电压总谐波畸变率最大幅值
    private double maxVoltageDistortionData;
    //电压总谐波畸变率限值
    private double limitVoltageDistortionData;
    //电压总谐波畸变率最大幅值与限值的差值
    private double diffVoltageDistortionData;

    //谐波电压含有率超标天数
    private int overHarmonicVoltageDay;
    //谐波电压含有率最大幅值
    private double maxHarmonicVoltageData;
    //谐波电压含有率限值
    private double limitHarmonicVoltageData;
    //谐波电压含有率最大幅值与限值的差值
    private double diffHarmonicVoltageData;

    //频率偏差超标天数
    private int overFrequencyDeviationDay;
    //频率偏差最大幅值
    private double maxFrequencyDeviationData;
    //频率偏差限值
    private double limitFrequencyDeviationData;
    //频率偏差最大幅值与限值的差值
    private double diffFrequencyDeviationData;

    //间谐波电压含有率超标天数
    private int overInterharmonicsDay;
    //间谐波电压含有率最大幅值
    private double maxInterharmonicsData;
    //间谐波电压含有率限值
    private double limitInterharmonicsData;
    //间谐波电压含有率最大幅值和限值的差值s
    private double diffInterharmonicsData;

    //三相电压不平衡度超标天数
    private int overThreeVoltageUnbalanceDay;
    //三相电压不平衡度最大幅值
    private double maxThreeVoltageUnbalanceData;
    //三相电压不平衡度限值
    private double limitThreeVoltageUnbalanceData;
    //三相电压不平衡度最大幅值和限值的差值
    private double diffThreeVoltageUnbalanceData;

    //负序电流超标天数
    private int overNegativeDay;
    //负序电流最大幅值
    private double maxNegativeDay;
    //负序电流限值
    private double limitNegativeData;
    //负序电流最大幅值和限值的差值
    private double diffNegativeData;

    //闪变超标天数
    private int overFlickerDay;
    //闪变最大幅值
    private double maxFlickerData;
    //闪变限值
    private double limitFlickerData;
    //闪变最大幅值和限值的差值
    private double diffFlickerData;

    /**
     *各次谐波电压含有率
     */
    //3次
    private int overVoltageThreeTimes;
    //5次
    private int overVoltageFiveTimes;
    //7次
    private int overVoltageSevenTimes;
    //11次
    private int overVoltageElevenTimes;
    //13次
    private int overVoltageThirteenTimes;
    //23次
    private int overVoltageTwentyThirdTimes;
    //25次
    private int overVoltageTwentyFiveTimes;
    //其他次
    private int overVoltageOtherTimes;

    /**
     * 各次谐波电流含量
     */
    //3次
    private int overCurrentThreeTimes;
    //5次
    private int overCurrentFiveTimes;
    //7次
    private int overCurrentSevenTimes;
    //11次
    private int overCurrentElevenTimes;
    //13次
    private int overCurrentThirteenTimes;
    //23次
    private int overCurrentTwentyThirdTimes;
    //25次
    private int overCurrentTwentyFiveTimes;
    //其他次
    private int overCurrentOtherTimes;

    //监测点编号
    private String monitorNumber;

    public String getProvinceCompany() {
        return provinceCompany;
    }

    public void setProvinceCompany(String provinceCompany) {
        this.provinceCompany = provinceCompany;
    }

    public String getCityCompany() {
        return cityCompany;
    }

    public void setCityCompany(String cityCompany) {
        this.cityCompany = cityCompany;
    }

    public int getMonitorId() {
        return monitorId;
    }

    public void setMonitorId(int monitorId) {
        this.monitorId = monitorId;
    }

    public String getMonitorName() {
        return monitorName;
    }

    public void setMonitorName(String monitorName) {
        this.monitorName = monitorName;
    }

    public String getMonitorType() {
        return monitorType;
    }

    public void setMonitorType(String monitorType) {
        this.monitorType = monitorType;
    }

    public String getMonitorVoltageLevel() {
        return monitorVoltageLevel;
    }

    public void setMonitorVoltageLevel(String monitorVoltageLevel) {
        this.monitorVoltageLevel = monitorVoltageLevel;
    }

    public String getPlantName() {
        return plantName;
    }

    public void setPlantName(String plantName) {
        this.plantName = plantName;
    }

    public int getOverLimitDay() {
        return overLimitDay;
    }

    public void setOverLimitDay(int overLimitDay) {
        this.overLimitDay = overLimitDay;
    }

    public int getOverFrequencyDeviationDay() {
        return overFrequencyDeviationDay;
    }

    public void setOverFrequencyDeviationDay(int overFrequencyDeviationDay) {
        this.overFrequencyDeviationDay = overFrequencyDeviationDay;
    }

    public int getOverVoltageDeviationDay() {
        return overVoltageDeviationDay;
    }

    public void setOverVoltageDeviationDay(int overVoltageDeviationDay) {
        this.overVoltageDeviationDay = overVoltageDeviationDay;
    }

    public int getOverLimitHarmVDay() {
        return overLimitHarmVDay;
    }

    public void setOverLimitHarmVDay(int overLimitHarmVDay) {
        this.overLimitHarmVDay = overLimitHarmVDay;
    }

    public int getOverVoltageDistortionDay() {
        return overVoltageDistortionDay;
    }

    public void setOverVoltageDistortionDay(int overVoltageDistortionDay) {
        this.overVoltageDistortionDay = overVoltageDistortionDay;
    }

    public int getOverHarmonicVoltageDay() {
        return overHarmonicVoltageDay;
    }

    public void setOverHarmonicVoltageDay(int overHarmonicVoltageDay) {
        this.overHarmonicVoltageDay = overHarmonicVoltageDay;
    }

    public int getOverHarmonicCurrentDay() {
        return overHarmonicCurrentDay;
    }

    public void setOverHarmonicCurrentDay(int overHarmonicCurrentDay) {
        this.overHarmonicCurrentDay = overHarmonicCurrentDay;
    }

    public int getOverVoltageThreeTimes() {
        return overVoltageThreeTimes;
    }

    public void setOverVoltageThreeTimes(int overVoltageThreeTimes) {
        this.overVoltageThreeTimes = overVoltageThreeTimes;
    }

    public int getOverVoltageFiveTimes() {
        return overVoltageFiveTimes;
    }

    public void setOverVoltageFiveTimes(int overVoltageFiveTimes) {
        this.overVoltageFiveTimes = overVoltageFiveTimes;
    }

    public int getOverVoltageSevenTimes() {
        return overVoltageSevenTimes;
    }

    public void setOverVoltageSevenTimes(int overVoltageSevenTimes) {
        this.overVoltageSevenTimes = overVoltageSevenTimes;
    }

    public int getOverVoltageElevenTimes() {
        return overVoltageElevenTimes;
    }

    public void setOverVoltageElevenTimes(int overVoltageElevenTimes) {
        this.overVoltageElevenTimes = overVoltageElevenTimes;
    }

    public int getOverVoltageThirteenTimes() {
        return overVoltageThirteenTimes;
    }

    public void setOverVoltageThirteenTimes(int overVoltageThirteenTimes) {
        this.overVoltageThirteenTimes = overVoltageThirteenTimes;
    }

    public int getOverVoltageTwentyThirdTimes() {
        return overVoltageTwentyThirdTimes;
    }

    public void setOverVoltageTwentyThirdTimes(int overVoltageTwentyThirdTimes) {
        this.overVoltageTwentyThirdTimes = overVoltageTwentyThirdTimes;
    }

    public int getOverVoltageTwentyFiveTimes() {
        return overVoltageTwentyFiveTimes;
    }

    public void setOverVoltageTwentyFiveTimes(int overVoltageTwentyFiveTimes) {
        this.overVoltageTwentyFiveTimes = overVoltageTwentyFiveTimes;
    }

    public int getOverVoltageOtherTimes() {
        return overVoltageOtherTimes;
    }

    public void setOverVoltageOtherTimes(int overVoltageOtherTimes) {
        this.overVoltageOtherTimes = overVoltageOtherTimes;
    }

    public int getOverCurrentThreeTimes() {
        return overCurrentThreeTimes;
    }

    public void setOverCurrentThreeTimes(int overCurrentThreeTimes) {
        this.overCurrentThreeTimes = overCurrentThreeTimes;
    }

    public int getOverCurrentFiveTimes() {
        return overCurrentFiveTimes;
    }

    public void setOverCurrentFiveTimes(int overCurrentFiveTimes) {
        this.overCurrentFiveTimes = overCurrentFiveTimes;
    }

    public int getOverCurrentSevenTimes() {
        return overCurrentSevenTimes;
    }

    public void setOverCurrentSevenTimes(int overCurrentSevenTimes) {
        this.overCurrentSevenTimes = overCurrentSevenTimes;
    }

    public int getOverCurrentElevenTimes() {
        return overCurrentElevenTimes;
    }

    public void setOverCurrentElevenTimes(int overCurrentElevenTimes) {
        this.overCurrentElevenTimes = overCurrentElevenTimes;
    }

    public int getOverCurrentThirteenTimes() {
        return overCurrentThirteenTimes;
    }

    public void setOverCurrentThirteenTimes(int overCurrentThirteenTimes) {
        this.overCurrentThirteenTimes = overCurrentThirteenTimes;
    }

    public int getOverCurrentTwentyThirdTimes() {
        return overCurrentTwentyThirdTimes;
    }

    public void setOverCurrentTwentyThirdTimes(int overCurrentTwentyThirdTimes) {
        this.overCurrentTwentyThirdTimes = overCurrentTwentyThirdTimes;
    }

    public int getOverCurrentTwentyFiveTimes() {
        return overCurrentTwentyFiveTimes;
    }

    public void setOverCurrentTwentyFiveTimes(int overCurrentTwentyFiveTimes) {
        this.overCurrentTwentyFiveTimes = overCurrentTwentyFiveTimes;
    }

    public int getOverCurrentOtherTimes() {
        return overCurrentOtherTimes;
    }

    public void setOverCurrentOtherTimes(int overCurrentOtherTimes) {
        this.overCurrentOtherTimes = overCurrentOtherTimes;
    }

    public int getOverThreeVoltageUnbalanceDay() {
        return overThreeVoltageUnbalanceDay;
    }

    public void setOverThreeVoltageUnbalanceDay(int overThreeVoltageUnbalanceDay) {
        this.overThreeVoltageUnbalanceDay = overThreeVoltageUnbalanceDay;
    }

    public int getOverFlickerDay() {
        return overFlickerDay;
    }

    public void setOverFlickerDay(int overFlickerDay) {
        this.overFlickerDay = overFlickerDay;
    }

    public String getMonitorNumber() {
        return monitorNumber;
    }

    public void setMonitorNumber(String monitorNumber) {
        this.monitorNumber = monitorNumber;
    }

    public String getPlantVolageLevel() {
        return plantVolageLevel;
    }

    public void setPlantVolageLevel(String plantVolageLevel) {
        this.plantVolageLevel = plantVolageLevel;
    }

    public int getOverInterharmonicsDay() {
        return overInterharmonicsDay;
    }

    public void setOverInterharmonicsDay(int overInterharmonicsDay) {
        this.overInterharmonicsDay = overInterharmonicsDay;
    }

    public int getOverNegativeDay() {
        return overNegativeDay;
    }

    public void setOverNegativeDay(int overNegativeDay) {
        this.overNegativeDay = overNegativeDay;
    }

    public String getObjName() {
        return objName;
    }

    public void setObjName(String objName) {
        this.objName = objName;
    }

    public String getPowerSubstationName() {
        return powerSubstationName;
    }

    public void setPowerSubstationName(String powerSubstationName) {
        this.powerSubstationName = powerSubstationName;
    }

    public Float getDlcMp() {
        return dlcMp;
    }

    public void setDlcMp(Float dlcMp) {
        this.dlcMp = dlcMp;
    }

    public Float getDevcMp() {
        return devcMp;
    }

    public void setDevcMp(Float devcMp) {
        this.devcMp = devcMp;
    }

    public Float getXycMp() {
        return xycMp;
    }

    public void setXycMp(Float xycMp) {
        this.xycMp = xycMp;
    }

    public double getMaxVoltageDeviationData() {
        return maxVoltageDeviationData;
    }

    public void setMaxVoltageDeviationData(double maxVoltageDeviationData) {
        this.maxVoltageDeviationData = maxVoltageDeviationData;
    }

    public double getLimitVoltageDeviationData() {
        return limitVoltageDeviationData;
    }

    public void setLimitVoltageDeviationData(double limitVoltageDeviationData) {
        this.limitVoltageDeviationData = limitVoltageDeviationData;
    }

    public double getDiffVoltageDeviationData() {
        return diffVoltageDeviationData;
    }

    public void setDiffVoltageDeviationData(double diffVoltageDeviationData) {
        this.diffVoltageDeviationData = diffVoltageDeviationData;
    }

    public double getMaxHarmonicCurrentData() {
        return maxHarmonicCurrentData;
    }

    public void setMaxHarmonicCurrentData(double maxHarmonicCurrentData) {
        this.maxHarmonicCurrentData = maxHarmonicCurrentData;
    }

    public double getLimitHarmonicCurrentData() {
        return limitHarmonicCurrentData;
    }

    public void setLimitHarmonicCurrentData(double limitHarmonicCurrentData) {
        this.limitHarmonicCurrentData = limitHarmonicCurrentData;
    }

    public double getDiffHarmonicCurrentData() {
        return diffHarmonicCurrentData;
    }

    public void setDiffHarmonicCurrentData(double diffHarmonicCurrentData) {
        this.diffHarmonicCurrentData = diffHarmonicCurrentData;
    }

    public double getMaxLimitHarmVData() {
        return maxLimitHarmVData;
    }

    public void setMaxLimitHarmVData(double maxLimitHarmVData) {
        this.maxLimitHarmVData = maxLimitHarmVData;
    }

    public double getLimitHarmVData() {
        return limitHarmVData;
    }

    public void setLimitHarmVData(double limitHarmVData) {
        this.limitHarmVData = limitHarmVData;
    }

    public double getDiffHarmVData() {
        return diffHarmVData;
    }

    public void setDiffHarmVData(double diffHarmVData) {
        this.diffHarmVData = diffHarmVData;
    }

    public double getMaxVoltageDistortionData() {
        return maxVoltageDistortionData;
    }

    public void setMaxVoltageDistortionData(double maxVoltageDistortionData) {
        this.maxVoltageDistortionData = maxVoltageDistortionData;
    }

    public double getLimitVoltageDistortionData() {
        return limitVoltageDistortionData;
    }

    public void setLimitVoltageDistortionData(double limitVoltageDistortionData) {
        this.limitVoltageDistortionData = limitVoltageDistortionData;
    }

    public double getDiffVoltageDistortionData() {
        return diffVoltageDistortionData;
    }

    public void setDiffVoltageDistortionData(double diffVoltageDistortionData) {
        this.diffVoltageDistortionData = diffVoltageDistortionData;
    }

    public double getMaxHarmonicVoltageData() {
        return maxHarmonicVoltageData;
    }

    public void setMaxHarmonicVoltageData(double maxHarmonicVoltageData) {
        this.maxHarmonicVoltageData = maxHarmonicVoltageData;
    }

    public double getLimitHarmonicVoltageData() {
        return limitHarmonicVoltageData;
    }

    public void setLimitHarmonicVoltageData(double limitHarmonicVoltageData) {
        this.limitHarmonicVoltageData = limitHarmonicVoltageData;
    }

    public double getDiffHarmonicVoltageData() {
        return diffHarmonicVoltageData;
    }

    public void setDiffHarmonicVoltageData(double diffHarmonicVoltageData) {
        this.diffHarmonicVoltageData = diffHarmonicVoltageData;
    }

    public double getMaxFrequencyDeviationData() {
        return maxFrequencyDeviationData;
    }

    public void setMaxFrequencyDeviationData(double maxFrequencyDeviationData) {
        this.maxFrequencyDeviationData = maxFrequencyDeviationData;
    }

    public double getLimitFrequencyDeviationData() {
        return limitFrequencyDeviationData;
    }

    public void setLimitFrequencyDeviationData(double limitFrequencyDeviationData) {
        this.limitFrequencyDeviationData = limitFrequencyDeviationData;
    }

    public double getDiffFrequencyDeviationData() {
        return diffFrequencyDeviationData;
    }

    public void setDiffFrequencyDeviationData(double diffFrequencyDeviationData) {
        this.diffFrequencyDeviationData = diffFrequencyDeviationData;
    }

    public double getMaxInterharmonicsData() {
        return maxInterharmonicsData;
    }

    public void setMaxInterharmonicsData(double maxInterharmonicsData) {
        this.maxInterharmonicsData = maxInterharmonicsData;
    }

    public double getLimitInterharmonicsData() {
        return limitInterharmonicsData;
    }

    public void setLimitInterharmonicsData(double limitInterharmonicsData) {
        this.limitInterharmonicsData = limitInterharmonicsData;
    }

    public double getDiffInterharmonicsData() {
        return diffInterharmonicsData;
    }

    public void setDiffInterharmonicsData(double diffInterharmonicsData) {
        this.diffInterharmonicsData = diffInterharmonicsData;
    }

    public double getMaxThreeVoltageUnbalanceData() {
        return maxThreeVoltageUnbalanceData;
    }

    public void setMaxThreeVoltageUnbalanceData(double maxThreeVoltageUnbalanceData) {
        this.maxThreeVoltageUnbalanceData = maxThreeVoltageUnbalanceData;
    }

    public double getLimitThreeVoltageUnbalanceData() {
        return limitThreeVoltageUnbalanceData;
    }

    public void setLimitThreeVoltageUnbalanceData(double limitThreeVoltageUnbalanceData) {
        this.limitThreeVoltageUnbalanceData = limitThreeVoltageUnbalanceData;
    }

    public double getDiffThreeVoltageUnbalanceData() {
        return diffThreeVoltageUnbalanceData;
    }

    public void setDiffThreeVoltageUnbalanceData(double diffThreeVoltageUnbalanceData) {
        this.diffThreeVoltageUnbalanceData = diffThreeVoltageUnbalanceData;
    }

    public double getMaxNegativeDay() {
        return maxNegativeDay;
    }

    public void setMaxNegativeDay(double maxNegativeDay) {
        this.maxNegativeDay = maxNegativeDay;
    }

    public double getLimitNegativeData() {
        return limitNegativeData;
    }

    public void setLimitNegativeData(double limitNegativeData) {
        this.limitNegativeData = limitNegativeData;
    }

    public double getDiffNegativeData() {
        return diffNegativeData;
    }

    public void setDiffNegativeData(double diffNegativeData) {
        this.diffNegativeData = diffNegativeData;
    }

    public double getMaxFlickerData() {
        return maxFlickerData;
    }

    public void setMaxFlickerData(double maxFlickerData) {
        this.maxFlickerData = maxFlickerData;
    }

    public double getLimitFlickerData() {
        return limitFlickerData;
    }

    public void setLimitFlickerData(double limitFlickerData) {
        this.limitFlickerData = limitFlickerData;
    }

    public double getDiffFlickerData() {
        return diffFlickerData;
    }

    public void setDiffFlickerData(double diffFlickerData) {
        this.diffFlickerData = diffFlickerData;
    }

    @Override
    public String toString() {
        return "OverLimitMonitor{" +
                "provinceCompany='" + provinceCompany + '\'' +
                ", cityCompany='" + cityCompany + '\'' +
                ", monitorId=" + monitorId +
                ", monitorName='" + monitorName + '\'' +
                ", monitorType='" + monitorType + '\'' +
                ", powerSubstationName='" + powerSubstationName + '\'' +
                ", objName='" + objName + '\'' +
                ", monitorVoltageLevel='" + monitorVoltageLevel + '\'' +
                ", plantName='" + plantName + '\'' +
                ", plantVolageLevel='" + plantVolageLevel + '\'' +
                ", dlcMp=" + dlcMp +
                ", devcMp=" + devcMp +
                ", xycMp=" + xycMp +
                ", overLimitDay=" + overLimitDay +
                ", overVoltageDeviationDay=" + overVoltageDeviationDay +
                ", maxVoltageDeviationData=" + maxVoltageDeviationData +
                ", limitVoltageDeviationData=" + limitVoltageDeviationData +
                ", diffVoltageDeviationData=" + diffVoltageDeviationData +
                ", overHarmonicCurrentDay=" + overHarmonicCurrentDay +
                ", maxHarmonicCurrentData=" + maxHarmonicCurrentData +
                ", limitHarmonicCurrentData=" + limitHarmonicCurrentData +
                ", diffHarmonicCurrentData=" + diffHarmonicCurrentData +
                ", overLimitHarmVDay=" + overLimitHarmVDay +
                ", maxLimitHarmVData=" + maxLimitHarmVData +
                ", limitHarmVData=" + limitHarmVData +
                ", diffHarmVData=" + diffHarmVData +
                ", overVoltageDistortionDay=" + overVoltageDistortionDay +
                ", maxVoltageDistortionData=" + maxVoltageDistortionData +
                ", limitVoltageDistortionData=" + limitVoltageDistortionData +
                ", diffVoltageDistortionData=" + diffVoltageDistortionData +
                ", overHarmonicVoltageDay=" + overHarmonicVoltageDay +
                ", maxHarmonicVoltageData=" + maxHarmonicVoltageData +
                ", limitHarmonicVoltageData=" + limitHarmonicVoltageData +
                ", diffHarmonicVoltageData=" + diffHarmonicVoltageData +
                ", overFrequencyDeviationDay=" + overFrequencyDeviationDay +
                ", maxFrequencyDeviationData=" + maxFrequencyDeviationData +
                ", limitFrequencyDeviationData=" + limitFrequencyDeviationData +
                ", diffFrequencyDeviationData=" + diffFrequencyDeviationData +
                ", overInterharmonicsDay=" + overInterharmonicsDay +
                ", maxInterharmonicsData=" + maxInterharmonicsData +
                ", limitInterharmonicsData=" + limitInterharmonicsData +
                ", diffInterharmonicsData=" + diffInterharmonicsData +
                ", overThreeVoltageUnbalanceDay=" + overThreeVoltageUnbalanceDay +
                ", maxThreeVoltageUnbalanceData=" + maxThreeVoltageUnbalanceData +
                ", limitThreeVoltageUnbalanceData=" + limitThreeVoltageUnbalanceData +
                ", diffThreeVoltageUnbalanceData=" + diffThreeVoltageUnbalanceData +
                ", overNegativeDay=" + overNegativeDay +
                ", maxNegativeDay=" + maxNegativeDay +
                ", limitNegativeData=" + limitNegativeData +
                ", diffNegativeData=" + diffNegativeData +
                ", overFlickerDay=" + overFlickerDay +
                ", maxFlickerData=" + maxFlickerData +
                ", limitFlickerData=" + limitFlickerData +
                ", diffFlickerData=" + diffFlickerData +
                ", overVoltageThreeTimes=" + overVoltageThreeTimes +
                ", overVoltageFiveTimes=" + overVoltageFiveTimes +
                ", overVoltageSevenTimes=" + overVoltageSevenTimes +
                ", overVoltageElevenTimes=" + overVoltageElevenTimes +
                ", overVoltageThirteenTimes=" + overVoltageThirteenTimes +
                ", overVoltageTwentyThirdTimes=" + overVoltageTwentyThirdTimes +
                ", overVoltageTwentyFiveTimes=" + overVoltageTwentyFiveTimes +
                ", overVoltageOtherTimes=" + overVoltageOtherTimes +
                ", overCurrentThreeTimes=" + overCurrentThreeTimes +
                ", overCurrentFiveTimes=" + overCurrentFiveTimes +
                ", overCurrentSevenTimes=" + overCurrentSevenTimes +
                ", overCurrentElevenTimes=" + overCurrentElevenTimes +
                ", overCurrentThirteenTimes=" + overCurrentThirteenTimes +
                ", overCurrentTwentyThirdTimes=" + overCurrentTwentyThirdTimes +
                ", overCurrentTwentyFiveTimes=" + overCurrentTwentyFiveTimes +
                ", overCurrentOtherTimes=" + overCurrentOtherTimes +
                ", monitorNumber='" + monitorNumber + '\'' +
                '}';
    }
}
