package com.xzzn.ems.domain;

import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.xzzn.common.core.domain.BaseEntity;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import com.xzzn.common.annotation.Excel;

/**
 * 总数据对象 ems_ammeter_data
 *
 * @author xzzn
 * @date 2025-07-29
 */
public class EmsAmmeterData extends BaseEntity
{
    private static final long serialVersionUID = 1L;

    /**  */
    private Long id;

    /** 数据更新时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @Excel(name = "数据更新时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss")
    private Date dataUpdateTime;

    /** 当前组合有功总电能 */
    @Excel(name = "当前组合有功总电能")
    private BigDecimal currentCombActiveTotal;

    /** 当前组合有功尖电能 */
    @Excel(name = "当前组合有功尖电能")
    private BigDecimal currentCombActivePeak;

    /** 当前组合有功峰电能 */
    @Excel(name = "当前组合有功峰电能")
    private BigDecimal currentCombActiveHigh;

    /** 当前组合有功平电能 */
    @Excel(name = "当前组合有功平电能")
    private BigDecimal currentCombActiveFlat;

    /** 当前组合有功谷电能 */
    @Excel(name = "当前组合有功谷电能")
    private BigDecimal currentCombActiveValley;

    /** 当前正向总有功电能 */
    @Excel(name = "当前正向总有功电能")
    private BigDecimal currentForwardActiveTotal;

    /** 当前正向有功尖电能 */
    @Excel(name = "当前正向有功尖电能")
    private BigDecimal currentForwardActivePeak;

    /** 当前正向有功峰电能 */
    @Excel(name = "当前正向有功峰电能")
    private BigDecimal currentForwardActiveHigh;

    /** 当前正向有功平电能 */
    @Excel(name = "当前正向有功平电能")
    private BigDecimal currentForwardActiveFlat;

    /** 当前正向有功谷电能 */
    @Excel(name = "当前正向有功谷电能")
    private BigDecimal currentForwardActiveValley;

    /** 当前反向总有功电能 */
    @Excel(name = "当前反向总有功电能")
    private BigDecimal currentReverseActiveTotal;

    /** 当前反向有功尖电能 */
    @Excel(name = "当前反向有功尖电能")
    private BigDecimal currentReverseActivePeak;

    /** 当前反向有功峰电能 */
    @Excel(name = "当前反向有功峰电能")
    private BigDecimal currentReverseActiveHigh;

    /** 当前反向有功平电能 */
    @Excel(name = "当前反向有功平电能")
    private BigDecimal currentReverseActiveFlat;

    /** 当前反向有功谷电能 */
    @Excel(name = "当前反向有功谷电能")
    private BigDecimal currentReverseActiveValley;

    /** 当前组合无功总电能 */
    @Excel(name = "当前组合无功总电能")
    private BigDecimal currentCombReactiveTotal;

    /** 当前组合无功尖电能 */
    @Excel(name = "当前组合无功尖电能")
    private BigDecimal currentCombReactivePeak;

    /** 当前组合无功峰电能 */
    @Excel(name = "当前组合无功峰电能")
    private BigDecimal currentCombReactiveHigh;

    /** 当前组合无功平电能 */
    @Excel(name = "当前组合无功平电能")
    private BigDecimal currentCombReactiveFlat;

    /** 当前组合无功谷电能 */
    @Excel(name = "当前组合无功谷电能")
    private BigDecimal currentCombReactiveValley;

    /** 当前正向总无功电能 */
    @Excel(name = "当前正向总无功电能")
    private BigDecimal currentForwardReactiveTotal;

    /** 当前正向无功尖电能 */
    @Excel(name = "当前正向无功尖电能")
    private BigDecimal currentForwardReactivePeak;

    /** 当前正向无功峰电能 */
    @Excel(name = "当前正向无功峰电能")
    private BigDecimal currentForwardReactiveHigh;

    /** 当前正向无功平电能 */
    @Excel(name = "当前正向无功平电能")
    private BigDecimal currentForwardReactiveFlat;

    /** 当前正向无功谷电能 */
    @Excel(name = "当前正向无功谷电能")
    private BigDecimal currentForwardReactiveValley;

    /** 当前反向总无功电能 */
    @Excel(name = "当前反向总无功电能")
    private BigDecimal currentReverseReactiveTotal;

    /** 当前反向无功尖电能 */
    @Excel(name = "当前反向无功尖电能")
    private BigDecimal currentReverseReactivePeak;

    /** 当前反向无功峰电能 */
    @Excel(name = "当前反向无功峰电能")
    private BigDecimal currentReverseReactiveHigh;

    /** 当前反向无功平电能 */
    @Excel(name = "当前反向无功平电能")
    private BigDecimal currentReverseReactiveFlat;

    /** 当前反向无功谷电能 */
    @Excel(name = "当前反向无功谷电能")
    private BigDecimal currentReverseReactiveValley;

    /** A相电压 */
    @Excel(name = "A相电压")
    private BigDecimal phaseAVoltage;

    /** B相电压 */
    @Excel(name = "B相电压")
    private BigDecimal phaseBVoltage;

    /** C相电压 */
    @Excel(name = "C相电压")
    private BigDecimal phaseCVoltage;

    /** A相电流 */
    @Excel(name = "A相电流")
    private BigDecimal phaseACurrent;

    /** B相电流 */
    @Excel(name = "B相电流")
    private BigDecimal phaseBCurrent;

    /** C相电流 */
    @Excel(name = "C相电流")
    private BigDecimal phaseCCurrent;

    /** 频率 */
    @Excel(name = "频率")
    private BigDecimal frequency;

    /** A-B线电压 */
    @Excel(name = "A-B线电压")
    private BigDecimal abLineVoltage;

    /** C-B线电压 */
    @Excel(name = "C-B线电压")
    private BigDecimal cbLineVoltage;

    /** A-C线电压 */
    @Excel(name = "A-C线电压")
    private BigDecimal acLineVoltage;

    /** 正向有功最大需量 */
    @Excel(name = "正向有功最大需量")
    private BigDecimal forwardAcMaxDemand;

    /** 反向有功最大需量 */
    @Excel(name = "反向有功最大需量")
    private BigDecimal reverseAcMaxDemand;

    /** A相有功功率 */
    @Excel(name = "A相有功功率")
    private BigDecimal phaseAActivePower;

    /** B相有功功率 */
    @Excel(name = "B相有功功率")
    private BigDecimal phaseBActivePower;

    /** C相有功功率 */
    @Excel(name = "C相有功功率")
    private BigDecimal phaseCActivePower;

    /** 总有功功率 */
    @Excel(name = "总有功功率")
    private BigDecimal totalActivePower;

    /** A相无功功率 */
    @Excel(name = "A相无功功率")
    private BigDecimal phaseAReactivePower;

    /** B相无功功率 */
    @Excel(name = "B相无功功率")
    private BigDecimal phaseBReactivePower;

    /** C相无功功率 */
    @Excel(name = "C相无功功率")
    private BigDecimal phaseCReactivePower;

    /** 总无功功率 */
    @Excel(name = "总无功功率")
    private BigDecimal totalReactivePower;

    /** A相视在功率 */
    @Excel(name = "A相视在功率")
    private BigDecimal phaseAApparentPower;

    /** B相视在功率 */
    @Excel(name = "B相视在功率")
    private BigDecimal phaseBApparentPower;

    /** C相视在功率 */
    @Excel(name = "C相视在功率")
    private BigDecimal phaseCApparentPower;

    /** 总视在功率 */
    @Excel(name = "总视在功率")
    private BigDecimal totalApparentPower;

    /** A相功率因数 */
    @Excel(name = "A相功率因数")
    private BigDecimal phaseAPowerFactor;

    /** B相功率因数 */
    @Excel(name = "B相功率因数")
    private BigDecimal phaseBPowerFactor;

    /** C相功率因数 */
    @Excel(name = "C相功率因数")
    private BigDecimal phaseCPowerFactor;

    /** 总功率因数 */
    @Excel(name = "总功率因数")
    private BigDecimal totalPowerFactor;

    /** 当日正向有功最大需量 */
    @Excel(name = "当日正向有功最大需量")
    private BigDecimal dailyForwardMaxDemand;

    /** 站点id */
    @Excel(name = "站点id")
    private String siteId;

    /** 设备唯一标识符 */
    @Excel(name = "设备唯一标识符")
    private String deviceId;

    /** 二次-AB 线电压 */
    @Excel(name = "二次-AB 线电压")
    private BigDecimal secondaryAbLineVoltage;

    /** 二次-A 相电流 */
    @Excel(name = "二次-A 相电流")
    private BigDecimal secondaryAPhaseCurrent;

    /** 二次-A 相电压 */
    @Excel(name = "二次-A 相电压")
    private BigDecimal secondaryAPhaseVoltage;

    /** 二次-A 相功率因数 */
    @Excel(name = "二次-A 相功率因数")
    private BigDecimal secondaryAPowerFactor;

    /** 二次-A 相视在功率 */
    @Excel(name = "二次-A 相视在功率")
    private BigDecimal secondaryAApparentPower;

    /** 二次-A 相无功功率 */
    @Excel(name = "二次-A 相无功功率")
    private BigDecimal secondaryAReactivePower;

    /** 二次-A 相有功功率 */
    @Excel(name = "二次-A 相有功功率")
    private BigDecimal secondaryAActivePower;

    /** 二次-BC 线电压 */
    @Excel(name = "二次-BC 线电压")
    private BigDecimal secondaryBcLineVoltage;

