package com.njcn.pojo.data;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Detailed {
    private String bdName;
    private Date dTime;
    private String time;
    private String gdName;
    private String pointName;
    private String listResult = "";
    private Integer tinterval;
    private Integer oddCount = 0; //偶次谐波电压总数
    private Integer eveCount = 0; //奇次谐波电压总数
    private Integer oddIcount = 0;//偶次谐波电流总数
    private Integer eveIcount = 0;//奇次谐波电流总数
    private Long lineId;
    private Integer totalCount = 0;

    private Integer freqDevOverTime;

    private Integer voltageDevOvertime;

    private Integer UBalanceOverTime;

    private Integer flickerOverTime;

    private Integer UAberranceOverTime;

    private Integer UHarm2OverTime;

    private Integer UHarm3OverTime;

    private Integer UHarm4OverTime;

    private Integer UHarm5OverTime;

    private Integer UHarm6OverTime;

    private Integer UHarm7OverTime;

    private Integer UHarm8OverTime;

    private Integer UHarm9OverTime;

    private Integer UHarm10OverTime;

    private Integer UHarm11OverTime;

    private Integer UHarm12OverTime;

    private Integer UHarm13OverTime;

    private Integer UHarm14OverTime;

    private Integer UHarm15OverTime;

    private Integer UHarm16OverTime;

    private Integer UHarm17OverTime;

    private Integer UHarm18OverTime;

    private Integer UHarm19OverTime;

    private Integer UHarm20OverTime;

    private Integer UHarm21OverTime;

    private Integer UHarm22OverTime;

    private Integer UHarm23OverTime;

    private Integer UHarm24OverTime;

    private Integer UHarm25OverTime;

    private Integer IHarm2OverTime;

    private Integer IHarm3OverTime;

    private Integer IHarm4OverTime;

    private Integer IHarm5OverTime;

    private Integer IHarm6OverTime;

    private Integer IHarm7OverTime;

    private Integer IHarm8OverTime;

    private Integer IHarm9OverTime;

    private Integer IHarm10OverTime;

    private Integer IHarm11OverTime;

    private Integer IHarm12OverTime;

    private Integer IHarm13OverTime;

    private Integer IHarm14OverTime;

    private Integer IHarm15OverTime;

    private Integer IHarm16OverTime;

    private Integer IHarm17OverTime;

    private Integer IHarm18OverTime;

    private Integer IHarm19OverTime;

    private Integer IHarm20OverTime;

    private Integer IHarm21OverTime;

    private Integer IHarm22OverTime;

    private Integer IHarm23OverTime;

    private Integer IHarm24OverTime;

    private Integer IHarm25OverTime;

    //负序电流限值次数
    private Integer INegOvertime;

    //偶次谐波电压总数
    private Integer inuCount  = 0;

    private Integer INUHARM1OverTime;

    private Integer INUHARM2OverTime;

    private Integer INUHARM3OverTime;

    private Integer INUHARM4OverTime;

    private Integer INUHARM5OverTime;

    private Integer INUHARM6OverTime;

    private Integer INUHARM7OverTime;

    private Integer INUHARM8OverTime;

    private Integer INUHARM9OverTime;

    private Integer INUHARM100OverTime;

    private Integer INUHARM11OverTime;

    private Integer INUHARM12OverTime;

    private Integer INUHARM13OverTime;

    private Integer INUHARM14OverTime;

    private Integer INUHARM15OverTime;

    private Integer INUHARM16OverTime;

    public Integer getFreqDevOverTime() {
        return freqDevOverTime;
    }

    public void setFreqDevOverTime(Integer freqDevOverTime) {
        this.freqDevOverTime = freqDevOverTime;
        packageData(this.freqDevOverTime, "频率偏差越限", 0);
    }

    public Integer getVoltageDevOvertime() {
        return voltageDevOvertime;
    }

    public void setVoltageDevOvertime(Integer voltageDevOvertime) {
        this.voltageDevOvertime = voltageDevOvertime;
        packageData(this.voltageDevOvertime, "电压偏差越限", 0);
    }

    public Integer getUBalanceOverTime() {
        return UBalanceOverTime;
    }

    public void setUBalanceOverTime(Integer UBalanceOverTime) {
        this.UBalanceOverTime = UBalanceOverTime;
        packageData(this.UBalanceOverTime, "电压不平衡越限", 0);
    }

    public Integer getFlickerOverTime() {
        return flickerOverTime;
    }

    public void setFlickerOverTime(Integer flickerOverTime) {
        this.flickerOverTime = flickerOverTime;
        packageData(this.flickerOverTime, "闪变越限", 0);
    }

    public Integer getUAberranceOverTime() {
        return UAberranceOverTime;
    }

    public void setUAberranceOverTime(Integer UAberranceOverTime) {
        this.UAberranceOverTime = UAberranceOverTime;
        packageData(this.UAberranceOverTime, "电压谐波畸变率越限", 0);
    }

    public Integer getUHarm2OverTime() {
        return UHarm2OverTime;
    }

    public void setUHarm2OverTime(Integer UHarm2OverTime) {
        this.UHarm2OverTime = UHarm2OverTime;
        packageData(this.UHarm2OverTime, "2次电压谐波含有率越限", 2);
    }

    public Integer getUHarm3OverTime() {
        return UHarm3OverTime;
    }

    public void setUHarm3OverTime(Integer UHarm3OverTime) {
        this.UHarm3OverTime = UHarm3OverTime;
        packageData(this.UHarm3OverTime, "3次电压谐波含有率越限", 1);
    }

    public Integer getUHarm4OverTime() {
        return UHarm4OverTime;
    }

    public void setUHarm4OverTime(Integer UHarm4OverTime) {
        this.UHarm4OverTime = UHarm4OverTime;
        packageData(this.UHarm4OverTime, "4次电压谐波含有率越限", 2);
    }

    public Integer getUHarm5OverTime() {
        return UHarm5OverTime;
    }

    public void setUHarm5OverTime(Integer UHarm5OverTime) {
        this.UHarm5OverTime = UHarm5OverTime;
        packageData(this.UHarm5OverTime, "5次电压谐波含有率越限", 1);
    }

    public Integer getUHarm6OverTime() {
        return UHarm6OverTime;
    }

    public void setUHarm6OverTime(Integer UHarm6OverTime) {
        this.UHarm6OverTime = UHarm6OverTime;
        packageData(this.UHarm6OverTime, "6次电压谐波含有率越限", 2);
    }

    public Integer getUHarm7OverTime() {
        return UHarm7OverTime;
    }

    public void setUHarm7OverTime(Integer UHarm7OverTime) {
        this.UHarm7OverTime = UHarm7OverTime;
        packageData(this.UHarm7OverTime, "7次电压谐波含有率越限", 1);
    }

    public Integer getUHarm8OverTime() {
        return UHarm8OverTime;
    }

    public void setUHarm8OverTime(Integer UHarm8OverTime) {
        this.UHarm8OverTime = UHarm8OverTime;
        packageData(this.UHarm8OverTime, "8次电压谐波含有率越限", 2);
    }

    public Integer getUHarm9OverTime() {
        return UHarm9OverTime;
    }

    public void setUHarm9OverTime(Integer UHarm9OverTime) {
        this.UHarm9OverTime = UHarm9OverTime;
        packageData(this.UHarm9OverTime, "9次电压谐波含有率越限", 1);
    }

    public Integer getUHarm10OverTime() {
        return UHarm10OverTime;
    }

    public void setUHarm10OverTime(Integer UHarm10OverTime) {
        this.UHarm10OverTime = UHarm10OverTime;
        packageData(this.UHarm10OverTime, "10次电压谐波含有率越限", 2);
    }

    public Integer getUHarm11OverTime() {
        return UHarm11OverTime;
    }

    public void setUHarm11OverTime(Integer UHarm11OverTime) {
        this.UHarm11OverTime = UHarm11OverTime;
        packageData(this.UHarm11OverTime, "11次电压谐波含有率越限", 1);
    }

    public Integer getUHarm12OverTime() {
        return UHarm12OverTime;
    }

    public void setUHarm12OverTime(Integer UHarm12OverTime) {
        this.UHarm12OverTime = UHarm12OverTime;
        packageData(this.UHarm12OverTime, "12次电压谐波含有率越限", 2);
    }

    public Integer getUHarm13OverTime() {
        return UHarm13OverTime;
    }

    public void setUHarm13OverTime(Integer UHarm13OverTime) {
        this.UHarm13OverTime = UHarm13OverTime;
        packageData(this.UHarm13OverTime, "13次电压谐波含有率越限", 1);
    }

    public Integer getUHarm14OverTime() {
        return UHarm14OverTime;
    }

    public void setUHarm14OverTime(Integer UHarm14OverTime) {
        this.UHarm14OverTime = UHarm14OverTime;
        packageData(this.UHarm14OverTime, "14次电压谐波含有率越限", 2);
    }

    public Integer getUHarm15OverTime() {
        return UHarm15OverTime;
    }

    public void setUHarm15OverTime(Integer UHarm15OverTime) {
        this.UHarm15OverTime = UHarm15OverTime;
        packageData(this.UHarm15OverTime, "15次电压谐波含有率越限", 1);
    }

    public Integer getUHarm16OverTime() {
        return UHarm16OverTime;
    }

    public void setUHarm16OverTime(Integer UHarm16OverTime) {
        this.UHarm16OverTime = UHarm16OverTime;
        packageData(this.UHarm16OverTime, "16次电压谐波含有率越限", 2);
    }

    public Integer getUHarm17OverTime() {
        return UHarm17OverTime;
    }

    public void setUHarm17OverTime(Integer UHarm17OverTime) {
        this.UHarm17OverTime = UHarm17OverTime;
        packageData(this.UHarm17OverTime, "17次电压谐波含有率越限", 1);
    }

    public Integer getUHarm18OverTime() {
        return UHarm18OverTime;
    }

    public void setUHarm18OverTime(Integer UHarm18OverTime) {
        this.UHarm18OverTime = UHarm18OverTime;
        packageData(this.UHarm18OverTime, "18次电压谐波含有率越限", 2);
    }

    public Integer getUHarm19OverTime() {
        return UHarm19OverTime;
    }

    public void setUHarm19OverTime(Integer UHarm19OverTime) {
        this.UHarm19OverTime = UHarm19OverTime;
        packageData(this.UHarm19OverTime, "19次电压谐波含有率越限", 1);
    }

    public Integer getUHarm20OverTime() {
        return UHarm20OverTime;
    }

    public void setUHarm20OverTime(Integer UHarm20OverTime) {
        this.UHarm20OverTime = UHarm20OverTime;
        packageData(this.UHarm20OverTime, "20次电压谐波含有率越限", 2);
    }

    public Integer getUHarm21OverTime() {
        return UHarm21OverTime;
    }

    public void setUHarm21OverTime(Integer UHarm21OverTime) {
        this.UHarm21OverTime = UHarm21OverTime;
        packageData(this.UHarm21OverTime, "21次电压谐波含有率越限", 1);
    }

    public Integer getUHarm22OverTime() {
        return UHarm22OverTime;
    }

    public void setUHarm22OverTime(Integer UHarm22OverTime) {
        this.UHarm22OverTime = UHarm22OverTime;
        packageData(this.UHarm22OverTime, "22次电压谐波含有率越限", 2);
    }

    public Integer getUHarm23OverTime() {
        return UHarm23OverTime;
    }

    public void setUHarm23OverTime(Integer UHarm23OverTime) {
        this.UHarm23OverTime = UHarm23OverTime;
        packageData(this.UHarm23OverTime, "23次电压谐波含有率越限", 1);
    }

    public Integer getUHarm24OverTime() {
        return UHarm24OverTime;
    }

    public void setUHarm24OverTime(Integer UHarm24OverTime) {
        this.UHarm24OverTime = UHarm24OverTime;
        packageData(this.UHarm24OverTime, "24次电压谐波含有率越限", 2);
    }

    public Integer getUHarm25OverTime() {
        return UHarm25OverTime;
    }

    public void setUHarm25OverTime(Integer UHarm25OverTime) {
        this.UHarm25OverTime = UHarm25OverTime;
        packageData(this.UHarm25OverTime, "25次电压谐波含有率越限", 1);
    }

    public Integer getIHarm2OverTime() {
        return IHarm2OverTime;
    }

    public void setIHarm2OverTime(Integer IHarm2OverTime) {
        this.IHarm2OverTime = IHarm2OverTime;
        packageData(this.IHarm2OverTime, "2次电流谐波幅值越限", 4);
    }

    public Integer getIHarm3OverTime() {
        return IHarm3OverTime;
    }

    public void setIHarm3OverTime(Integer IHarm3OverTime) {
        this.IHarm3OverTime = IHarm3OverTime;
        packageData(this.IHarm3OverTime, "3次电流谐波幅值越限", 3);
    }

    public Integer getIHarm4OverTime() {
        return IHarm4OverTime;
    }

    public void setIHarm4OverTime(Integer IHarm4OverTime) {
        this.IHarm4OverTime = IHarm4OverTime;
        packageData(this.IHarm4OverTime, "4次电流谐波幅值越限", 4);
    }

    public Integer getIHarm5OverTime() {
        return IHarm5OverTime;
    }

    public void setIHarm5OverTime(Integer IHarm5OverTime) {
        this.IHarm5OverTime = IHarm5OverTime;
        packageData(this.IHarm5OverTime, "5次电流谐波幅值越限", 3);
    }

    public Integer getIHarm6OverTime() {
        return IHarm6OverTime;
    }

    public void setIHarm6OverTime(Integer IHarm6OverTime) {
        this.IHarm6OverTime = IHarm6OverTime;
        packageData(this.IHarm6OverTime, "6次电流谐波幅值越限", 4);
    }

    public Integer getIHarm7OverTime() {
        return IHarm7OverTime;
    }

    public void setIHarm7OverTime(Integer IHarm7OverTime) {
        this.IHarm7OverTime = IHarm7OverTime;
        packageData(this.IHarm7OverTime, "7次电流谐波幅值越限", 3);
    }

    public Integer getIHarm8OverTime() {
        return IHarm8OverTime;
    }

    public void setIHarm8OverTime(Integer IHarm8OverTime) {
        this.IHarm8OverTime = IHarm8OverTime;
        packageData(this.IHarm8OverTime, "8次电流谐波幅值越限", 4);
    }

    public Integer getIHarm9OverTime() {
        return IHarm9OverTime;
    }

    public void setIHarm9OverTime(Integer IHarm9OverTime) {
        this.IHarm9OverTime = IHarm9OverTime;
        packageData(this.IHarm9OverTime, "9次电流谐波幅值越限", 3);
    }

    public Integer getIHarm10OverTime() {
        return IHarm10OverTime;
    }

    public void setIHarm10OverTime(Integer IHarm10OverTime) {
        this.IHarm10OverTime = IHarm10OverTime;
        packageData(this.IHarm10OverTime, "10次电流谐波幅值越限", 4);
    }

    public Integer getIHarm11OverTime() {
        return IHarm11OverTime;
    }

    public void setIHarm11OverTime(Integer IHarm11OverTime) {
        this.IHarm11OverTime = IHarm11OverTime;
        packageData(this.IHarm11OverTime , "11次电流谐波幅值越限", 3);
    }

    public Integer getIHarm12OverTime() {
        return IHarm12OverTime;
    }

    public void setIHarm12OverTime(Integer IHarm12OverTime) {
        this.IHarm12OverTime = IHarm12OverTime;
        packageData(this.IHarm12OverTime , "12次电流谐波幅值越限", 4);
    }

    public Integer getIHarm13OverTime() {
        return IHarm13OverTime;
    }

    public void setIHarm13OverTime(Integer IHarm13OverTime) {
        this.IHarm13OverTime = IHarm13OverTime;
        packageData(this.IHarm13OverTime, "13次电流谐波幅值越限", 3);
    }

    public Integer getIHarm14OverTime() {
        return IHarm14OverTime;
    }

    public void setIHarm14OverTime(Integer IHarm14OverTime) {
        this.IHarm14OverTime = IHarm14OverTime;
        packageData(this.IHarm14OverTime, "14次电流谐波幅值越限", 4);
    }

    public Integer getIHarm15OverTime() {
        return IHarm15OverTime;
    }

    public void setIHarm15OverTime(Integer IHarm15OverTime) {
        this.IHarm15OverTime = IHarm15OverTime;
        packageData(this.IHarm15OverTime , "15次电流谐波幅值越限", 3);
    }

    public Integer getIHarm16OverTime() {
        return IHarm16OverTime;
    }

    public void setIHarm16OverTime(Integer IHarm16OverTime) {
        this.IHarm16OverTime = IHarm16OverTime;
        packageData(this.IHarm16OverTime, "16次电流谐波幅值越限", 4);
    }

    public Integer getIHarm17OverTime() {
        return IHarm17OverTime;
    }

    public void setIHarm17OverTime(Integer IHarm17OverTime) {
        this.IHarm17OverTime = IHarm17OverTime;
        packageData(this.IHarm17OverTime, "17次电流谐波幅值越限", 3);
    }

    public Integer getIHarm18OverTime() {
        return IHarm18OverTime;
    }

    public void setIHarm18OverTime(Integer IHarm18OverTime) {
        this.IHarm18OverTime = IHarm18OverTime;
        packageData(this.IHarm18OverTime, "18次电流谐波幅值越限", 4);
    }

    public Integer getIHarm19OverTime() {
        return IHarm19OverTime;
    }

    public void setIHarm19OverTime(Integer IHarm19OverTime) {
        this.IHarm19OverTime = IHarm19OverTime;
        packageData(this.IHarm19OverTime, "19次电流谐波幅值越限", 3);
    }

    public Integer getIHarm20OverTime() {
        return IHarm20OverTime;
    }

    public void setIHarm20OverTime(Integer IHarm20OverTime) {
        this.IHarm20OverTime = IHarm20OverTime;
        packageData(this.IHarm20OverTime, "20次电流谐波幅值越限", 4);
    }

    public Integer getIHarm21OverTime() {
        return IHarm21OverTime;
    }

    public void setIHarm21OverTime(Integer IHarm21OverTime) {
        this.IHarm21OverTime = IHarm21OverTime;
        packageData(this.IHarm21OverTime, "21次电流谐波幅值越限", 4);
    }

    public Integer getIHarm22OverTime() {
        return IHarm22OverTime;
    }

    public void setIHarm22OverTime(Integer IHarm22OverTime) {
        this.IHarm22OverTime = IHarm22OverTime;
        packageData(this.IHarm22OverTime, "22次电流谐波幅值越限", 4);
    }

    public Integer getIHarm23OverTime() {
        return IHarm23OverTime;
    }

    public void setIHarm23OverTime(Integer IHarm23OverTime) {
        this.IHarm23OverTime = IHarm23OverTime;
        packageData(this.IHarm23OverTime, "23次电流谐波幅值越限", 3);
    }

    public Integer getIHarm24OverTime() {
        return IHarm24OverTime;
    }

    public void setIHarm24OverTime(Integer IHarm24OverTime) {
        this.IHarm24OverTime = IHarm24OverTime;
        packageData(this.IHarm24OverTime, "24次电流谐波幅值越限", 4);
    }

    public Integer getIHarm25OverTime() {
        return IHarm25OverTime;
    }

    public void setIHarm25OverTime(Integer IHarm25OverTime) {
        this.IHarm25OverTime = IHarm25OverTime;
        packageData(this.IHarm25OverTime, "25次电流谐波幅值越限", 3);
    }

    public Integer getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(Integer totalCount) {
        this.totalCount = totalCount;
    }

    public Long getLineId() {
        return lineId;
    }

    public void setLineId(Long lineId) {
        this.lineId = lineId;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }

    public Date getdTime() {
        return dTime;
    }

    public void setdTime(Date dTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        this.time = sdf.format(dTime);
    }

    public Integer getOddIcount() {
        return oddIcount;
    }

    public void setOddIcount(Integer oddIcount) {
        this.oddIcount = oddIcount;
    }

    public Integer getEveIcount() {
        return eveIcount;
    }

    public void setEveIcount(Integer eveIcount) {
        this.eveIcount = eveIcount;
    }

    public Integer getOddCount() {
        return oddCount;
    }

    public void setOddCount(Integer oddCount) {
        this.oddCount = oddCount;
    }

    public Integer getEveCount() {
        return eveCount;
    }

    public void setEveCount(Integer eveCount) {
        this.eveCount = eveCount;
    }

    public Integer getTinterval() {
        return tinterval;
    }

    public void setTinterval(Integer tinterval) {
        this.tinterval = tinterval;
    }

    public String getListResult() {
        return listResult;
    }

    public void setListResult(String listResult) {
        this.listResult = listResult;
    }

    public String getBdName() {
        return bdName;
    }

    public void setBdName(String bdName) {
        this.bdName = bdName;
    }

    public String getGdName() {
        return gdName;
    }

    public void setGdName(String gdName) {
        this.gdName = gdName;
    }

    public String getPointName() {
        return pointName;
    }

    public void setPointName(String pointName) {
        this.pointName = pointName;
    }

    public Integer getINegOvertime() {
        return INegOvertime;
    }

    public void setINegOvertime(Integer INegOvertime) {
        this.INegOvertime = INegOvertime;
        packageData(this.INegOvertime, "负序电流限值越限", 0);
    }

    public Integer getInuCount() {
        return inuCount;
    }

    public void setInuCount(Integer inuCount) {
        this.inuCount = inuCount;
    }

    public Integer getINUHARM1OverTime() {
        return INUHARM1OverTime;
    }

    public void setINUHARM1OverTime(Integer INUHARM1OverTime) {
        this.INUHARM1OverTime = INUHARM1OverTime;
        packageData(this.INUHARM1OverTime, "0.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM2OverTime() {
        return INUHARM2OverTime;
    }

    public void setINUHARM2OverTime(Integer INUHARM2OverTime) {
        this.INUHARM2OverTime = INUHARM2OverTime;
        packageData(this.INUHARM2OverTime, "1.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM3OverTime() {
        return INUHARM3OverTime;
    }

    public void setINUHARM3OverTime(Integer INUHARM3OverTime) {
        this.INUHARM3OverTime = INUHARM3OverTime;
        packageData(this.INUHARM3OverTime, "2.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM4OverTime() {
        return INUHARM4OverTime;
    }

    public void setINUHARM4OverTime(Integer INUHARM4OverTime) {
        this.INUHARM4OverTime = INUHARM4OverTime;
        packageData(this.INUHARM4OverTime, "3.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM5OverTime() {
        return INUHARM5OverTime;
    }

    public void setINUHARM5OverTime(Integer INUHARM5OverTime) {
        this.INUHARM5OverTime = INUHARM5OverTime;
        packageData(this.INUHARM5OverTime, "4.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM6OverTime() {
        return INUHARM6OverTime;
    }

    public void setINUHARM6OverTime(Integer INUHARM6OverTime) {
        this.INUHARM6OverTime = INUHARM6OverTime;
        packageData(this.INUHARM6OverTime, "5.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM7OverTime() {
        return INUHARM7OverTime;
    }

    public void setINUHARM7OverTime(Integer INUHARM7OverTime) {
        this.INUHARM7OverTime = INUHARM7OverTime;
        packageData(this.INUHARM7OverTime, "6.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM8OverTime() {
        return INUHARM8OverTime;
    }

    public void setINUHARM8OverTime(Integer INUHARM8OverTime) {
        this.INUHARM8OverTime = INUHARM8OverTime;
        packageData(this.INUHARM8OverTime, "7.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM9OverTime() {
        return INUHARM9OverTime;
    }

    public void setINUHARM9OverTime(Integer INUHARM9OverTime) {
        this.INUHARM9OverTime = INUHARM9OverTime;
        packageData(this.INUHARM9OverTime, "8.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM100OverTime() {
        return INUHARM100OverTime;
    }

    public void setINUHARM100OverTime(Integer INUHARM100OverTime) {
        this.INUHARM100OverTime = INUHARM100OverTime;
        packageData(this.INUHARM100OverTime, "9.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM11OverTime() {
        return INUHARM11OverTime;
    }

    public void setINUHARM11OverTime(Integer INUHARM11OverTime) {
        this.INUHARM11OverTime = INUHARM11OverTime;
        packageData(this.INUHARM11OverTime, "10.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM12OverTime() {
        return INUHARM12OverTime;
    }

    public void setINUHARM12OverTime(Integer INUHARM12OverTime) {
        this.INUHARM12OverTime = INUHARM12OverTime;
        packageData(this.INUHARM12OverTime, "11.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM13OverTime() {
        return INUHARM13OverTime;
    }

    public void setINUHARM13OverTime(Integer INUHARM13OverTime) {
        this.INUHARM13OverTime = INUHARM13OverTime;
        packageData(this.INUHARM13OverTime, "12.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM14OverTime() {
        return INUHARM14OverTime;
    }

    public void setINUHARM14OverTime(Integer INUHARM14OverTime) {
        this.INUHARM14OverTime = INUHARM14OverTime;
        packageData(this.INUHARM14OverTime, "13.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM15OverTime() {
        return INUHARM15OverTime;
    }

    public void setINUHARM15OverTime(Integer INUHARM15OverTime) {
        this.INUHARM15OverTime = INUHARM15OverTime;
        packageData(this.INUHARM15OverTime, "14.5次间谐波电压限值越限", 5);
    }

    public Integer getINUHARM16OverTime() {
        return INUHARM16OverTime;
    }

    public void setINUHARM16OverTime(Integer INUHARM16OverTime) {
        this.INUHARM16OverTime = INUHARM16OverTime;
        packageData(this.INUHARM16OverTime, "15.5次间谐波电压限值越限", 5);
    }

    public void setValue() {
        //packageData(this.limitRate.getFlicketAllTime(), "闪变总计算次数", 0);
        packageData(this.oddCount, "偶次电压谐波含有率越限", 0);
        packageData(this.eveCount, "奇次电压谐波含有率越限", 0);
        packageData(this.oddIcount, "偶次电流谐波幅值越限", 0);
        packageData(this.eveIcount, "奇次电流谐波幅值越限", 0);
        packageData(this.inuCount, "间谐波电压限值越限", 0);
    }

    private void packageData(Integer count, String des, int type) { //type:0-普通，1-奇次谐波，2-偶次谐波,3-奇次谐波电流，4-偶次谐波电流
        if (count.intValue() > 0) {
            if (type == 0) {
                if (des.equals("闪变越限")) {
                    this.listResult += (des + count * 120 + "分钟，");
                } else {
                    this.listResult += (des + count * this.tinterval + "分钟，");
                }
            } else if (type == 1) {
                this.eveCount += count;
            } else if (type == 2) {
                this.oddCount += count;
            } else if (type == 3) {
                this.eveIcount += count;
            } else if (type == 4){
                this.oddIcount += count;
            } else {
                this.inuCount += count;
            }

            this.totalCount = this.totalCount + count;
        }
    }
}