    /** 二次-B 相电流 */
    @Excel(name = "二次-B 相电流")
    private BigDecimal secondaryBPhaseCurrent;

    /** 二次-B 相电压 */
    @Excel(name = "二次-B 相电压")
    private BigDecimal secondaryBPhaseVoltage;

    /** 二次-B 相功率因数 */
    @Excel(name = "二次-B 相功率因数")
    private BigDecimal secondaryBPowerFactor;

    /** 二次-B 相视在功率 */
    @Excel(name = "二次-B 相视在功率")
    private BigDecimal secondaryBApparentPower;

    /** 二次-B 相无功功率 */
    @Excel(name = "二次-B 相无功功率")
    private BigDecimal secondaryBReactivePower;

    /** 二次-B 相有功功率 */
    @Excel(name = "二次-B 相有功功率")
    private BigDecimal secondaryBActivePower;

    /** 二次-CA 线电压 */
    @Excel(name = "二次-CA 线电压")
    private BigDecimal secondaryCaLineVoltage;

    /** 二次-C 相电流 */
    @Excel(name = "二次-C 相电流")
    private BigDecimal secondaryCPhaseCurrent;

    /** 二次-C 相电压 */
    @Excel(name = "二次-C 相电压")
    private BigDecimal secondaryCPhaseVoltage;

    /** 二次-C 相功率因数 */
    @Excel(name = "二次-C 相功率因数")
    private BigDecimal secondaryCPowerFactor;

    /** 二次-C 相视在功率 */
    @Excel(name = "二次-C 相视在功率")
    private BigDecimal secondaryCApparentPower;

    /** 二次-C 相无功功率 */
    @Excel(name = "二次-C 相无功功率")
    private BigDecimal secondaryCReactivePower;

    /** 二次-C 相有功功率 */
    @Excel(name = "二次-C 相有功功率")
    private BigDecimal secondaryCActivePower;

    /** 二次-电网频率 */
    @Excel(name = "二次-电网频率")
    private BigDecimal secondaryGridFrequency;

    /** 二次-反向无功电能 */
    @Excel(name = "二次-反向无功电能")
    private BigDecimal secondaryReverseReactiveEnergy;

    /** 二次-负向有功电能 */
    @Excel(name = "二次-负向有功电能")
    private BigDecimal secondaryNegativeActiveEnergy;

    /** 二次-总功率因数 */
    @Excel(name = "二次-总功率因数")
    private BigDecimal secondaryTotalPowerFactor;

    /** 二次-总视在功率 */
    @Excel(name = "二次-总视在功率")
    private BigDecimal secondaryTotalApparentPower;

    /** 二次-总无功功率 */
    @Excel(name = "二次-总无功功率")
    private BigDecimal secondaryTotalReactivePower;

    /** 二次-正向无功电能 */
    @Excel(name = "二次-正向无功电能")
    private BigDecimal secondaryPositiveReactiveEnergy;

    /** 二次-正向有功电能 */
    @Excel(name = "二次-正向有功电能")
    private BigDecimal secondaryPositiveActiveEnergy;

    /** 二次-总有功功率 */
    @Excel(name = "二次-总有功功率")
    private BigDecimal secondaryTotalActivePower;

    /** 反向无功电能 EQ- */
    @Excel(name = "反向无功电能 EQ-")
    private BigDecimal reverseReactiveEnergyEqMinus;

    /** 反向有功电能 EP- */
    @Excel(name = "反向有功电能 EP-")
    private BigDecimal reverseActiveEnergyEpMinus;

    /** 正向无功电能 EQ+ */
    @Excel(name = "正向无功电能 EQ+")
    private BigDecimal positiveReactiveEnergyEqPlus;

    /** 正向有功电能 EP+ */
    @Excel(name = "正向有功电能 EP+")
    private BigDecimal positiveActiveEnergyEpPlus;

    /** 电流变比 */
    @Excel(name = "电流变比")
    private BigDecimal currentPercent;

    /** 电压变比 */
    @Excel(name = "电压变比")
    private BigDecimal voltagePercent;

    /** 平均电流 */
    @Excel(name = "平均电流")
    private BigDecimal avgCurrent;

    /** 总正向有功电能2 */
    @Excel(name = "总正向有功电能2")
    private BigDecimal totalForwardActiveTwo;

    /** 总尖正向有功电能 */
    @Excel(name = "总尖正向有功电能")
    private BigDecimal totalPeakForwardActive;

    /** 总峰正向有功电能 */
    @Excel(name = "总峰正向有功电能")
    private BigDecimal totalHighForwardActive;

    /** 总平正向有功电能 */
    @Excel(name = "总平正向有功电能")
    private BigDecimal totalFlatForwardActive;

    /** 总谷正向有功电能 */
    @Excel(name = "总谷正向有功电能")
    private BigDecimal totalValleyForwardActive;

    /** 总反向有功电能2 */
    @Excel(name = "总反向有功电能2")
    private BigDecimal totalReverseActiveTwo;

    /** 总尖反向有功电能 */
    @Excel(name = "总尖反向有功电能")
    private BigDecimal totalPeakReverseActive;

    /** 总峰反向有功电能 */
    @Excel(name = "总峰反向有功电能")
    private BigDecimal totalHighReverseActive;

    /** 总平反向有功电能 */
    @Excel(name = "总平反向有功电能")
    private BigDecimal totalFlatReverseActive;

    /** 总谷反向有功电能 */
    @Excel(name = "总谷反向有功电能")
    private BigDecimal totalValleyReverseActive;

    /** 断线检测指示 */
    @Excel(name = "断线检测指示")
    private String disconnectDetectionIndication;

    /** 额定一次电流值 */
    @Excel(name = "额定一次电流值")
    private BigDecimal ratedPrimaryCurrentValue;

    /** 开关量输入输出状态 */
    @Excel(name = "开关量输入输出状态")
    private String switchInputOutputStatus;

    /** 报警状态 */
    @Excel(name = "报警状态")
    private String alarmStatus;

    /** 当前总电压百分比 */
    @Excel(name = "当前总电压百分比")
    private BigDecimal currentTotalVoltagePercent;

    /** 电压直流含量百分比 */
    @Excel(name = "电压直流含量百分比")
    private BigDecimal voltageContentPercent;

    /** 电压交流含量百分比 */
    @Excel(name = "电压交流含量百分比")
    private BigDecimal voltageAcPercent;

    /** 当前总电流百分比 */
    @Excel(name = "当前总电流百分比")
    private BigDecimal currentTotalCurrentPercent;

    /** 电流直流含量百分比 */
    @Excel(name = "电流直流含量百分比")
    private BigDecimal currentContentPercent;

    /** 电流交流含量百分比 */
    @Excel(name = "电流交流含量百分比")
    private BigDecimal currentAcPercent;

    /** 当前总功率百分比 */
    @Excel(name = "当前总功率百分比")
    private BigDecimal currentTotalPowerPercent;

    /** 功率直流含量百分比 */
    @Excel(name = "功率直流含量百分比")
    private BigDecimal powerContentPercent;

    /** 功率交流含量百分比 */
    @Excel(name = "功率交流含量百分比")
    private BigDecimal powerAcPercent;

    /** 日期时间设置（年月） */
    @Excel(name = "日期时间设置", readConverterExp = "年=月")
    private String dataSettingYearMonth;

    /** 日期时间设置（日时） */
    @Excel(name = "日期时间设置", readConverterExp = "日=时")
    private String dataSettingDayHour;

    /** 日期时间设置（分秒） */
    @Excel(name = "日期时间设置", readConverterExp = "分=秒")
    private String dataSettingMinutesSeconds;

    /** 当前抄表日（高）、当前费率（低） */
    @Excel(name = "当前抄表日", readConverterExp = "高=")
    private BigDecimal currentRate;

    /** 软件版本号 */
    @Excel(name = "软件版本号")
    private String versionNumber;

    /** 电压 */
    @Excel(name = "电压")
    private BigDecimal voltage;

    /** 电流 */
    @Excel(name = "电流")
    private BigDecimal current;

    /** 功率 */
    @Excel(name = "功率")
    private BigDecimal power;

    /** 内部温度 */
    @Excel(name = "内部温度")
    private BigDecimal internalTemp;

    /** 总正向有功电能1 */
    @Excel(name = "总正向有功电能1")
    private BigDecimal totalForwardActiveOne;

    /** 总反向有功电能1 */
    @Excel(name = "总反向有功电能1")
    private BigDecimal totalReverseActiveOne;

    /** 正向无功最大需量 */
    @Excel(name = "正向无功最大需量")
    private BigDecimal forwardReactiveMaxDemand;

    /** 反向无功最大需量 */
    @Excel(name = "反向无功最大需量")
    private BigDecimal reverseReactiveMaxDemand;

    /** A 相正向有功电能 */
    @Excel(name = "A 相正向有功电能")
    private BigDecimal aForwardActiveEnergy;

    /** B 相正向有功电能 */
    @Excel(name = "B 相正向有功电能")
    private BigDecimal bForwardActiveEnergy;

    /** C 相正向有功电能 */
    @Excel(name = "C 相正向有功电能")
    private BigDecimal cForwardActiveEnergy;

    /** DIDO 状态、失压状态 */
    @Excel(name = "DIDO 状态、失压状态")
    private String didoStatus;

    /** 运行状态 1（高 8 位）/运行状态 2（低 8 位） */
    @Excel(name = "运行状态 1", readConverterExp = "高=,8=,位=")
    private String runningStatus;

    /** 零序电流 */
    @Excel(name = "零序电流")
    private BigDecimal zeroSeqCurrent;

    /** 电压不平衡度 */
    @Excel(name = "电压不平衡度")
    private BigDecimal voltageUnbalanceDegree;

    /** 电流不平衡度 */
    @Excel(name = "电流不平衡度")
    private BigDecimal currentUnbalanceDegree;

    /** 当日反向有功最大需量 */
    @Excel(name = "当日反向有功最大需量")
    private BigDecimal dailyReverseAcMaxDemand;

    /** 当日正向无功最大需量 */
    @Excel(name = "当日正向无功最大需量")
    private BigDecimal dailyForwardReacMaxDemand;

    /** 当日反向无功最大需量 */
    @Excel(name = "当日反向无功最大需量")
    private BigDecimal dailyReverseReacMaxDemand;

    /** 上 1 日正向有功最大需量 */
    @Excel(name = "上 1 日正向有功最大需量")
    private BigDecimal preDayForwardAcMaxDemand;

    /** 上 1 日反向有功最大需量 */
    @Excel(name = "上 1 日反向有功最大需量")
    private BigDecimal preDayReverseAcMaxDemand;

    /** 上 1 日正向无功最大需量 */
    @Excel(name = "上 1 日正向无功最大需量")
    private BigDecimal preDayForwardReacMaxDemand;

    /** 上 1 日反向无功最大需量 */
    @Excel(name = "上 1 日反向无功最大需量")
    private BigDecimal preDayReverseReacMaxDemand;

    /** 上 2 日正向有功最大需量 */
    @Excel(name = "上 2 日正向有功最大需量")
    private BigDecimal pre2dForwardAcMaxDemand;

    /** 上 2 日反向有功最大需量 */
    @Excel(name = "上 2 日反向有功最大需量")
    private BigDecimal pre2dReverseAcMaxDemand;

    /** 上 2 日正向无功最大需量 */
    @Excel(name = "上 2 日正向无功最大需量")
    private BigDecimal pre2dForwardReacMaxDemand;

    /** 上 2 日反向无功最大需量 */
    @Excel(name = "上 2 日反向无功最大需量")
    private BigDecimal pre2dReverseReacMaxDemand;

    /** 当前正向有功需量 */
    @Excel(name = "当前正向有功需量")
    private BigDecimal currentForwardAcDemand;

    /** 当前反向有功需量 */
    @Excel(name = "当前反向有功需量")
    private BigDecimal currentReverseAcDemand;

    /** 当前正向无功需量 */
    @Excel(name = "当前正向无功需量")
    private BigDecimal currentForwardReacDemand;

    /** 当前反向无功需量 */
    @Excel(name = "当前反向无功需量")
    private BigDecimal currentReverseReacDemand;

    public void setId(Long id)
    {
        this.id = id;
    }

    public Long getId()
    {
        return id;
    }

    public void setDataUpdateTime(Date dataUpdateTime)
    {
        this.dataUpdateTime = dataUpdateTime;
    }

    public Date getDataUpdateTime()
    {
        return dataUpdateTime;
    }

    public void setCurrentCombActiveTotal(BigDecimal currentCombActiveTotal)
    {
        this.currentCombActiveTotal = currentCombActiveTotal;
    }

    public BigDecimal getCurrentCombActiveTotal()
    {
        return currentCombActiveTotal;
    }

    public void setCurrentCombActivePeak(BigDecimal currentCombActivePeak)
    {
        this.currentCombActivePeak = currentCombActivePeak;
    }

    public BigDecimal getCurrentCombActivePeak()
    {
        return currentCombActivePeak;
    }

    public void setCurrentCombActiveHigh(BigDecimal currentCombActiveHigh)
    {
        this.currentCombActiveHigh = currentCombActiveHigh;
    }

    public BigDecimal getCurrentCombActiveHigh()
    {
        return currentCombActiveHigh;
    }

    public void setCurrentCombActiveFlat(BigDecimal currentCombActiveFlat)
    {
        this.currentCombActiveFlat = currentCombActiveFlat;
    }

    public BigDecimal getCurrentCombActiveFlat()
    {
        return currentCombActiveFlat;
    }

    public void setCurrentCombActiveValley(BigDecimal currentCombActiveValley)
    {
        this.currentCombActiveValley = currentCombActiveValley;
    }

    public BigDecimal getCurrentCombActiveValley()
    {
        return currentCombActiveValley;
    }

    public void setCurrentForwardActiveTotal(BigDecimal currentForwardActiveTotal)
    {
        this.currentForwardActiveTotal = currentForwardActiveTotal;
    }

    public BigDecimal getCurrentForwardActiveTotal()
    {
        return currentForwardActiveTotal;
    }

    public void setCurrentForwardActivePeak(BigDecimal currentForwardActivePeak)
    {
        this.currentForwardActivePeak = currentForwardActivePeak;
    }

    public BigDecimal getCurrentForwardActivePeak()
    {
        return currentForwardActivePeak;
    }

    public void setCurrentForwardActiveHigh(BigDecimal currentForwardActiveHigh)
    {
        this.currentForwardActiveHigh = currentForwardActiveHigh;
    }

    public BigDecimal getCurrentForwardActiveHigh()
    {
        return currentForwardActiveHigh;
    }

    public void setCurrentForwardActiveFlat(BigDecimal currentForwardActiveFlat)
    {
        this.currentForwardActiveFlat = currentForwardActiveFlat;
    }

    public BigDecimal getCurrentForwardActiveFlat()
    {
        return currentForwardActiveFlat;
    }

    public void setCurrentForwardActiveValley(BigDecimal currentForwardActiveValley)
    {
        this.currentForwardActiveValley = currentForwardActiveValley;
    }

    public BigDecimal getCurrentForwardActiveValley()
    {
        return currentForwardActiveValley;
    }

    public void setCurrentReverseActiveTotal(BigDecimal currentReverseActiveTotal)
    {
        this.currentReverseActiveTotal = currentReverseActiveTotal;
    }

    public BigDecimal getCurrentReverseActiveTotal()
    {
        return currentReverseActiveTotal;
    }

    public void setCurrentReverseActivePeak(BigDecimal currentReverseActivePeak)
    {
        this.currentReverseActivePeak = currentReverseActivePeak;
    }

    public BigDecimal getCurrentReverseActivePeak()
    {
        return currentReverseActivePeak;
    }

    public void setCurrentReverseActiveHigh(BigDecimal currentReverseActiveHigh)
    {
        this.currentReverseActiveHigh = currentReverseActiveHigh;
    }

    public BigDecimal getCurrentReverseActiveHigh()
    {
        return currentReverseActiveHigh;
    }

    public void setCurrentReverseActiveFlat(BigDecimal currentReverseActiveFlat)
    {
        this.currentReverseActiveFlat = currentReverseActiveFlat;
    }

    public BigDecimal getCurrentReverseActiveFlat()
    {
        return currentReverseActiveFlat;
    }

    public void setCurrentReverseActiveValley(BigDecimal currentReverseActiveValley)
    {
        this.currentReverseActiveValley = currentReverseActiveValley;
    }

    public BigDecimal getCurrentReverseActiveValley()
    {
        return currentReverseActiveValley;
    }

    public void setCurrentCombReactiveTotal(BigDecimal currentCombReactiveTotal)
    {
        this.currentCombReactiveTotal = currentCombReactiveTotal;
    }

    public BigDecimal getCurrentCombReactiveTotal()
    {
        return currentCombReactiveTotal;
    }

    public void setCurrentCombReactivePeak(BigDecimal currentCombReactivePeak)
    {
        this.currentCombReactivePeak = currentCombReactivePeak;
    }

    public BigDecimal getCurrentCombReactivePeak()
    {
        return currentCombReactivePeak;
    }

    public void setCurrentCombReactiveHigh(BigDecimal currentCombReactiveHigh)
    {
        this.currentCombReactiveHigh = currentCombReactiveHigh;
    }

    public BigDecimal getCurrentCombReactiveHigh()
    {
        return currentCombReactiveHigh;
    }

    public void setCurrentCombReactiveFlat(BigDecimal currentCombReactiveFlat)
    {
        this.currentCombReactiveFlat = currentCombReactiveFlat;
    }

    public BigDecimal getCurrentCombReactiveFlat()
    {
        return currentCombReactiveFlat;
    }

    public void setCurrentCombReactiveValley(BigDecimal currentCombReactiveValley)
    {
        this.currentCombReactiveValley = currentCombReactiveValley;
    }

    public BigDecimal getCurrentCombReactiveValley()
    {
        return currentCombReactiveValley;
    }

    public void setCurrentForwardReactiveTotal(BigDecimal currentForwardReactiveTotal)
    {
        this.currentForwardReactiveTotal = currentForwardReactiveTotal;
    }

    public BigDecimal getCurrentForwardReactiveTotal()
    {
        return currentForwardReactiveTotal;
    }

    public void setCurrentForwardReactivePeak(BigDecimal currentForwardReactivePeak)
    {
        this.currentForwardReactivePeak = currentForwardReactivePeak;
    }

    public BigDecimal getCurrentForwardReactivePeak()
    {
        return currentForwardReactivePeak;
    }

    public void setCurrentForwardReactiveHigh(BigDecimal currentForwardReactiveHigh)
    {
        this.currentForwardReactiveHigh = currentForwardReactiveHigh;
    }

    public BigDecimal getCurrentForwardReactiveHigh()
    {
        return currentForwardReactiveHigh;
    }

    public void setCurrentForwardReactiveFlat(BigDecimal currentForwardReactiveFlat)
    {
        this.currentForwardReactiveFlat = currentForwardReactiveFlat;
    }

    public BigDecimal getCurrentForwardReactiveFlat()
    {
        return currentForwardReactiveFlat;
    }

    public void setCurrentForwardReactiveValley(BigDecimal currentForwardReactiveValley)
    {
        this.currentForwardReactiveValley = currentForwardReactiveValley;
    }

    public BigDecimal getCurrentForwardReactiveValley()
    {
        return currentForwardReactiveValley;
    }

    public void setCurrentReverseReactiveTotal(BigDecimal currentReverseReactiveTotal)
    {
        this.currentReverseReactiveTotal = currentReverseReactiveTotal;
    }

    public BigDecimal getCurrentReverseReactiveTotal()
    {
        return currentReverseReactiveTotal;
    }

    public void setCurrentReverseReactivePeak(BigDecimal currentReverseReactivePeak)
    {
        this.currentReverseReactivePeak = currentReverseReactivePeak;
    }

    public BigDecimal getCurrentReverseReactivePeak()
    {
        return currentReverseReactivePeak;
    }

    public void setCurrentReverseReactiveHigh(BigDecimal currentReverseReactiveHigh)
    {
        this.currentReverseReactiveHigh = currentReverseReactiveHigh;
    }

    public BigDecimal getCurrentReverseReactiveHigh()
    {
        return currentReverseReactiveHigh;
    }

    public void setCurrentReverseReactiveFlat(BigDecimal currentReverseReactiveFlat)
    {
        this.currentReverseReactiveFlat = currentReverseReactiveFlat;
    }

    public BigDecimal getCurrentReverseReactiveFlat()
    {
        return currentReverseReactiveFlat;
    }

    public void setCurrentReverseReactiveValley(BigDecimal currentReverseReactiveValley)
    {
        this.currentReverseReactiveValley = currentReverseReactiveValley;
    }

    public BigDecimal getCurrentReverseReactiveValley()
    {
        return currentReverseReactiveValley;
    }

    public void setPhaseAVoltage(BigDecimal phaseAVoltage)
    {
        this.phaseAVoltage = phaseAVoltage;
    }

    public BigDecimal getPhaseAVoltage()
    {
        return phaseAVoltage;
    }

    public void setPhaseBVoltage(BigDecimal phaseBVoltage)
    {
        this.phaseBVoltage = phaseBVoltage;
    }

    public BigDecimal getPhaseBVoltage()
    {
        return phaseBVoltage;
    }

    public void setPhaseCVoltage(BigDecimal phaseCVoltage)
    {
        this.phaseCVoltage = phaseCVoltage;
    }

    public BigDecimal getPhaseCVoltage()
    {
        return phaseCVoltage;
    }

    public void setPhaseACurrent(BigDecimal phaseACurrent)
    {
        this.phaseACurrent = phaseACurrent;
    }

    public BigDecimal getPhaseACurrent()
    {
        return phaseACurrent;
    }

    public void setPhaseBCurrent(BigDecimal phaseBCurrent)
    {
        this.phaseBCurrent = phaseBCurrent;
    }

    public BigDecimal getPhaseBCurrent()
    {
        return phaseBCurrent;
    }

    public void setPhaseCCurrent(BigDecimal phaseCCurrent)
    {
        this.phaseCCurrent = phaseCCurrent;
    }

    public BigDecimal getPhaseCCurrent()
    {
        return phaseCCurrent;
    }

    public void setFrequency(BigDecimal frequency)
    {
        this.frequency = frequency;
    }

    public BigDecimal getFrequency()
    {
        return frequency;
    }

    public void setAbLineVoltage(BigDecimal abLineVoltage)
    {
        this.abLineVoltage = abLineVoltage;
    }

    public BigDecimal getAbLineVoltage()
    {
        return abLineVoltage;
    }

    public void setCbLineVoltage(BigDecimal cbLineVoltage)
    {
        this.cbLineVoltage = cbLineVoltage;
    }

    public BigDecimal getCbLineVoltage()
    {
        return cbLineVoltage;
    }

    public void setAcLineVoltage(BigDecimal acLineVoltage)
    {
        this.acLineVoltage = acLineVoltage;
    }

    public BigDecimal getAcLineVoltage()
    {
        return acLineVoltage;
    }

    public void setForwardAcMaxDemand(BigDecimal forwardAcMaxDemand)
    {
        this.forwardAcMaxDemand = forwardAcMaxDemand;
    }

    public BigDecimal getForwardAcMaxDemand()
    {
        return forwardAcMaxDemand;
    }

    public void setReverseAcMaxDemand(BigDecimal reverseAcMaxDemand)
    {
        this.reverseAcMaxDemand = reverseAcMaxDemand;
    }

    public BigDecimal getReverseAcMaxDemand()
    {
        return reverseAcMaxDemand;
    }

    public void setPhaseAActivePower(BigDecimal phaseAActivePower)
    {
        this.phaseAActivePower = phaseAActivePower;
    }

    public BigDecimal getPhaseAActivePower()
    {
        return phaseAActivePower;
    }

    public void setPhaseBActivePower(BigDecimal phaseBActivePower)
    {
        this.phaseBActivePower = phaseBActivePower;
    }

    public BigDecimal getPhaseBActivePower()
    {
        return phaseBActivePower;
    }

    public void setPhaseCActivePower(BigDecimal phaseCActivePower)
    {
        this.phaseCActivePower = phaseCActivePower;
    }

    public BigDecimal getPhaseCActivePower()
    {
        return phaseCActivePower;
    }

    public void setTotalActivePower(BigDecimal totalActivePower)
    {
        this.totalActivePower = totalActivePower;
    }

    public BigDecimal getTotalActivePower()
    {
        return totalActivePower;
    }

    public void setPhaseAReactivePower(BigDecimal phaseAReactivePower)
    {
        this.phaseAReactivePower = phaseAReactivePower;
    }

    public BigDecimal getPhaseAReactivePower()
    {
        return phaseAReactivePower;
    }

    public void setPhaseBReactivePower(BigDecimal phaseBReactivePower)
    {
        this.phaseBReactivePower = phaseBReactivePower;
    }

    public BigDecimal getPhaseBReactivePower()
    {
        return phaseBReactivePower;
    }

    public void setPhaseCReactivePower(BigDecimal phaseCReactivePower)
    {
        this.phaseCReactivePower = phaseCReactivePower;
    }

    public BigDecimal getPhaseCReactivePower()
    {
        return phaseCReactivePower;
    }

    public void setTotalReactivePower(BigDecimal totalReactivePower)
    {
        this.totalReactivePower = totalReactivePower;
    }

    public BigDecimal getTotalReactivePower()
    {
        return totalReactivePower;
    }

    public void setPhaseAApparentPower(BigDecimal phaseAApparentPower)
    {
        this.phaseAApparentPower = phaseAApparentPower;
    }

    public BigDecimal getPhaseAApparentPower()
    {
        return phaseAApparentPower;
    }

    public void setPhaseBApparentPower(BigDecimal phaseBApparentPower)
    {
        this.phaseBApparentPower = phaseBApparentPower;
    }

    public BigDecimal getPhaseBApparentPower()
    {
        return phaseBApparentPower;
    }

    public void setPhaseCApparentPower(BigDecimal phaseCApparentPower)
    {
        this.phaseCApparentPower = phaseCApparentPower;
    }

    public BigDecimal getPhaseCApparentPower()
    {
        return phaseCApparentPower;
    }

    public void setTotalApparentPower(BigDecimal totalApparentPower)
    {
        this.totalApparentPower = totalApparentPower;
    }

    public BigDecimal getTotalApparentPower()
    {
        return totalApparentPower;
    }

    public void setPhaseAPowerFactor(BigDecimal phaseAPowerFactor)
    {
        this.phaseAPowerFactor = phaseAPowerFactor;
    }

    public BigDecimal getPhaseAPowerFactor()
    {
        return phaseAPowerFactor;
    }

    public void setPhaseBPowerFactor(BigDecimal phaseBPowerFactor)
    {
        this.phaseBPowerFactor = phaseBPowerFactor;
    }

    public BigDecimal getPhaseBPowerFactor()
    {
        return phaseBPowerFactor;
    }

    public void setPhaseCPowerFactor(BigDecimal phaseCPowerFactor)
    {
        this.phaseCPowerFactor = phaseCPowerFactor;
    }

    public BigDecimal getPhaseCPowerFactor()
    {
        return phaseCPowerFactor;
    }

    public void setTotalPowerFactor(BigDecimal totalPowerFactor)
    {
        this.totalPowerFactor = totalPowerFactor;
    }

    public BigDecimal getTotalPowerFactor()
    {
        return totalPowerFactor;
    }

    public void setDailyForwardMaxDemand(BigDecimal dailyForwardMaxDemand)
    {
        this.dailyForwardMaxDemand = dailyForwardMaxDemand;
    }

    public BigDecimal getDailyForwardMaxDemand()
    {
        return dailyForwardMaxDemand;
    }

    public void setSiteId(String siteId)
    {
        this.siteId = siteId;
    }

    public String getSiteId()
    {
        return siteId;
    }

    public void setDeviceId(String deviceId)
    {
        this.deviceId = deviceId;
    }

    public String getDeviceId()
    {
        return deviceId;
    }

    public void setSecondaryAbLineVoltage(BigDecimal secondaryAbLineVoltage)
    {
        this.secondaryAbLineVoltage = secondaryAbLineVoltage;
    }

    public BigDecimal getSecondaryAbLineVoltage()
    {
        return secondaryAbLineVoltage;
    }

    public void setSecondaryAPhaseCurrent(BigDecimal secondaryAPhaseCurrent)
    {
        this.secondaryAPhaseCurrent = secondaryAPhaseCurrent;
    }

    public BigDecimal getSecondaryAPhaseCurrent()
    {
        return secondaryAPhaseCurrent;
    }

    public void setSecondaryAPhaseVoltage(BigDecimal secondaryAPhaseVoltage)
    {
        this.secondaryAPhaseVoltage = secondaryAPhaseVoltage;
    }

    public BigDecimal getSecondaryAPhaseVoltage()
    {
        return secondaryAPhaseVoltage;
    }

    public void setSecondaryAPowerFactor(BigDecimal secondaryAPowerFactor)
    {
        this.secondaryAPowerFactor = secondaryAPowerFactor;
    }

    public BigDecimal getSecondaryAPowerFactor()
    {
        return secondaryAPowerFactor;
    }

    public void setSecondaryAApparentPower(BigDecimal secondaryAApparentPower)
    {
        this.secondaryAApparentPower = secondaryAApparentPower;
    }

    public BigDecimal getSecondaryAApparentPower()
    {
        return secondaryAApparentPower;
    }

    public void setSecondaryAReactivePower(BigDecimal secondaryAReactivePower)
    {
        this.secondaryAReactivePower = secondaryAReactivePower;
    }

    public BigDecimal getSecondaryAReactivePower()
    {
        return secondaryAReactivePower;
    }

    public void setSecondaryAActivePower(BigDecimal secondaryAActivePower)
    {
        this.secondaryAActivePower = secondaryAActivePower;
    }

    public BigDecimal getSecondaryAActivePower()
    {
        return secondaryAActivePower;
    }

    public void setSecondaryBcLineVoltage(BigDecimal secondaryBcLineVoltage)
    {
        this.secondaryBcLineVoltage = secondaryBcLineVoltage;
    }

    public BigDecimal getSecondaryBcLineVoltage()
    {
        return secondaryBcLineVoltage;
    }

    public void setSecondaryBPhaseCurrent(BigDecimal secondaryBPhaseCurrent)
    {
        this.secondaryBPhaseCurrent = secondaryBPhaseCurrent;
    }

    public BigDecimal getSecondaryBPhaseCurrent()
    {
        return secondaryBPhaseCurrent;
    }

    public void setSecondaryBPhaseVoltage(BigDecimal secondaryBPhaseVoltage)
    {
        this.secondaryBPhaseVoltage = secondaryBPhaseVoltage;
    }

    public BigDecimal getSecondaryBPhaseVoltage()
    {
        return secondaryBPhaseVoltage;
    }

    public void setSecondaryBPowerFactor(BigDecimal secondaryBPowerFactor)
    {
        this.secondaryBPowerFactor = secondaryBPowerFactor;
    }

    public BigDecimal getSecondaryBPowerFactor()
    {
        return secondaryBPowerFactor;
    }

    public void setSecondaryBApparentPower(BigDecimal secondaryBApparentPower)
    {
        this.secondaryBApparentPower = secondaryBApparentPower;
    }

    public BigDecimal getSecondaryBApparentPower()
    {
        return secondaryBApparentPower;
    }

    public void setSecondaryBReactivePower(BigDecimal secondaryBReactivePower)
    {
        this.secondaryBReactivePower = secondaryBReactivePower;
    }

    public BigDecimal getSecondaryBReactivePower()
    {
        return secondaryBReactivePower;
    }

    public void setSecondaryBActivePower(BigDecimal secondaryBActivePower)
    {
        this.secondaryBActivePower = secondaryBActivePower;
    }

    public BigDecimal getSecondaryBActivePower()
    {
        return secondaryBActivePower;
    }

    public void setSecondaryCaLineVoltage(BigDecimal secondaryCaLineVoltage)
    {
        this.secondaryCaLineVoltage = secondaryCaLineVoltage;
    }

    public BigDecimal getSecondaryCaLineVoltage()
    {
        return secondaryCaLineVoltage;
    }

    public void setSecondaryCPhaseCurrent(BigDecimal secondaryCPhaseCurrent)
    {
        this.secondaryCPhaseCurrent = secondaryCPhaseCurrent;
    }

    public BigDecimal getSecondaryCPhaseCurrent()
    {
        return secondaryCPhaseCurrent;
    }

    public void setSecondaryCPhaseVoltage(BigDecimal secondaryCPhaseVoltage)
    {
        this.secondaryCPhaseVoltage = secondaryCPhaseVoltage;
    }

    public BigDecimal getSecondaryCPhaseVoltage()
    {
        return secondaryCPhaseVoltage;
    }

    public void setSecondaryCPowerFactor(BigDecimal secondaryCPowerFactor)
    {
        this.secondaryCPowerFactor = secondaryCPowerFactor;
    }

    public BigDecimal getSecondaryCPowerFactor()
    {
        return secondaryCPowerFactor;
    }

    public void setSecondaryCApparentPower(BigDecimal secondaryCApparentPower)
    {
        this.secondaryCApparentPower = secondaryCApparentPower;
    }

    public BigDecimal getSecondaryCApparentPower()
    {
        return secondaryCApparentPower;
    }

    public void setSecondaryCReactivePower(BigDecimal secondaryCReactivePower)
    {
        this.secondaryCReactivePower = secondaryCReactivePower;
    }

    public BigDecimal getSecondaryCReactivePower()
    {
        return secondaryCReactivePower;
    }

    public void setSecondaryCActivePower(BigDecimal secondaryCActivePower)
    {
        this.secondaryCActivePower = secondaryCActivePower;
    }

    public BigDecimal getSecondaryCActivePower()
    {
        return secondaryCActivePower;
    }

    public void setSecondaryGridFrequency(BigDecimal secondaryGridFrequency)
    {
        this.secondaryGridFrequency = secondaryGridFrequency;
    }

    public BigDecimal getSecondaryGridFrequency()
    {
        return secondaryGridFrequency;
    }

    public void setSecondaryReverseReactiveEnergy(BigDecimal secondaryReverseReactiveEnergy)
    {
        this.secondaryReverseReactiveEnergy = secondaryReverseReactiveEnergy;
    }

    public BigDecimal getSecondaryReverseReactiveEnergy()
    {
        return secondaryReverseReactiveEnergy;
    }

    public void setSecondaryNegativeActiveEnergy(BigDecimal secondaryNegativeActiveEnergy)
    {
        this.secondaryNegativeActiveEnergy = secondaryNegativeActiveEnergy;
    }

    public BigDecimal getSecondaryNegativeActiveEnergy()
    {
        return secondaryNegativeActiveEnergy;
    }

    public void setSecondaryTotalPowerFactor(BigDecimal secondaryTotalPowerFactor)
    {
        this.secondaryTotalPowerFactor = secondaryTotalPowerFactor;
    }

    public BigDecimal getSecondaryTotalPowerFactor()
    {
        return secondaryTotalPowerFactor;
    }

    public void setSecondaryTotalApparentPower(BigDecimal secondaryTotalApparentPower)
    {
        this.secondaryTotalApparentPower = secondaryTotalApparentPower;
    }

    public BigDecimal getSecondaryTotalApparentPower()
    {
        return secondaryTotalApparentPower;
    }

    public void setSecondaryTotalReactivePower(BigDecimal secondaryTotalReactivePower)
    {
        this.secondaryTotalReactivePower = secondaryTotalReactivePower;
    }

    public BigDecimal getSecondaryTotalReactivePower()
    {
        return secondaryTotalReactivePower;
    }

    public void setSecondaryPositiveReactiveEnergy(BigDecimal secondaryPositiveReactiveEnergy)
    {
        this.secondaryPositiveReactiveEnergy = secondaryPositiveReactiveEnergy;
    }

    public BigDecimal getSecondaryPositiveReactiveEnergy()
    {
        return secondaryPositiveReactiveEnergy;
    }

    public void setSecondaryPositiveActiveEnergy(BigDecimal secondaryPositiveActiveEnergy)
    {
        this.secondaryPositiveActiveEnergy = secondaryPositiveActiveEnergy;
    }

    public BigDecimal getSecondaryPositiveActiveEnergy()
    {
        return secondaryPositiveActiveEnergy;
    }

    public void setSecondaryTotalActivePower(BigDecimal secondaryTotalActivePower)
    {
        this.secondaryTotalActivePower = secondaryTotalActivePower;
    }

    public BigDecimal getSecondaryTotalActivePower()
    {
        return secondaryTotalActivePower;
    }

    public void setReverseReactiveEnergyEqMinus(BigDecimal reverseReactiveEnergyEqMinus)
    {
        this.reverseReactiveEnergyEqMinus = reverseReactiveEnergyEqMinus;
    }

    public BigDecimal getReverseReactiveEnergyEqMinus()
    {
        return reverseReactiveEnergyEqMinus;
    }

    public void setReverseActiveEnergyEpMinus(BigDecimal reverseActiveEnergyEpMinus)
    {
        this.reverseActiveEnergyEpMinus = reverseActiveEnergyEpMinus;
    }

    public BigDecimal getReverseActiveEnergyEpMinus()
    {
        return reverseActiveEnergyEpMinus;
    }

    public void setPositiveReactiveEnergyEqPlus(BigDecimal positiveReactiveEnergyEqPlus)
    {
        this.positiveReactiveEnergyEqPlus = positiveReactiveEnergyEqPlus;
    }

    public BigDecimal getPositiveReactiveEnergyEqPlus()
    {
        return positiveReactiveEnergyEqPlus;
    }

    public void setPositiveActiveEnergyEpPlus(BigDecimal positiveActiveEnergyEpPlus)
    {
        this.positiveActiveEnergyEpPlus = positiveActiveEnergyEpPlus;
    }

    public BigDecimal getPositiveActiveEnergyEpPlus()
    {
        return positiveActiveEnergyEpPlus;
    }

    public void setCurrentPercent(BigDecimal currentPercent)
    {
        this.currentPercent = currentPercent;
    }

    public BigDecimal getCurrentPercent()
    {
        return currentPercent;
    }

    public void setVoltagePercent(BigDecimal voltagePercent)
    {
        this.voltagePercent = voltagePercent;
    }

    public BigDecimal getVoltagePercent()
    {
        return voltagePercent;
    }

    public void setAvgCurrent(BigDecimal avgCurrent)
    {
        this.avgCurrent = avgCurrent;
    }

    public BigDecimal getAvgCurrent()
    {
        return avgCurrent;
    }

    public void setTotalForwardActiveTwo(BigDecimal totalForwardActiveTwo)
    {
        this.totalForwardActiveTwo = totalForwardActiveTwo;
    }

    public BigDecimal getTotalForwardActiveTwo()
    {
        return totalForwardActiveTwo;
    }

    public void setTotalPeakForwardActive(BigDecimal totalPeakForwardActive)
    {
        this.totalPeakForwardActive = totalPeakForwardActive;
    }

    public BigDecimal getTotalPeakForwardActive()
    {
        return totalPeakForwardActive;
    }

    public void setTotalHighForwardActive(BigDecimal totalHighForwardActive)
    {
        this.totalHighForwardActive = totalHighForwardActive;
    }

    public BigDecimal getTotalHighForwardActive()
    {
        return totalHighForwardActive;
    }

    public void setTotalFlatForwardActive(BigDecimal totalFlatForwardActive)
    {
        this.totalFlatForwardActive = totalFlatForwardActive;
    }

    public BigDecimal getTotalFlatForwardActive()
    {
        return totalFlatForwardActive;
    }

    public void setTotalValleyForwardActive(BigDecimal totalValleyForwardActive)
    {
        this.totalValleyForwardActive = totalValleyForwardActive;
    }

    public BigDecimal getTotalValleyForwardActive()
    {
        return totalValleyForwardActive;
    }

    public void setTotalReverseActiveTwo(BigDecimal totalReverseActiveTwo)
    {
        this.totalReverseActiveTwo = totalReverseActiveTwo;
    }

    public BigDecimal getTotalReverseActiveTwo()
    {
        return totalReverseActiveTwo;
    }

    public void setTotalPeakReverseActive(BigDecimal totalPeakReverseActive)
    {
        this.totalPeakReverseActive = totalPeakReverseActive;
    }

    public BigDecimal getTotalPeakReverseActive()
    {
        return totalPeakReverseActive;
    }

    public void setTotalHighReverseActive(BigDecimal totalHighReverseActive)
    {
        this.totalHighReverseActive = totalHighReverseActive;
    }

    public BigDecimal getTotalHighReverseActive()
    {
        return totalHighReverseActive;
    }

    public void setTotalFlatReverseActive(BigDecimal totalFlatReverseActive)
    {
        this.totalFlatReverseActive = totalFlatReverseActive;
    }

    public BigDecimal getTotalFlatReverseActive()
    {
        return totalFlatReverseActive;
    }

    public void setTotalValleyReverseActive(BigDecimal totalValleyReverseActive)
    {
        this.totalValleyReverseActive = totalValleyReverseActive;
    }

    public BigDecimal getTotalValleyReverseActive()
    {
        return totalValleyReverseActive;
    }

    public void setDisconnectDetectionIndication(String disconnectDetectionIndication)
    {
        this.disconnectDetectionIndication = disconnectDetectionIndication;
    }

    public String getDisconnectDetectionIndication()
    {
        return disconnectDetectionIndication;
    }

    public void setRatedPrimaryCurrentValue(BigDecimal ratedPrimaryCurrentValue)
    {
        this.ratedPrimaryCurrentValue = ratedPrimaryCurrentValue;
    }

    public BigDecimal getRatedPrimaryCurrentValue()
    {
        return ratedPrimaryCurrentValue;
    }

    public void setSwitchInputOutputStatus(String switchInputOutputStatus)
    {
        this.switchInputOutputStatus = switchInputOutputStatus;
    }

    public String getSwitchInputOutputStatus()
    {
        return switchInputOutputStatus;
    }

    public void setAlarmStatus(String alarmStatus)
    {
        this.alarmStatus = alarmStatus;
    }

    public String getAlarmStatus()
    {
        return alarmStatus;
    }

    public void setCurrentTotalVoltagePercent(BigDecimal currentTotalVoltagePercent)
    {
        this.currentTotalVoltagePercent = currentTotalVoltagePercent;
    }

    public BigDecimal getCurrentTotalVoltagePercent()
    {
        return currentTotalVoltagePercent;
    }

    public void setVoltageContentPercent(BigDecimal voltageContentPercent)
    {
        this.voltageContentPercent = voltageContentPercent;
    }

    public BigDecimal getVoltageContentPercent()
    {
        return voltageContentPercent;
    }

    public void setVoltageAcPercent(BigDecimal voltageAcPercent)
    {
        this.voltageAcPercent = voltageAcPercent;
    }

    public BigDecimal getVoltageAcPercent()
    {
        return voltageAcPercent;
    }

    public void setCurrentTotalCurrentPercent(BigDecimal currentTotalCurrentPercent)
    {
        this.currentTotalCurrentPercent = currentTotalCurrentPercent;
    }

    public BigDecimal getCurrentTotalCurrentPercent()
    {
        return currentTotalCurrentPercent;
    }

    public void setCurrentContentPercent(BigDecimal currentContentPercent)
    {
        this.currentContentPercent = currentContentPercent;
    }

    public BigDecimal getCurrentContentPercent()
    {
        return currentContentPercent;
    }

    public void setCurrentAcPercent(BigDecimal currentAcPercent)
    {
        this.currentAcPercent = currentAcPercent;
    }

    public BigDecimal getCurrentAcPercent()
    {
        return currentAcPercent;
    }

    public void setCurrentTotalPowerPercent(BigDecimal currentTotalPowerPercent)
    {
        this.currentTotalPowerPercent = currentTotalPowerPercent;
    }

    public BigDecimal getCurrentTotalPowerPercent()
    {
        return currentTotalPowerPercent;
    }

    public void setPowerContentPercent(BigDecimal powerContentPercent)
    {
        this.powerContentPercent = powerContentPercent;
    }

    public BigDecimal getPowerContentPercent()
    {
        return powerContentPercent;
    }

    public void setPowerAcPercent(BigDecimal powerAcPercent)
    {
        this.powerAcPercent = powerAcPercent;
    }

    public BigDecimal getPowerAcPercent()
    {
        return powerAcPercent;
    }

    public void setDataSettingYearMonth(String dataSettingYearMonth)
    {
        this.dataSettingYearMonth = dataSettingYearMonth;
    }

    public String getDataSettingYearMonth()
    {
        return dataSettingYearMonth;
    }

    public void setDataSettingDayHour(String dataSettingDayHour)
    {
        this.dataSettingDayHour = dataSettingDayHour;
    }

    public String getDataSettingDayHour()
    {
        return dataSettingDayHour;
    }

    public void setDataSettingMinutesSeconds(String dataSettingMinutesSeconds)
    {
        this.dataSettingMinutesSeconds = dataSettingMinutesSeconds;
    }

    public String getDataSettingMinutesSeconds()
    {
        return dataSettingMinutesSeconds;
    }

    public void setCurrentRate(BigDecimal currentRate)
    {
        this.currentRate = currentRate;
    }

    public BigDecimal getCurrentRate()
    {
        return currentRate;
    }

    public void setVersionNumber(String versionNumber)
    {
        this.versionNumber = versionNumber;
    }

    public String getVersionNumber()
    {
        return versionNumber;
    }

    public void setVoltage(BigDecimal voltage)
    {
        this.voltage = voltage;
    }

    public BigDecimal getVoltage()
    {
        return voltage;
    }

    public void setCurrent(BigDecimal current)
    {
        this.current = current;
    }

    public BigDecimal getCurrent()
    {
        return current;
    }

    public void setPower(BigDecimal power)
    {
        this.power = power;
    }

    public BigDecimal getPower()
    {
        return power;
    }

    public void setInternalTemp(BigDecimal internalTemp)
    {
        this.internalTemp = internalTemp;
    }

    public BigDecimal getInternalTemp()
    {
        return internalTemp;
    }

    public void setTotalForwardActiveOne(BigDecimal totalForwardActiveOne)
    {
        this.totalForwardActiveOne = totalForwardActiveOne;
    }

    public BigDecimal getTotalForwardActiveOne()
    {
        return totalForwardActiveOne;
    }

    public void setTotalReverseActiveOne(BigDecimal totalReverseActiveOne)
    {
        this.totalReverseActiveOne = totalReverseActiveOne;
    }

    public BigDecimal getTotalReverseActiveOne()
    {
        return totalReverseActiveOne;
    }

    public void setForwardReactiveMaxDemand(BigDecimal forwardReactiveMaxDemand)
    {
        this.forwardReactiveMaxDemand = forwardReactiveMaxDemand;
    }

    public BigDecimal getForwardReactiveMaxDemand()
    {
        return forwardReactiveMaxDemand;
    }

    public void setReverseReactiveMaxDemand(BigDecimal reverseReactiveMaxDemand)
    {
        this.reverseReactiveMaxDemand = reverseReactiveMaxDemand;
    }

    public BigDecimal getReverseReactiveMaxDemand()
    {
        return reverseReactiveMaxDemand;
    }

    public void setaForwardActiveEnergy(BigDecimal aForwardActiveEnergy)
    {
        this.aForwardActiveEnergy = aForwardActiveEnergy;
    }

    public BigDecimal getaForwardActiveEnergy()
    {
        return aForwardActiveEnergy;
    }

    public void setbForwardActiveEnergy(BigDecimal bForwardActiveEnergy)
    {
        this.bForwardActiveEnergy = bForwardActiveEnergy;
    }

    public BigDecimal getbForwardActiveEnergy()
    {
        return bForwardActiveEnergy;
    }

    public void setcForwardActiveEnergy(BigDecimal cForwardActiveEnergy)
    {
        this.cForwardActiveEnergy = cForwardActiveEnergy;
    }

    public BigDecimal getcForwardActiveEnergy()
    {
        return cForwardActiveEnergy;
    }

    public void setDidoStatus(String didoStatus)
    {
        this.didoStatus = didoStatus;
    }

    public String getDidoStatus()
    {
        return didoStatus;
    }

    public void setRunningStatus(String runningStatus)
    {
        this.runningStatus = runningStatus;
    }

    public String getRunningStatus()
    {
        return runningStatus;
    }

    public void setZeroSeqCurrent(BigDecimal zeroSeqCurrent)
    {
        this.zeroSeqCurrent = zeroSeqCurrent;
    }

    public BigDecimal getZeroSeqCurrent()
    {
        return zeroSeqCurrent;
    }

    public void setVoltageUnbalanceDegree(BigDecimal voltageUnbalanceDegree)
    {
        this.voltageUnbalanceDegree = voltageUnbalanceDegree;
    }

    public BigDecimal getVoltageUnbalanceDegree()
    {
        return voltageUnbalanceDegree;
    }

    public void setCurrentUnbalanceDegree(BigDecimal currentUnbalanceDegree)
    {
        this.currentUnbalanceDegree = currentUnbalanceDegree;
    }

    public BigDecimal getCurrentUnbalanceDegree()
    {
        return currentUnbalanceDegree;
    }

    public void setDailyReverseAcMaxDemand(BigDecimal dailyReverseAcMaxDemand)
    {
        this.dailyReverseAcMaxDemand = dailyReverseAcMaxDemand;
    }

    public BigDecimal getDailyReverseAcMaxDemand()
    {
        return dailyReverseAcMaxDemand;
    }

    public void setDailyForwardReacMaxDemand(BigDecimal dailyForwardReacMaxDemand)
    {
        this.dailyForwardReacMaxDemand = dailyForwardReacMaxDemand;
    }

    public BigDecimal getDailyForwardReacMaxDemand()
    {
        return dailyForwardReacMaxDemand;
    }

    public void setDailyReverseReacMaxDemand(BigDecimal dailyReverseReacMaxDemand)
    {
        this.dailyReverseReacMaxDemand = dailyReverseReacMaxDemand;
    }

    public BigDecimal getDailyReverseReacMaxDemand()
    {
        return dailyReverseReacMaxDemand;
    }

    public void setPreDayForwardAcMaxDemand(BigDecimal preDayForwardAcMaxDemand)
    {
        this.preDayForwardAcMaxDemand = preDayForwardAcMaxDemand;
    }

    public BigDecimal getPreDayForwardAcMaxDemand()
    {
        return preDayForwardAcMaxDemand;
    }

    public void setPreDayReverseAcMaxDemand(BigDecimal preDayReverseAcMaxDemand)
    {
        this.preDayReverseAcMaxDemand = preDayReverseAcMaxDemand;
    }

    public BigDecimal getPreDayReverseAcMaxDemand()
    {
        return preDayReverseAcMaxDemand;
    }

    public void setPreDayForwardReacMaxDemand(BigDecimal preDayForwardReacMaxDemand)
    {
        this.preDayForwardReacMaxDemand = preDayForwardReacMaxDemand;
    }

    public BigDecimal getPreDayForwardReacMaxDemand()
    {
        return preDayForwardReacMaxDemand;
    }

    public void setPreDayReverseReacMaxDemand(BigDecimal preDayReverseReacMaxDemand)
    {
        this.preDayReverseReacMaxDemand = preDayReverseReacMaxDemand;
    }

    public BigDecimal getPreDayReverseReacMaxDemand()
    {
        return preDayReverseReacMaxDemand;
    }

    public void setPre2dForwardAcMaxDemand(BigDecimal pre2dForwardAcMaxDemand)
    {
        this.pre2dForwardAcMaxDemand = pre2dForwardAcMaxDemand;
    }

    public BigDecimal getPre2dForwardAcMaxDemand()
    {
        return pre2dForwardAcMaxDemand;
    }

    public void setPre2dReverseAcMaxDemand(BigDecimal pre2dReverseAcMaxDemand)
    {
        this.pre2dReverseAcMaxDemand = pre2dReverseAcMaxDemand;
    }

    public BigDecimal getPre2dReverseAcMaxDemand()
    {
        return pre2dReverseAcMaxDemand;
    }

    public void setPre2dForwardReacMaxDemand(BigDecimal pre2dForwardReacMaxDemand)
    {
        this.pre2dForwardReacMaxDemand = pre2dForwardReacMaxDemand;
    }

    public BigDecimal getPre2dForwardReacMaxDemand()
    {
        return pre2dForwardReacMaxDemand;
    }

    public void setPre2dReverseReacMaxDemand(BigDecimal pre2dReverseReacMaxDemand)
    {
        this.pre2dReverseReacMaxDemand = pre2dReverseReacMaxDemand;
    }

    public BigDecimal getPre2dReverseReacMaxDemand()
    {
        return pre2dReverseReacMaxDemand;
    }

    public void setCurrentForwardAcDemand(BigDecimal currentForwardAcDemand)
    {
        this.currentForwardAcDemand = currentForwardAcDemand;
    }

    public BigDecimal getCurrentForwardAcDemand()
    {
        return currentForwardAcDemand;
    }

    public void setCurrentReverseAcDemand(BigDecimal currentReverseAcDemand)
    {
        this.currentReverseAcDemand = currentReverseAcDemand;
    }

    public BigDecimal getCurrentReverseAcDemand()
    {
        return currentReverseAcDemand;
    }

    public void setCurrentForwardReacDemand(BigDecimal currentForwardReacDemand)
    {
        this.currentForwardReacDemand = currentForwardReacDemand;
    }

    public BigDecimal getCurrentForwardReacDemand()
    {
        return currentForwardReacDemand;
    }

    public void setCurrentReverseReacDemand(BigDecimal currentReverseReacDemand)
    {
        this.currentReverseReacDemand = currentReverseReacDemand;
    }

    public BigDecimal getCurrentReverseReacDemand()
    {
        return currentReverseReacDemand;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
                .append("id", getId())
                .append("dataUpdateTime", getDataUpdateTime())
                .append("currentCombActiveTotal", getCurrentCombActiveTotal())
                .append("currentCombActivePeak", getCurrentCombActivePeak())
                .append("currentCombActiveHigh", getCurrentCombActiveHigh())
                .append("currentCombActiveFlat", getCurrentCombActiveFlat())
                .append("currentCombActiveValley", getCurrentCombActiveValley())
                .append("currentForwardActiveTotal", getCurrentForwardActiveTotal())
                .append("currentForwardActivePeak", getCurrentForwardActivePeak())
                .append("currentForwardActiveHigh", getCurrentForwardActiveHigh())
                .append("currentForwardActiveFlat", getCurrentForwardActiveFlat())
                .append("currentForwardActiveValley", getCurrentForwardActiveValley())
                .append("currentReverseActiveTotal", getCurrentReverseActiveTotal())
                .append("currentReverseActivePeak", getCurrentReverseActivePeak())
                .append("currentReverseActiveHigh", getCurrentReverseActiveHigh())
                .append("currentReverseActiveFlat", getCurrentReverseActiveFlat())
                .append("currentReverseActiveValley", getCurrentReverseActiveValley())
                .append("currentCombReactiveTotal", getCurrentCombReactiveTotal())
                .append("currentCombReactivePeak", getCurrentCombReactivePeak())
                .append("currentCombReactiveHigh", getCurrentCombReactiveHigh())
                .append("currentCombReactiveFlat", getCurrentCombReactiveFlat())
                .append("currentCombReactiveValley", getCurrentCombReactiveValley())
                .append("currentForwardReactiveTotal", getCurrentForwardReactiveTotal())
                .append("currentForwardReactivePeak", getCurrentForwardReactivePeak())
                .append("currentForwardReactiveHigh", getCurrentForwardReactiveHigh())
                .append("currentForwardReactiveFlat", getCurrentForwardReactiveFlat())
                .append("currentForwardReactiveValley", getCurrentForwardReactiveValley())
                .append("currentReverseReactiveTotal", getCurrentReverseReactiveTotal())
                .append("currentReverseReactivePeak", getCurrentReverseReactivePeak())
                .append("currentReverseReactiveHigh", getCurrentReverseReactiveHigh())
                .append("currentReverseReactiveFlat", getCurrentReverseReactiveFlat())
                .append("currentReverseReactiveValley", getCurrentReverseReactiveValley())
                .append("phaseAVoltage", getPhaseAVoltage())
                .append("phaseBVoltage", getPhaseBVoltage())
                .append("phaseCVoltage", getPhaseCVoltage())
                .append("phaseACurrent", getPhaseACurrent())
                .append("phaseBCurrent", getPhaseBCurrent())
                .append("phaseCCurrent", getPhaseCCurrent())
                .append("frequency", getFrequency())
                .append("abLineVoltage", getAbLineVoltage())
                .append("cbLineVoltage", getCbLineVoltage())
                .append("acLineVoltage", getAcLineVoltage())
                .append("forwardAcMaxDemand", getForwardAcMaxDemand())
                .append("reverseAcMaxDemand", getReverseAcMaxDemand())
                .append("phaseAActivePower", getPhaseAActivePower())
                .append("phaseBActivePower", getPhaseBActivePower())
                .append("phaseCActivePower", getPhaseCActivePower())
                .append("totalActivePower", getTotalActivePower())
                .append("phaseAReactivePower", getPhaseAReactivePower())
                .append("phaseBReactivePower", getPhaseBReactivePower())
                .append("phaseCReactivePower", getPhaseCReactivePower())
                .append("totalReactivePower", getTotalReactivePower())
                .append("phaseAApparentPower", getPhaseAApparentPower())
                .append("phaseBApparentPower", getPhaseBApparentPower())
                .append("phaseCApparentPower", getPhaseCApparentPower())
                .append("totalApparentPower", getTotalApparentPower())
                .append("phaseAPowerFactor", getPhaseAPowerFactor())
                .append("phaseBPowerFactor", getPhaseBPowerFactor())
                .append("phaseCPowerFactor", getPhaseCPowerFactor())
                .append("totalPowerFactor", getTotalPowerFactor())
                .append("dailyForwardMaxDemand", getDailyForwardMaxDemand())
                .append("siteId", getSiteId())
                .append("deviceId", getDeviceId())
                .append("createBy", getCreateBy())
                .append("createTime", getCreateTime())
                .append("updateBy", getUpdateBy())
                .append("updateTime", getUpdateTime())
                .append("remark", getRemark())
                .append("secondaryAbLineVoltage", getSecondaryAbLineVoltage())
                .append("secondaryAPhaseCurrent", getSecondaryAPhaseCurrent())
                .append("secondaryAPhaseVoltage", getSecondaryAPhaseVoltage())
                .append("secondaryAPowerFactor", getSecondaryAPowerFactor())
                .append("secondaryAApparentPower", getSecondaryAApparentPower())
                .append("secondaryAReactivePower", getSecondaryAReactivePower())
                .append("secondaryAActivePower", getSecondaryAActivePower())
                .append("secondaryBcLineVoltage", getSecondaryBcLineVoltage())
                .append("secondaryBPhaseCurrent", getSecondaryBPhaseCurrent())
                .append("secondaryBPhaseVoltage", getSecondaryBPhaseVoltage())
                .append("secondaryBPowerFactor", getSecondaryBPowerFactor())
                .append("secondaryBApparentPower", getSecondaryBApparentPower())
                .append("secondaryBReactivePower", getSecondaryBReactivePower())
                .append("secondaryBActivePower", getSecondaryBActivePower())
                .append("secondaryCaLineVoltage", getSecondaryCaLineVoltage())
                .append("secondaryCPhaseCurrent", getSecondaryCPhaseCurrent())
                .append("secondaryCPhaseVoltage", getSecondaryCPhaseVoltage())
                .append("secondaryCPowerFactor", getSecondaryCPowerFactor())
                .append("secondaryCApparentPower", getSecondaryCApparentPower())
                .append("secondaryCReactivePower", getSecondaryCReactivePower())
                .append("secondaryCActivePower", getSecondaryCActivePower())
                .append("secondaryGridFrequency", getSecondaryGridFrequency())
                .append("secondaryReverseReactiveEnergy", getSecondaryReverseReactiveEnergy())
                .append("secondaryNegativeActiveEnergy", getSecondaryNegativeActiveEnergy())
                .append("secondaryTotalPowerFactor", getSecondaryTotalPowerFactor())
                .append("secondaryTotalApparentPower", getSecondaryTotalApparentPower())
                .append("secondaryTotalReactivePower", getSecondaryTotalReactivePower())
                .append("secondaryPositiveReactiveEnergy", getSecondaryPositiveReactiveEnergy())
                .append("secondaryPositiveActiveEnergy", getSecondaryPositiveActiveEnergy())
                .append("secondaryTotalActivePower", getSecondaryTotalActivePower())
                .append("reverseReactiveEnergyEqMinus", getReverseReactiveEnergyEqMinus())
                .append("reverseActiveEnergyEpMinus", getReverseActiveEnergyEpMinus())
                .append("positiveReactiveEnergyEqPlus", getPositiveReactiveEnergyEqPlus())
                .append("positiveActiveEnergyEpPlus", getPositiveActiveEnergyEpPlus())
                .append("currentPercent", getCurrentPercent())
                .append("voltagePercent", getVoltagePercent())
                .append("avgCurrent", getAvgCurrent())
                .append("totalForwardActiveTwo", getTotalForwardActiveTwo())
                .append("totalPeakForwardActive", getTotalPeakForwardActive())
                .append("totalHighForwardActive", getTotalHighForwardActive())
                .append("totalFlatForwardActive", getTotalFlatForwardActive())
                .append("totalValleyForwardActive", getTotalValleyForwardActive())
                .append("totalReverseActiveTwo", getTotalReverseActiveTwo())
                .append("totalPeakReverseActive", getTotalPeakReverseActive())
                .append("totalHighReverseActive", getTotalHighReverseActive())
                .append("totalFlatReverseActive", getTotalFlatReverseActive())
                .append("totalValleyReverseActive", getTotalValleyReverseActive())
                .append("disconnectDetectionIndication", getDisconnectDetectionIndication())
                .append("ratedPrimaryCurrentValue", getRatedPrimaryCurrentValue())
                .append("switchInputOutputStatus", getSwitchInputOutputStatus())
                .append("alarmStatus", getAlarmStatus())
                .append("currentTotalVoltagePercent", getCurrentTotalVoltagePercent())
                .append("voltageContentPercent", getVoltageContentPercent())
                .append("voltageAcPercent", getVoltageAcPercent())
                .append("currentTotalCurrentPercent", getCurrentTotalCurrentPercent())
                .append("currentContentPercent", getCurrentContentPercent())
                .append("currentAcPercent", getCurrentAcPercent())
                .append("currentTotalPowerPercent", getCurrentTotalPowerPercent())
                .append("powerContentPercent", getPowerContentPercent())
                .append("powerAcPercent", getPowerAcPercent())
                .append("dataSettingYearMonth", getDataSettingYearMonth())
                .append("dataSettingDayHour", getDataSettingDayHour())
                .append("dataSettingMinutesSeconds", getDataSettingMinutesSeconds())
                .append("currentRate", getCurrentRate())
                .append("versionNumber", getVersionNumber())
                .append("voltage", getVoltage())
                .append("current", getCurrent())
                .append("power", getPower())
                .append("internalTemp", getInternalTemp())
                .append("totalForwardActiveOne", getTotalForwardActiveOne())
                .append("totalReverseActiveOne", getTotalReverseActiveOne())
                .append("forwardReactiveMaxDemand", getForwardReactiveMaxDemand())
                .append("reverseReactiveMaxDemand", getReverseReactiveMaxDemand())
                .append("aForwardActiveEnergy", getaForwardActiveEnergy())
                .append("bForwardActiveEnergy", getbForwardActiveEnergy())
                .append("cForwardActiveEnergy", getcForwardActiveEnergy())
                .append("didoStatus", getDidoStatus())
                .append("runningStatus", getRunningStatus())
                .append("zeroSeqCurrent", getZeroSeqCurrent())
                .append("voltageUnbalanceDegree", getVoltageUnbalanceDegree())
                .append("currentUnbalanceDegree", getCurrentUnbalanceDegree())
                .append("dailyReverseAcMaxDemand", getDailyReverseAcMaxDemand())
                .append("dailyForwardReacMaxDemand", getDailyForwardReacMaxDemand())
                .append("dailyReverseReacMaxDemand", getDailyReverseReacMaxDemand())
                .append("preDayForwardAcMaxDemand", getPreDayForwardAcMaxDemand())
                .append("preDayReverseAcMaxDemand", getPreDayReverseAcMaxDemand())
                .append("preDayForwardReacMaxDemand", getPreDayForwardReacMaxDemand())
                .append("preDayReverseReacMaxDemand", getPreDayReverseReacMaxDemand())
                .append("pre2dForwardAcMaxDemand", getPre2dForwardAcMaxDemand())
                .append("pre2dReverseAcMaxDemand", getPre2dReverseAcMaxDemand())
                .append("pre2dForwardReacMaxDemand", getPre2dForwardReacMaxDemand())
                .append("pre2dReverseReacMaxDemand", getPre2dReverseReacMaxDemand())
                .append("currentForwardAcDemand", getCurrentForwardAcDemand())
                .append("currentReverseAcDemand", getCurrentReverseAcDemand())
                .append("currentForwardReacDemand", getCurrentForwardReacDemand())
                .append("currentReverseReacDemand", getCurrentReverseReacDemand())
                .toString();
    }
}
