<template>
|
<flex-layout direction="row" class="page-history" :no-bg="true" :loading="loading">
|
<home-list slot="header" @toggleChange="toggleChange" @leaf-click="leafClick"></home-list>
|
<content-box style="margin-left: 4px; margin-right: 4px;" :title="battFullName">
|
<div slot="box-tools" class="box-tools">
|
<el-tooltip class="item" effect="dark" content="实时数据" placement="bottom">
|
<i class="iconfont el-icon-jinru" @click="syncPage"></i>
|
</el-tooltip>
|
</div>
|
<div slot="box-tools" class="box-tools" style="right: 36px;">
|
<el-tooltip class="item" effect="dark" content="数据对比" placement="bottom">
|
<i class="iconfont el-icon-jiankong" @click="toShowComparison"></i>
|
</el-tooltip>
|
</div>
|
<div slot="box-tools" class="box-tools" style="right: 65px;">
|
<el-tooltip class="item" effect="dark" content="数据导出" placement="bottom">
|
<i class="iconfont el-icon-daochu" @click="showDataDifferDialog" style="font-size: 24px"></i>
|
</el-tooltip>
|
</div>
|
<div slot="box-tools" class="box-tools" style="right: 96px;">
|
<el-tooltip class="item" effect="dark" content="标准曲线" placement="bottom">
|
<i class="iconfont el-icon-biaozhunquxian" @click="confirmAddStandardLine"
|
style="font-size: 20px"></i>
|
</el-tooltip>
|
</div>
|
<div slot="box-tools" class="box-tools" style="right: 125px;display: flex;align-items: center;width:160px">
|
<label style="font-size:12px;margin-right:8px">显示粒度:</label>
|
<el-select v-model="show_num" size="small" style="width:90px" @change="testRecordChange">
|
<el-option :value="1" label="×1"></el-option>
|
<el-option :value="2" label="×2"></el-option>
|
<el-option :value="3" label="×3"></el-option>
|
<el-option :value="4" label="×4"></el-option>
|
<el-option :value="5" label="×5"></el-option>
|
<el-option :value="6" label="×6"></el-option>
|
<el-option :value="7" label="×7"></el-option>
|
<el-option :value="8" label="×8"></el-option>
|
<el-option :value="9" label="×9"></el-option>
|
<el-option :value="10" label="×10"></el-option>
|
</el-select>
|
</div>
|
<flex-layout :no-bg="true">
|
<div class="content-header" slot="header">
|
<div class="table-layout">
|
<div class="table-row">
|
<div class="table-cell text-right w80">电池状态:</div>
|
<div class="table-cell">
|
<el-input v-model="formateBattState" placeholder="" size="small" :disabled="true">
|
</el-input>
|
</div>
|
<div class="table-cell text-right w80">端电压:</div>
|
<div class="table-cell">
|
<el-input v-model="top.group" placeholder="" size="small" :disabled="true"
|
style="min-width:12rem"></el-input>
|
</div>
|
<div class="table-cell text-right w80">电池电流:</div>
|
<div class="table-cell">
|
<el-input v-model="top.curr" placeholder="" size="small" :disabled="true"></el-input>
|
</div>
|
<div class="table-cell text-right w80">测试时长:</div>
|
<div class="table-cell">
|
<el-input v-model="top.test_long" placeholder="" size="small" :disabled="true">
|
</el-input>
|
</div>
|
</div>
|
<div class="table-row">
|
<div class="table-cell text-right w80">测试日期:</div>
|
<div class="table-cell">
|
<el-cascader v-if="isAio" v-model="test_record1.value" :options="test_record1.list" size="small"
|
placeholder="请选择测试日期" style="width: 100%; min-width:16rem"
|
@change="testRecordChange">
|
<template slot-scope="{ node, data }">
|
<span>{{ data.label }}</span>
|
<span v-if="!node.isLeaf"> ({{data.children.length }})</span>
|
</template>
|
</el-cascader>
|
<el-cascader v-else v-model="test_record.value" :options="test_record.list" size="small"
|
placeholder="请选择测试日期" style="width: 100%; min-width:16rem"
|
@change="testRecordChange">
|
<template slot-scope="{ node, data }">
|
<span>{{ data.label }}</span>
|
<span v-if="!node.isLeaf"> ({{ data.children.length }}) </span>
|
</template>
|
</el-cascader>
|
</div>
|
<div class="table-cell text-right w80">测试容量:</div>
|
<div class="table-cell">
|
<el-input v-model="top.test_cap" placeholder="" size="small" :disabled="true">
|
</el-input>
|
</div>
|
<div class="table-cell text-right w80">剩余容量:</div>
|
<div class="table-cell">
|
<el-input v-model="top.re_cap" placeholder="" size="small" :disabled="true"></el-input>
|
</div>
|
|
<div class="table-cell text-right w80">续航时长:</div>
|
<div class="table-cell">
|
<el-tooltip class="item" effect="dark" content="机房停电时电池对实际负载供电时长" placement="top">
|
<el-input v-model="top.xuhang" placeholder="" size="small" :disabled="true">
|
</el-input>
|
</el-tooltip>
|
</div>
|
</div>
|
</div>
|
</div>
|
<div class="page-content">
|
<div class="flex-box-list">
|
<div class="flex-box" style="margin-bottom: 8px;">
|
<chart-wrapper :title="groupVolTitle">
|
<line-chart ref="groupVol" id="groupVol" unit="V"></line-chart>
|
</chart-wrapper>
|
</div>
|
<div class="flex-box" style="margin-bottom: 8px;">
|
<chart-wrapper :title="monBarTitle">
|
<div class="chart-tools-wrapper">
|
<el-select v-model="chartType" size="mini" @change="changeChartType">
|
<el-option v-for="item in chartTypes" :key="item.value" :label="item.label"
|
:value="item.value"></el-option>
|
</el-select>
|
</div>
|
<bar-chart ref="monBar" id="monBar" :show-label="false"></bar-chart>
|
</chart-wrapper>
|
</div>
|
</div>
|
<div class="flex-box-list">
|
<div class="flex-box" style="margin-top: 8px;">
|
<chart-wrapper title="电池电流折线图(A)">
|
<line-chart ref="groupCurr" id="groupCurr" unit="A" start-zero></line-chart>
|
</chart-wrapper>
|
</div>
|
<div class="flex-box" style="margin-top: 8px;">
|
<chart-wrapper :title="monInfo.title">
|
<line-chart ref="monInfo" id="monInfo" :unit="monInfo.unit"></line-chart>
|
</chart-wrapper>
|
</div>
|
</div>
|
</div>
|
<div class="content-footer" slot="footer">
|
<div class="slider-container">
|
<el-slider v-model="slider" size="small" :format-tooltip="formatTooltip" @input="sliderInput">
|
</el-slider>
|
</div>
|
</div>
|
</flex-layout>
|
</content-box>
|
<el-dialog title="历史数据对比" width="1200px" :visible.sync="showComparison" v-if="showComparison"
|
:close-on-click-modal="false" top="0" class="dialog-center" :modal-append-to-body="false">
|
<comparison :test_record="test_record"></comparison>
|
</el-dialog>
|
<!-- 电压/温度差 -->
|
<el-dialog
|
title="电压/温度差分析"
|
width="auto"
|
:visible.sync="dataDiffter"
|
:close-on-click-modal="false"
|
top="0"
|
class="dialog-center">
|
<data-diffter
|
v-if="dataDiffter" :visible.sync="dataDiffter"
|
:vol="volDiffer" :temp="tempDiffer" @success="ensureExportExcel"></data-diffter>
|
</el-dialog>
|
<div id="allGraph">
|
<div class="chart-contain">
|
<div class="chart" ref="allGraph"></div>
|
</div>
|
</div>
|
<form :action="exportInfo.action" method="post" ref="all_picture" enctype="multipart/form-data">
|
<input type="hidden" id="exPageName" name="pageName" value="exportTbal" />
|
<input type="hidden" name="ltop_echart" ref="ltop_echart" value="" />
|
<input type="hidden" name="rtop_echart" ref="rtop_echart" value="" />
|
<input type="hidden" name="lbottom_echart" ref="lbottom_echart" value="" />
|
<input type="hidden" name="rbottom_echart" ref="rbottom_echart" value="" />
|
<input type="hidden" name="actucap_echart" ref="actucap_echart" value="" />
|
<input type="hidden" name="restcap_echart" ref="restcap_echart" value="" />
|
<input type="hidden" name="capperc_echart" ref="capperc_echart" value="" />
|
<input type="hidden" name="tmp_echart" ref="tmp_echart" value=""> <!-- 单体温度折线图 -->
|
<input type="hidden" name="mon_res" ref="mon_res" value=""> <!-- 单体内阻 -->
|
<input type="hidden" name="JH_curr" ref="JH_curr" value=""> <!-- 单体均衡电流 -->
|
<input type="hidden" name="last_vol" ref="last_vol" value=""> <!-- 终止电压柱状图 -->
|
<input type="hidden" name="last_tmp" ref="last_tmp" value=""> <!-- 终止温度柱状图 -->
|
<input type="hidden" name="restcap_line_echart" ref="restcap_line_echart" value=""> <!-- 剩余容量 -->
|
<input type="hidden" name="group_vol_qth" ref="group_vol_qth">
|
<!--驼峰锅底-->
|
|
<input type="hidden" name="obj-bmd" ref="obj_bmd" value="" />
|
<input type="hidden" name="obj-title" ref="obj_title" value="" /> <!-- 落后单体阀值信息 -->
|
<input type="hidden" name="arr-data" ref="arr_data" value="" />
|
<!--存放单体的起始信息二维数组-->
|
<input type="hidden" name="mon-vol-list" ref="mon_vol_list" value="" /> <!-- 所有单体电压测试信息 -->
|
<input type="hidden" name="mon-tmp-list" ref="mon_tmp_list" value="" /> <!-- 所有单体温度测试信息 -->
|
<input type="hidden" name="mon-group-list" ref="mon_group_list" value="" /> <!-- 在线电压 -->
|
|
<!-- 电压/温度对比数据 -->
|
<input type="hidden" name="splitTime" ref="splitTime" value="" />
|
<input type="hidden" name="mon_vol_compare_pic" ref="mon_vol_compare_pic" value="" />
|
<input type="hidden" name="mon_temp_compare_pic" ref="mon_temp_compare_pic" value="" />
|
<input type="hidden" name="time-compare-list" ref="time_compare_list" value="" />
|
<input type="hidden" name="mon-vol-compare-list" ref="mon_vol_compare_list" value="" />
|
<input type="hidden" name="mon-tmp-compare-list" ref="mon_tmp_compare_list" value="" />
|
</form>
|
</flex-layout>
|
</template>
|
|
<script>
|
import echarts from "echarts"
|
import ContentBox from "../../components/ContentBox";
|
import HomeList from "./HomeList";
|
import BarChart from "../../components/chart/BarChart";
|
import LineChart from "../../components/chart/LineChart";
|
import ChartWrapper from "@/components/ChartWrapper";
|
import chartImage from '@/assets/images/eleOn.gif'
|
import comparison from '../../components/comparisonData/comparison.vue'
|
import getSpecialPointIndex from "@/assets/js/tools/getSpecialPointIndex";
|
import getQgth from "@/assets/js/tools/getQgth";
|
import {
|
searchAll_lowAction,
|
searchBattresdata,
|
searchBattTestData,
|
searchBattTestDataStop,
|
searchHistory
|
} from "../../assets/js/history";
|
|
import {
|
formatSeconds,
|
GetMonomerCap,
|
GetHourRate,
|
getBarNum,
|
Title,
|
getLow,
|
regEquipType,
|
sethoubeiTime,
|
} from "../../assets/js/tools";
|
|
let Titleobj = new Title();
|
import ECharts from "echarts/lib/echarts";
|
//引入折线图
|
import "echarts/lib/chart/bar";
|
import "echarts/lib/chart/line"
|
//引入提示框
|
import "echarts/lib/component/tooltip";
|
//引入标题
|
import "echarts/lib/component/title";
|
//引入图例标志
|
import "echarts/lib/component/legend";
|
//区域缩放
|
import "echarts/lib/component/dataZoom";
|
|
//markeline
|
import "echarts/lib/component/markLine"
|
|
// 引入自定义主题
|
import "@/components/chart/theme/transparent"
|
import DataDiffter from "@/pages/dataTest/dialogs/DataDiffter";
|
import getMinInfo from "@/assets/js/tools/getMinInfo";
|
import getMaxInfo from "@/assets/js/tools/getMaxInfo";
|
// 端信息
|
let allData = {
|
groupVol: [],
|
onlineVol: [],
|
testCurr: [],
|
testTimeLong: [],
|
monNumList: [],
|
recordTime: [],
|
testCap: [],
|
dataList: [],
|
endData: {}
|
};
|
// 单体折线信息
|
let monLineData = {
|
vol: [], // 单体电压
|
temp: [], // 单体温度
|
realCap: [], // 单体实际容量
|
resCap: [], // 单体剩余容量
|
preCap: [] // 单体容量百分比
|
};
|
// 单体柱状信息
|
let monBarData = {
|
vol: [], // 单体电压
|
temp: [], // 单体温度
|
realCap: [], // 单体实际容量
|
resCap: [], // 单体剩余容量
|
preCap: [], // 单体容量百分比
|
jh_curr: [], // 单体均衡电流
|
res: [], // 单体内阻
|
};
|
// 4个图表
|
let groupVolLineChart, currLineChart, monLineChart, monBarChart;
|
let allGraph;
|
export default {
|
components: {
|
DataDiffter,
|
ContentBox,
|
HomeList,
|
BarChart,
|
LineChart,
|
ChartWrapper,
|
comparison
|
},
|
data() {
|
let baseURL = this.$axios.defaults.baseURL;
|
baseURL = baseURL ? baseURL : "";
|
return {
|
HistoryData: [],
|
show_num: 5,
|
humpPotBottom: true, // 驼峰锅底
|
loading: false,
|
isNew: true,
|
showComparison: false,
|
dataDiffter: false,
|
volDiffer: [],
|
tempDiffer: [],
|
data: [],
|
batt: {},
|
groupVolTitle: '端电压折线图(V)',
|
groupVolQth: {
|
code: 0,
|
low: 0,
|
lowTime: '00:00:00',
|
high: 0,
|
highTime: '00:00:00',
|
qt: 0,
|
qg: 0,
|
qh: 0,
|
title: '正常'
|
},
|
top: {
|
state: "", // 电池状态
|
group: "", // 端电压
|
curr: "", // 电池电流
|
test_long: "", // 测试时长
|
test_cap: "", // 测试容量
|
re_cap: "", // 剩余容量
|
xuhang: "" // 续航时长
|
},
|
test_record: {
|
value: [],
|
list: [{
|
value: "herongDischarge",
|
label: "核容放电",
|
children: []
|
},
|
{
|
value: "jianceDischarge",
|
label: "监测放电",
|
children: []
|
},
|
{
|
value: "herongCharge",
|
label: "核容充电",
|
children: []
|
},
|
{
|
value: "jianceCharge",
|
label: "监测充电",
|
children: []
|
}
|
]
|
},
|
test_record1: {
|
value: [],
|
list: [
|
{
|
value: 0,
|
label: "电池组1",
|
children: [
|
{
|
value: "herongDischarge",
|
label: "核容放电",
|
children: []
|
},
|
{
|
value: "jianceDischarge",
|
label: "监测放电",
|
children: []
|
},
|
{
|
value: "herongCharge",
|
label: "核容充电",
|
children: []
|
},
|
{
|
value: "jianceCharge",
|
label: "监测充电",
|
children: []
|
}
|
]
|
},
|
{
|
value: 1,
|
label: "电池组2",
|
children: [
|
{
|
value: "herongDischarge",
|
label: "核容放电",
|
children: []
|
},
|
{
|
value: "jianceDischarge",
|
label: "监测放电",
|
children: []
|
},
|
{
|
value: "herongCharge",
|
label: "核容充电",
|
children: []
|
},
|
{
|
value: "jianceCharge",
|
label: "监测充电",
|
children: []
|
}
|
]
|
},
|
]
|
},
|
slider: 100,
|
testTimeLong: [],
|
battState: {
|
test_type: -100,
|
stop_reason: ''
|
},
|
monBarTitle: "最大值=0V;最小值=0V;平均值=0V",
|
chartType: 'vol',
|
chartTypes: [{
|
label: '单体电压',
|
value: 'vol',
|
unit: 'V',
|
fixed: 3,
|
},
|
{
|
label: '单体温度',
|
value: 'temp',
|
unit: '℃',
|
fixed: 1,
|
},
|
{
|
label: '单体实际容量',
|
value: 'realCap',
|
unit: 'AH',
|
fixed: 0,
|
},
|
{
|
label: '单体剩余容量',
|
value: 'resCap',
|
unit: 'AH',
|
fixed: 0,
|
},
|
{
|
label: '单体容量百分比',
|
value: 'preCap',
|
unit: '%',
|
fixed: 0
|
}
|
],
|
exportInfo: {
|
action: baseURL + "EchartPictureDowload.servlet",
|
ltop_echart: "", // 组端电压折线图
|
rtop_echart: "", // 单体电压柱状图
|
lbottom_echart: "", // 测试电流
|
rbottom_echart: "", // 单体电压折线图
|
actucap_echart: "", // 实际容量
|
restcap_echart: "", // 剩余容量
|
capperc_echart: "", // 容量百分比
|
tmp_echart: "", // 单体温度折线图
|
mon_res: "", // 单体内阻
|
JH_curr: "", // 单体均衡电流
|
last_vol: "", // 终止电压柱状图
|
last_tmp: "", // 终止温度柱状图
|
restcap_line_echart: "", // 剩余容量
|
obj_bmd: "", //
|
obj_title: "", // 落后单体阀值信息
|
arr_data: [], // 存放单体的起始信息二维数组
|
mon_vol_list: [], // 所有单体电压测试信息
|
mon_tmp_list: [], // 所有单体温度测试信息
|
mon_group_list: [] // 所有单体温度测试信息
|
},
|
low_list: [],
|
monInfo: {
|
title: "单体电压(V)",
|
unit: "V",
|
}
|
}
|
|
},
|
methods: {
|
changeShow() {
|
// 端信息
|
allData = {
|
groupVol: [],
|
onlineVol: [],
|
testCurr: [],
|
testTimeLong: [],
|
monNumList: [],
|
recordTime: [],
|
testCap: [],
|
dataList: [],
|
endData: {}
|
};
|
// 单体折线信息
|
monLineData = {
|
vol: [], // 单体电压
|
temp: [], // 单体温度
|
realCap: [], // 单体实际容量
|
resCap: [], // 单体剩余容量
|
preCap: [] // 单体容量百分比
|
};
|
// 单体柱状信息
|
monBarData = {
|
vol: [], // 单体电压
|
temp: [], // 单体温度
|
realCap: [], // 单体实际容量
|
resCap: [], // 单体剩余容量
|
preCap: [], // 单体容量百分比
|
jh_curr: [], // 单体均衡电流
|
res: [], // 单体内阻
|
};
|
this.formateHisData(this.HistoryData);
|
},
|
toggleChange() {
|
this.resize();
|
},
|
resize() {
|
this.$G.chartManage.resize("groupVol");
|
this.$G.chartManage.resize("monBar");
|
this.$G.chartManage.resize("groupCurr");
|
this.$G.chartManage.resize("monInfo");
|
},
|
leafClick(data) {
|
this.batt = data;
|
// 如果是LD9就跳转到LD9的历史页面
|
if (regEquipType(data.FBSDeviceId, 'LD9')) {
|
let search =
|
"?province=" +
|
data.StationName1 +
|
"&city=" +
|
data.StationName2 +
|
"&county=" +
|
data.StationName5 +
|
"&home=" +
|
data.StationName3 +
|
"&batt=" +
|
data.BattGroupId;
|
window.parent.postMessage(
|
{
|
cmd: "syncPage",
|
params: {
|
pageInfo: {
|
label: "历史数据",
|
name: "history",
|
src: '#/history-ld9' + search,
|
closable: true,
|
},
|
},
|
},
|
"*"
|
);
|
return;
|
}
|
// 重置页面内容
|
this.init();
|
// 获取充放电记录
|
this.searchBattTestData();
|
this.isNew = false;
|
},
|
// 初始化页面数据
|
init() {
|
// 初始化充放电记录
|
this.test_record.value = [];
|
this.test_record.list[0].children = [];
|
this.test_record.list[1].children = [];
|
this.test_record.list[2].children = [];
|
this.test_record.list[3].children = [];
|
|
// 初始化A059充放电记录
|
if(this.isAio) {
|
this.test_record1.value = [];
|
this.test_record1.list.map(item=>{
|
item.children.map(item1=>{
|
item1.children = [];
|
});
|
});
|
}
|
|
// 初始化顶部文本框内容
|
this.top = {
|
state: "", // 电池状态
|
group: "", // 端电压
|
curr: "", // 电池电流
|
test_long: "", // 测试时长
|
test_cap: "", // 测试容量
|
re_cap: "", // 剩余容量
|
xuhang: "---" // 续航时长
|
};
|
|
// 初始化电池状态
|
this.battState.test_type = -100;
|
|
// 初始化图表
|
this.initChart();
|
},
|
// 初始化图表和图表数据
|
initChart() {
|
let batt = this.batt;
|
// 拖动条默认值100
|
this.slider = 100;
|
this.testTimeLong = [];
|
|
// 端信息
|
allData = {
|
groupVol: [],
|
onlineVol: [],
|
testCurr: [],
|
testTimeLong: [],
|
recordTime: [],
|
testCap: [],
|
monNumList: [],
|
dataList: [],
|
};
|
let monCount = batt.MonCount;
|
console.log(batt);
|
// 锂电池包
|
if(regEquipType(batt.FBSDeviceId, "lithiumPack")) {
|
monCount = monCount*batt.packCount;
|
}
|
console.log(monCount);
|
for (let i = 1; i <= monCount; i++) {
|
allData.monNumList[i - 1] = ("#" + i);
|
}
|
// 单体折线信息
|
monLineData = {
|
vol: [], // 单体电压
|
temp: [], // 单体温度
|
realCap: [], // 单体实际容量
|
resCap: [], // 单体剩余容量
|
preCap: [] // 单体容量百分比
|
};
|
// 单体柱状信息
|
monBarData = {
|
vol: [], // 单体电压
|
temp: [], // 单体温度
|
realCap: [], // 单体实际容量
|
resCap: [], // 单体剩余容量
|
preCap: [], // 单体容量百分比
|
jh_curr: [], // 单体均衡电流
|
res: [], // 单体内阻
|
};
|
|
// 初始化图表的配置项
|
this.initChartOptions();
|
|
// 设置折线图
|
this.setLineChart();
|
|
// 设置柱状图
|
this.setBarChart();
|
},
|
initChartOptions() {
|
// 端电压折线图
|
groupVolLineChart = {
|
color: ["#0081ff", "#df9d02"],
|
title: {
|
show: false,
|
text: "端电压折线图(V)",
|
x: "left",
|
textStyle: {
|
fontSize: "14"
|
}
|
},
|
legend: {
|
show: false,
|
data: ["在线电压", "组端电压"],
|
right: 0,
|
orient: "vertical"
|
},
|
series: [{
|
name: "在线电压",
|
data: []
|
},
|
{
|
name: "组端电压",
|
data: []
|
}
|
]
|
};
|
|
// 电池电流折线图
|
currLineChart = {
|
title: {
|
show: false,
|
text: "电池电流折线图(A)",
|
x: "center",
|
textStyle: {
|
fontSize: "14"
|
}
|
},
|
series: [{
|
name: "电池电流",
|
areaStyle: {
|
color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [{
|
offset: 0,
|
color: '#00feff'
|
}, {
|
offset: 1,
|
color: 'transparent'
|
}])
|
},
|
data: []
|
}]
|
};
|
|
// 单体信息折线图
|
monLineChart = {
|
title: {
|
show: false,
|
text: "单体电压(V)",
|
x: "center",
|
textStyle: {
|
fontSize: "14"
|
}
|
},
|
series: []
|
};
|
|
|
// 图表类型
|
let chartInfo = this.getChartInfo();
|
let unit = chartInfo.unit;
|
let label = chartInfo.label;
|
// 单体信息柱状图
|
this.monBarTitle = "最大值=0" + unit + ";最小值=0" + unit + ";平均值=0" + unit;
|
monBarChart = {
|
title: {
|
show: false,
|
text: "最大值=0" + unit + ";最小值=0" + unit + ";平均值=0" + unit,
|
x: "center",
|
textStyle: {
|
fontSize: "14"
|
}
|
},
|
series: [{
|
name: "初始值",
|
hColor: '#0B388B',
|
data: []
|
},
|
{
|
name: label,
|
barGap: "-100%",
|
data: []
|
},
|
]
|
};
|
},
|
// 设置折线图
|
setLineChart() {
|
// 设置端电压折线图
|
this.setGroupVolLineChart();
|
// 设置电池电流折线图
|
this.setCurrLineChart();
|
// 设置单体折线图
|
this.setMonLineChart();
|
// 建立联动
|
this.$G.chartManage.connect(["groupVol", "groupCurr", "monInfo"]);
|
},
|
// 设置端电压折线图
|
setGroupVolLineChart() {
|
// 根据allData.groupVol数据设置groupVolLineChart的值
|
groupVolLineChart.series[0].data = allData.onlineVol;
|
groupVolLineChart.series[1].data = allData.groupVol;
|
let specialPoint = getSpecialPointIndex(allData.groupVol.map(item => {
|
return item[1];
|
}));
|
let markLine = {};
|
this.groupVolQth.code = specialPoint.code;
|
if (specialPoint.code && this.test_record.value[0] == "herongDischarge" && this.humpPotBottom) {
|
let batt = this.batt;
|
let qgth = getQgth(specialPoint, batt.MonVolStd * batt.MonCount);
|
this.groupVolTitle = qgth.title;
|
|
// 设置groupVolQth
|
this.groupVolQth.code = 1;
|
this.groupVolQth.low = specialPoint.minVal;
|
this.groupVolQth.lowTime = allData.groupVol[specialPoint.min][0];
|
this.groupVolQth.high = specialPoint.maxVal;
|
this.groupVolQth.highTime = allData.groupVol[specialPoint.max][0];
|
this.groupVolQth.qg = qgth.qg;
|
this.groupVolQth.qt = qgth.qt;
|
this.groupVolQth.qh = qgth.qh;
|
this.groupVolQth.title = qgth.label;
|
|
markLine = {
|
data: [{
|
label: {
|
show: true,
|
position: 'end',
|
formatter: [
|
'{a|Tg:' + allData.groupVol[specialPoint.min][0] + '}' + '{c|}',
|
'{b|锅底电压Vg:' + allData.groupVol[specialPoint.min][1] + 'V}' + '{c|}'
|
].join('\n'),
|
rich: {
|
a: {
|
|
},
|
b: {
|
|
},
|
c: {
|
width: 60
|
}
|
},
|
},
|
xAxis: allData.groupVol[specialPoint.min][0],
|
},
|
{
|
label: {
|
show: true,
|
position: 'end',
|
formatter: [
|
'{c|}' + '{a|Tt:' + allData.groupVol[specialPoint.max][0] + '}',
|
'{c|}' + '{b|驼峰电压Vt:' + allData.groupVol[specialPoint.max][1] + 'V}'
|
].join('\n'),
|
rich: {
|
a: {
|
|
},
|
b: {
|
|
},
|
c: {
|
width: 80,
|
}
|
},
|
},
|
xAxis: allData.groupVol[specialPoint.max][0],
|
}
|
]
|
};
|
} else {
|
this.groupVolTitle = "端电压折线图(V)";
|
}
|
groupVolLineChart.series[1].markLine = markLine;
|
// 更新图表
|
this.$refs.groupVol.setOption(groupVolLineChart);
|
},
|
// 设置电池电流折线图
|
setCurrLineChart() {
|
// 根据allData.testCurr数据设置currLineChart的值
|
currLineChart.series[0].data = allData.testCurr;
|
// 更新图表
|
this.$refs.groupCurr.setOption(currLineChart);
|
},
|
// 设置单体折线图
|
setMonLineChart() {
|
let chartInfo = this.getChartInfo();
|
// 根据monLineData的值设置monLineChart
|
let dataList = monLineData.vol;
|
let title = chartInfo.label + "(" + chartInfo.unit + ")";
|
let unit = chartInfo.unit;
|
let isUpdate = true;
|
switch (chartInfo.value) {
|
case "vol":
|
dataList = monLineData.vol;
|
break;
|
case "temp":
|
dataList = monLineData.temp;
|
break;
|
case "resCap":
|
dataList = monLineData.resCap;
|
break;
|
default:
|
isUpdate = false;
|
break;
|
}
|
// 检测是否更新
|
if (!isUpdate) {
|
return;
|
}
|
this.monInfo.title = title;
|
this.monInfo.unit = unit;
|
monLineChart.title.show = false;
|
monLineChart.series = dataList.map((item, index) => {
|
let monNum = "#" + (index + 1);
|
return {
|
name: monNum,
|
data: item
|
};
|
});
|
|
this.$nextTick(() => {
|
// 更新图表
|
this.$refs.monInfo.setOption(monLineChart);
|
});
|
},
|
// 设置柱状图
|
setBarChart() {
|
let chartInfo = this.getChartInfo();
|
let unit = chartInfo.unit;
|
let fixed = chartInfo.fixed;
|
// 根据monBarData的值设置monBarChart
|
let dataList = this.getBarDataList();
|
let index = this.getDataIndex(dataList.length, this.slider);
|
if (index != -1) {
|
let data = dataList[index];
|
let batNum = getBarNum(data);
|
monBarChart.title.show = false;
|
monBarChart.title.text = "最大值=" + batNum.max + unit + ";最小值=" + batNum.min + unit + ";平均值=" + batNum
|
.avg.toFixed(fixed) + unit
|
this.monBarTitle = monBarChart.title.text;
|
monBarChart.series[1].name = chartInfo.label;
|
monBarChart.series[1].data = data;
|
monBarChart.series[0].data = dataList[0];
|
} else {
|
console.log("未获取到值")
|
}
|
// 设置柱状图
|
this.$refs.monBar.setOption(monBarChart);
|
},
|
getBarDataList() {
|
let chartInfo = this.getChartInfo();
|
// 根据monBarData的值设置monBarChart
|
let dataList = monBarData.vol;
|
switch (chartInfo.value) {
|
case 'vol':
|
dataList = monBarData.vol;
|
break;
|
case 'temp':
|
dataList = monBarData.temp;
|
break;
|
case 'realCap':
|
dataList = monBarData.realCap;
|
break;
|
case 'resCap':
|
dataList = monBarData.resCap;
|
break;
|
case 'preCap':
|
dataList = monBarData.preCap;
|
break;
|
default:
|
dataList = monBarData.vol
|
break;
|
}
|
|
return dataList;
|
},
|
// 查询测试信息
|
searchBattTestData() {
|
let batt = this.batt;
|
// 开启等待框
|
let loading = this.$layer.loading(1);
|
searchBattTestData({
|
num: batt.FBSDeviceId,
|
BattGroupId: batt.BattGroupId
|
})
|
.then(res => {
|
// 关闭等待框
|
this.$layer.close(loading);
|
// 解析数据
|
let rs = JSON.parse(res.data.result);
|
let herongDischarge = []; // 核容放电
|
let herongCharge = []; // 核容充电
|
let jianceDischarge = []; // 监测放电
|
let jianceCharge = []; // 监测充电
|
if (rs.code == 1) {
|
rs.data.forEach(item => {
|
item.value = item.test_starttime;
|
item.label = item.test_starttime;
|
if (item.test_type == 3) {
|
// 测试类型为放电
|
if (item.test_starttype == 3) {
|
// 核容放电
|
herongDischarge.push(item);
|
} else {
|
// 监测放电
|
jianceDischarge.push(item);
|
}
|
} else if (item.test_type == 2) {
|
// 测试类型为充电
|
if (item.test_starttype == 3) {
|
// 核容充电
|
herongCharge.push(item);
|
} else {
|
// 监测充电
|
jianceCharge.push(item);
|
}
|
}
|
});
|
} else {
|
this.$layer.msg("未获取到充放电记录");
|
}
|
// 充放电记录
|
if(this.isAio) {
|
this.setAioTestRecord(herongDischarge, 0);
|
this.setAioTestRecord(jianceDischarge, 1);
|
this.setAioTestRecord(herongCharge, 2);
|
this.setAioTestRecord(jianceCharge, 3);
|
}else {
|
this.setNormalTestRecord(herongDischarge, jianceDischarge, herongCharge, jianceCharge);
|
}
|
})
|
.catch(error => {
|
this.$layer.close(loading);
|
console.log(error);
|
});
|
},
|
/**
|
* 设置普通类型充放电数据
|
*/
|
setNormalTestRecord(herongDischarge, jianceDischarge, herongCharge, jianceCharge) {
|
this.test_record.list[0].children = herongDischarge;
|
this.test_record.list[1].children = jianceDischarge;
|
this.test_record.list[2].children = herongCharge;
|
this.test_record.list[3].children = jianceCharge;
|
},
|
/**
|
* 设置A059充放电数据
|
*/
|
setAioTestRecord(data, index) {
|
data.map(item=>{
|
// 电池组1充放电数据
|
if(item.upload_client_type == 1) {
|
this.test_record1.list[0].children[index].children.push(item);
|
}else {
|
this.test_record1.list[1].children[index].children.push(item);
|
}
|
});
|
},
|
// 切换测试信息
|
testRecordChange() {
|
let testRecord = this.getTestRecord();
|
// 初始化图表
|
this.initChart();
|
// 已选择测试信息
|
if(testRecord != -1) {
|
let num = testRecord.record_num/this.show_num; // 根据粒度查询数据
|
// 查询历史数据
|
this.searchHistory(testRecord.BattGroupId, testRecord.test_record_count, num);
|
}
|
|
// 获取顶部电池组信息
|
// this.searchBattTestDataStop(
|
// testRecord.BattGroupId,
|
// testRecord.test_record_count
|
// );
|
},
|
// 查询顶部信息
|
searchBattTestDataStop(BattGroupId, count) {
|
searchBattTestDataStop(BattGroupId, count).then(res => {
|
let rs = JSON.parse(res.data.result);
|
if (rs.code == 1) {
|
let data = rs.data[0];
|
this.top.test_cap = data.test_cap.toFixed(1) + "AH";
|
this.top.test_long = formatSeconds(data.test_timelong);
|
}
|
});
|
},
|
// 查询历史信息
|
searchHistory(BattGroupId, count, num) {
|
this.loading = true;
|
this.$nextTick(() => {
|
searchHistory({
|
BattGroupId: BattGroupId,
|
test_record_count: count,
|
data_new: Math.floor(num)
|
}).then(res => {
|
this.loading = false;
|
let rs = JSON.parse(res.data.result);
|
let data = [];
|
// 数据
|
if (rs.code == 1) {
|
data = rs.data;
|
}
|
this.HistoryData = data
|
// 格式化数据
|
this.formateHisData(data);
|
this.searchBattresdata();
|
}).catch(error => {
|
this.loading = false;
|
console.log(error);
|
});
|
});
|
|
},
|
// 格式化历史信息数据
|
formateHisData(data) {
|
// let filterData = data.filter((item, i) => {
|
// if (item.record_num % this.show_num == 0) {
|
// return item
|
// }
|
// })
|
let record_time = -1; // 记录时间
|
let record_num = -100; // 记录笔数
|
allData.endData = data[data.length - 1];
|
data.forEach(item => {
|
let mon_num = item.mon_num;
|
let testTimeLong = formatSeconds(item.test_timelong);
|
// 获取组端电压，在线电压,组端电流的信息和开辟一个单体柱状图
|
if (record_num != item.record_num) {
|
record_time = item.record_time;
|
record_num = item.record_num;
|
allData.groupVol.push([testTimeLong, item.group_vol]);
|
allData.onlineVol.push([testTimeLong, item.online_vol]);
|
allData.testCurr.push([testTimeLong, item.test_curr]);
|
allData.recordTime.push(testTimeLong);
|
allData.testTimeLong.push(item.test_timelong);
|
allData.testCap.push(item.test_cap);
|
allData.dataList.push(item);
|
this.testTimeLong.push(item.test_timelong);
|
// 开辟空间
|
monBarData.vol.push([]);
|
monBarData.temp.push([]);
|
monBarData.realCap.push([]);
|
monBarData.resCap.push([]);
|
monBarData.preCap.push([]);
|
}
|
// 单体电压柱状图设置
|
let mon_num_text = "#" + mon_num;
|
let monBarVol = monBarData.vol[monBarData.vol.length - 1];
|
monBarVol.push([mon_num_text, item.mon_vol]);
|
|
// 单体温度柱状图
|
let monBarTemp = monBarData.temp[monBarData.temp.length - 1];
|
monBarTemp.push([mon_num_text, item.mon_tmp]);
|
|
// 设置单体折线图信息
|
if (typeof monLineData.vol[mon_num - 1] != "object") {
|
let index = mon_num - 1;
|
// 开辟空间
|
monLineData.vol[index] = [];
|
monLineData.temp[index] = [];
|
monLineData.resCap[index] = [];
|
}
|
// 获取到需要使用的空间
|
let monLineVol = monLineData.vol[mon_num - 1];
|
monLineVol.push([testTimeLong, item.mon_vol]);
|
|
let monLineTemp = monLineData.temp[mon_num - 1];
|
monLineTemp.push([testTimeLong, item.mon_tmp]);
|
});
|
|
// 初始化图表的配置项
|
this.initChartOptions();
|
|
// 设置容量
|
this.setCapList();
|
// 设置折线图表
|
this.setLineChart();
|
// 执行滑动事件
|
this.sliderInput();
|
},
|
setCapList() {
|
let batt = this.batt;
|
let batt_test_data = monBarData.vol;
|
let batt_test_evary_record = allData.dataList;
|
for (let i = 0; i < batt_test_data.length; i++) {
|
let vol_list = batt_test_data[i].map(item => {
|
return item[1];
|
});
|
let max_vol = Math.max.apply(null, vol_list);
|
for (let j = 0; j < vol_list.length; j++) {
|
let avg_curr = batt_test_evary_record[i].test_timelong > 0 ? batt_test_evary_record[i]
|
.test_cap * 3600 / batt_test_evary_record[i].test_timelong : batt_test_evary_record[i]
|
.test_curr;
|
let actionvalue = GetMonomerCap(batt.MonCapStd, GetHourRate(batt.MonCapStd, avg_curr),
|
batt_test_evary_record[i].test_cap, max_vol, vol_list[j], batt.MonVolStd, 1);
|
let restvalue = GetMonomerCap(batt.MonCapStd, GetHourRate(batt.MonCapStd, avg_curr),
|
batt_test_evary_record[i].test_cap, max_vol, vol_list[j], batt.MonVolStd, 0);
|
let batt_num_text = "#" + (j + 1);
|
monBarData.realCap[i].push([batt_num_text, actionvalue.toFixed(0)]);
|
monBarData.resCap[i].push([batt_num_text, restvalue.toFixed(0)]);
|
monBarData.preCap[i].push([batt_num_text, (actionvalue * 100 / batt.MonCapStd).toFixed(0)]);
|
}
|
}
|
// 容量
|
monLineData.vol.forEach((item, key) => {
|
item.forEach((volItem, volItemKey) => {
|
let resCapItem = monBarData.resCap[volItemKey];
|
if(resCapItem) {
|
monLineData.resCap[key].push([volItem[0], resCapItem[key][1]]);
|
}
|
});
|
});
|
},
|
// 获取测试的信息
|
getTestRecord() {
|
let value = this.test_record.value;
|
// A059设备
|
if(this.isAio) {
|
value = this.test_record1.value;
|
}
|
// 没有选择充放电记录,返回-1
|
if (value.length == 0) {
|
return -1;
|
}
|
let type = value[0];
|
let time = value[1];
|
let list = this.test_record.list;
|
// A059设备
|
if(this.isAio) {
|
value = this.test_record1.value;
|
let index = value[0];
|
type = value[1];
|
time = value[2];
|
list = this.test_record1.list[index].children;
|
}
|
let result = 0;
|
// 遍历list
|
for (let i in list) {
|
let item = list[i];
|
if (item.value == type) {
|
for (let j in item.children) {
|
let child = item.children[j];
|
if (child.value == time) {
|
result = child;
|
break;
|
}
|
}
|
break;
|
}
|
}
|
// 设置电池状态
|
this.battState.test_type = result.test_type;
|
this.battState.stop_reason = result.test_stoptype_reason;
|
// 返回结果集
|
return result;
|
},
|
// 格式化滑块显示的内容
|
formatTooltip(value) {
|
let testTimeLong = this.testTimeLong;
|
let index = this.getDataIndex(testTimeLong.length, value);
|
let test_long = formatSeconds(0);
|
if (index != -1) {
|
test_long = formatSeconds(testTimeLong[index]);
|
}
|
this.top.test_long = test_long;
|
return test_long;
|
},
|
// 拖动滑块时触发
|
sliderInput() {
|
// 设置头部信息
|
this.setTopData();
|
|
// 设置柱状图
|
this.setBarChart();
|
},
|
// 设置顶部文本框的数据
|
setTopData() {
|
let batt = this.batt;
|
// 组端电压和在线电压
|
let groupVol = allData.groupVol;
|
let onlineVol = allData.onlineVol;
|
let testCurr = allData.testCurr;
|
let testCap = allData.testCap;
|
let monVols = monBarData.vol;
|
let dataList = allData.dataList;
|
let index = this.getDataIndex(groupVol.length, this.slider);
|
if (index != -1) {
|
this.top.group =
|
"在线:" +
|
onlineVol[index][1].toFixed(2) +
|
"V；组端:" +
|
groupVol[index][1].toFixed(2) +
|
"V";
|
this.top.curr = testCurr[index][1].toFixed(1) + "A";
|
this.top.test_cap = testCap[index].toFixed(1) + "AH";
|
// 剩余容量
|
let monVol = monVols[index];
|
let list = dataList[index];
|
let avg_curr = list.test_timelong > 0 ? list.test_cap * 3600 / list.test_timelong : list.test_curr;
|
let batNum = getBarNum(monVol);
|
let over_cap = GetMonomerCap(batt.MonCapStd, GetHourRate(batt.MonCapStd, avg_curr),
|
list.test_cap, batNum.max, batNum.min, batt.MonVolStd, 0);
|
this.top.re_cap = over_cap.toFixed(1) + 'AH';
|
|
}
|
// 设置续航时长
|
let lastIndex = this.getDataIndex(groupVol.length, 100);
|
if (lastIndex != -1) {
|
// 实际容量
|
let monVol = monVols[lastIndex];
|
let list = dataList[lastIndex];
|
let avg_curr = list.test_timelong > 0 ? list.test_cap * 3600 / list.test_timelong : list.test_curr;
|
let batNum = getBarNum(monVol);
|
let real_cap = GetMonomerCap(batt.MonCapStd, GetHourRate(batt.MonCapStd, avg_curr),
|
list.test_cap, batNum.max, batNum.min, batt.MonVolStd, 1);
|
let xuhang = batt.Load_curr ? real_cap / batt.Load_curr : 0;
|
this.top.xuhang = xuhang ? sethoubeiTime(xuhang) : '---';
|
}
|
},
|
// 根据百分比获取显示的数据的笔数
|
getDataIndex(num, percent) {
|
if (percent <= 0) {
|
return 0;
|
}
|
return Math.floor(num * percent / 100) - 1;
|
},
|
// 向父级发送同步页面的指令
|
syncPage() {
|
let batt = this.batt;
|
let search = "?province=" + batt.StationName1 +
|
"&city=" + batt.StationName2 + "&county=" + batt.StationName5 +
|
"&home=" + batt.StationName3 + "&batt=" + batt.BattGroupId;
|
window.parent.postMessage({
|
cmd: "syncPage",
|
params: {
|
pageInfo: {
|
label: '实时监控',
|
name: 'movingRingSysteRrealTime',
|
src: '#/moving-ring-system' + search,
|
closable: true,
|
}
|
},
|
}, "*");
|
},
|
toShowComparison() {
|
this.showComparison = true;
|
},
|
getChartInfo() {
|
let chartType = this.chartType;
|
let chartTypes = this.chartTypes;
|
let chartTypeInfo = chartTypes[0];
|
for (let i = 0; i < chartTypes.length; i++) {
|
if (chartType == chartTypes[i].value) {
|
chartTypeInfo = chartTypes[i];
|
break;
|
}
|
}
|
return chartTypeInfo;
|
},
|
changeChartType() {
|
if (allData.groupVol.length == 0) {
|
this.initChart();
|
} else {
|
let loading = this.$layer.loading();
|
setTimeout(() => {
|
this.setBarChart();
|
this.setMonLineChart();
|
this.$layer.close(loading);
|
}, 100);
|
}
|
},
|
showDataDifferDialog() {
|
if (allData.groupVol.length == 0) {
|
this.$layer.msg('暂无数据导出,请先选择充放电数据！');
|
return false;
|
}
|
|
this.volDiffer = monLineData.vol;
|
this.tempDiffer = monLineData.temp;
|
this.$nextTick(()=>{
|
this.dataDiffter = true;
|
});
|
},
|
ensureExportExcel(data) {
|
// 关闭弹出框
|
this.dataDiffter = false;
|
// 定义导出
|
this.loading = true;
|
|
setTimeout(()=>{
|
// 对数据进行处理
|
this.$refs.splitTime.value = data.splitTime;
|
this.$refs.mon_vol_compare_pic.value = data.mon_vol_compare_pic;
|
this.$refs.mon_temp_compare_pic.value = data.mon_temp_compare_pic;
|
this.$refs.time_compare_list.value = data.time_compare_list;
|
this.$refs.mon_vol_compare_list.value = data.mon_vol_compare_list;
|
this.$refs.mon_tmp_compare_list.value = data.mon_tmp_compare_list;
|
this.$nextTick(()=>{
|
this.exportExcel();
|
this.loading = false;
|
});
|
}, 1000);
|
|
|
},
|
// 导出报表
|
exportExcel() {
|
|
if (allData.groupVol.length == 0) {
|
this.$layer.msg('暂无数据导出,请先选择充放电数据！');
|
return false;
|
}
|
let lastarray = new Array();
|
lastarray.push(allData.monNumList);
|
|
//组端电压折线图
|
let groupVolLineChartOption = this.$refs.groupVol.getOption(groupVolLineChart);
|
groupVolLineChartOption.title.show = true;
|
groupVolLineChartOption.title.x = 'center';
|
groupVolLineChartOption.legend.show = false;
|
this.createGraphByOpt(groupVolLineChartOption);
|
let oltop = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 电池电流折线图
|
let currLineChartOption = this.$refs.groupVol.getOption(currLineChart);
|
currLineChartOption.title.show = true;
|
currLineChartOption.title.x = 'center';
|
currLineChartOption.legend.show = false;
|
this.createGraphByOpt(currLineChartOption);
|
let ortop = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
//获取起始单体电压
|
lastarray.push(monBarData.vol[0].map(item => {
|
return item[1];
|
}));
|
|
|
//单体电压柱状图
|
let monBarVol = monBarData.vol;
|
let monBarEndVol = monBarVol[this.getDataIndex(monBarVol.length, this.slider)];
|
//获取单体截止电压
|
let monBarVolArr = monBarEndVol.map(item => {
|
return item[1];
|
});
|
lastarray.push(monBarVolArr);
|
monBarChart.title.show = true;
|
monBarChart.title.text = this.getTitle(monBarVolArr, 'Voltage');
|
let lowObj = Titleobj; //落后单体电压信息
|
monBarChart.title.x = 'center';
|
monBarChart.series[0].name = "单体电压";
|
monBarChart.series[0].data = monBarEndVol;
|
let monBarChartVolOption = this.$refs.monBar.getOption(monBarChart);
|
this.createGraphByOpt(monBarChartVolOption);
|
let orbottom1 = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
//单体实际容量柱状图
|
let monBarRealCap = monBarData.realCap;
|
let monBarRealCapEnd = monBarRealCap[this.getDataIndex(monBarRealCap.length, this.slider)];
|
let monBarRealCapArr = monBarRealCapEnd.map(item => {
|
return item[1];
|
});
|
lastarray.push(monBarRealCapArr);
|
let monRealCapNum = getBarNum(monBarRealCapEnd);
|
monBarChart.title.show = true;
|
monBarChart.title.text = this.getTitle(monBarRealCapArr, "Actual_capacity");
|
monBarChart.title.x = 'center';
|
monBarChart.series[0].name = "单体实际容量";
|
monBarChart.series[0].data = monBarRealCapEnd;
|
let monBarChartRealCapOption = this.$refs.monBar.getOption(monBarChart);
|
this.createGraphByOpt(monBarChartRealCapOption);
|
let orbottom2 = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
//单体剩余容量柱状图
|
let monBarResCap = monBarData.resCap;
|
let monBarResCapEnd = monBarResCap[this.getDataIndex(monBarResCap.length, this.slider)];
|
let monBarResCapArr = monBarResCapEnd.map(item => {
|
return item[1];
|
});
|
lastarray.push(monBarResCapArr);
|
monBarChart.title.show = true;
|
monBarChart.title.text = this.getTitle(monBarResCapArr, "Residual_capacity");
|
monBarChart.title.x = 'center';
|
monBarChart.series[0].name = "单体剩余容量";
|
monBarChart.series[0].data = monBarResCapEnd;
|
let monBarChartResCapOption = this.$refs.monBar.getOption(monBarChart);
|
this.createGraphByOpt(monBarChartResCapOption);
|
let orbottom3 = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
//单体容量百分比柱状图
|
let monBarPreCap = monBarData.preCap;
|
let monBarPreCapEnd = monBarPreCap[this.getDataIndex(monBarPreCap.length, this.slider)];
|
let monBarPreCapArr = monBarPreCapEnd.map(item => {
|
return item[1];
|
});
|
lastarray.push(monBarPreCapArr);
|
monBarChart.title.show = true;
|
monBarChart.title.text = this.getTitle(monBarPreCapArr, "Percent_total_capacity");
|
monBarChart.title.x = 'center';
|
monBarChart.series[0].name = "单体容量百分比";
|
monBarChart.series[0].data = monBarPreCapEnd;
|
let monBarChartPreCapOption = this.$refs.monBar.getOption(monBarChart);
|
this.createGraphByOpt(monBarChartPreCapOption);
|
let orbottom4 = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 单体电压折线图
|
monLineChart.title.show = true;
|
monLineChart.title.text = "单体电压(V)";
|
monLineChart.title.x = 'center';
|
monLineChart.series = monLineData.vol.map((item, index) => {
|
let monNum = "#" + (index + 1);
|
return {
|
name: monNum,
|
data: item
|
};
|
});
|
let monLineChartVolOption = this.$refs.groupVol.getOption(monLineChart);
|
this.createGraphByOpt(monLineChartVolOption);
|
let vol_line = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 单体温度折线图
|
monLineChart.title.show = true;
|
monLineChart.title.text = "单体温度(℃)";
|
monLineChart.title.x = 'center';
|
monLineChart.series = monLineData.temp.map((item, index) => {
|
let monNum = "#" + (index + 1);
|
return {
|
name: monNum,
|
data: item
|
};
|
});
|
let monLineChartTempOption = this.$refs.groupVol.getOption(monLineChart);
|
this.createGraphByOpt(monLineChartTempOption);
|
let tmp_line = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 单体剩余容量折线图
|
monLineChart.title.show = true;
|
monLineChart.title.text = "剩余容量(AH)";
|
monLineChart.title.x = 'center';
|
monLineChart.series = monLineData.resCap.map((item, index) => {
|
let monNum = "#" + (index + 1);
|
return {
|
name: monNum,
|
data: item
|
};
|
});
|
let monLineChartResCapOption = this.$refs.groupVol.getOption(monLineChart);
|
this.createGraphByOpt(monLineChartResCapOption);
|
let resCap_line = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 单体内阻
|
let monBarRes = monBarData.res;
|
let monBarResArr = monBarRes.map(item => {
|
return item[1];
|
});
|
monBarChart.title.show = true;
|
monBarChart.title.text = this.getTitle(monBarResArr, "Resistance");
|
monBarChart.title.x = 'center';
|
monBarChart.series[0].name = "单体内阻";
|
monBarChart.series[0].data = monBarRes;
|
monBarChart.series[1].name = "";
|
monBarChart.series[1].data = [];
|
let monBarResOption = this.$refs.monBar.getOption(monBarChart);
|
this.createGraphByOpt(monBarResOption);
|
let mon_res = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 单体均衡电流
|
let jhCurr = monBarData.jh_curr;
|
let jhCurrArr = jhCurr.map(item => {
|
return item[1];
|
});
|
let jhCurrNum = getBarNum(jhCurr);
|
monBarChart.title.show = true;
|
monBarChart.title.text = "最大值=" + jhCurrNum.max + "A;最小值=" + jhCurrNum.min + 'A;平局值=' + jhCurrNum.avg
|
.toFixed(0) + "A";
|
monBarChart.title.x = 'center';
|
monBarChart.series[0].name = "单体均衡电流";
|
monBarChart.series[0].data = jhCurr;
|
monBarChart.series[1].name = "";
|
monBarChart.series[1].data = [];
|
let jhCurrOption = this.$refs.monBar.getOption(monBarChart);
|
this.createGraphByOpt(jhCurrOption);
|
let JH_curr = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 终止单体电压
|
let endVolData = monBarData.vol[monBarData.vol.length - 1];
|
let endVolDataNum = getBarNum(endVolData);
|
monBarChart.title.show = true;
|
monBarChart.title.text = "最大值=" + endVolDataNum.max + "V;最小值=" + endVolDataNum.min + 'V;平局值=' +
|
endVolDataNum.avg.toFixed(2) + "V";
|
monBarChart.title.x = 'center';
|
monBarChart.series[0].name = "终止单体电压";
|
monBarChart.series[0].data = endVolData;
|
let endVolDataOption = this.$refs.monBar.getOption(monBarChart);
|
this.createGraphByOpt(endVolDataOption);
|
let last_vol = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 终止温度电压
|
let endTempData = monBarData.temp[monBarData.temp.length - 1];
|
let endTempDataNum = getBarNum(endTempData);
|
monBarChart.title.show = true;
|
monBarChart.title.text = "最大值=" + endTempDataNum.max + "℃;最小值=" + endTempDataNum.min + '℃;平局值=' +
|
endTempDataNum.avg.toFixed(0) + "℃";
|
monBarChart.title.x = 'center';
|
monBarChart.series[0].name = "终止单体温度";
|
monBarChart.series[0].data = endTempData;
|
let endTempDataOption = this.$refs.monBar.getOption(monBarChart);
|
this.createGraphByOpt(endTempDataOption);
|
let last_tmp = allGraph.getDataURL({
|
pixelRatio: 1,
|
backgroundColor: '#fff'
|
});
|
|
// 恢复name值
|
monBarChart.series[0].name = "初始值";
|
|
lastarray.push(monBarData.res.map(item => {
|
return item[1];
|
}));
|
|
lastarray.push(monBarData.temp[0].map(item => {
|
return item[1];
|
}));
|
|
lastarray.push(monBarData.temp[monBarData.temp.length - 1].map(item => {
|
return item[1];
|
}));
|
let batt = this.batt;
|
let testdata = allData.endData;
|
|
this.$refs.ltop_echart.value = oltop; // 组端电压折线图
|
this.$refs.rtop_echart.value = ortop; // 电池电流折线图
|
this.$refs.lbottom_echart.value = vol_line; // 单体电压折线图
|
this.$refs.rbottom_echart.value = orbottom1; //单体电压柱状图
|
this.$refs.actucap_echart.value = orbottom2; //单体实际容量
|
this.$refs.restcap_echart.value = orbottom3; //单体剩余容量
|
this.$refs.capperc_echart.value = orbottom4; //单体容量百分比
|
this.$refs.tmp_echart.value = tmp_line; // 单体温度
|
this.$refs.restcap_line_echart.value = resCap_line; // 剩余容量
|
this.$refs.mon_res.value = mon_res; // 单体内阻
|
this.$refs.JH_curr.value = JH_curr; // 单体均衡电流
|
this.$refs.last_vol.value = last_vol; // 终止单体电压柱状图
|
this.$refs.last_tmp.value = last_tmp; // 终止单体温度柱状图
|
let top_cause = this.battState.stop_reason;
|
batt.StationIp = top_cause;
|
this.$refs.obj_bmd.value = JSON.stringify({
|
binf: batt,
|
sdata: testdata
|
});
|
this.$refs.obj_title.value = JSON.stringify(lowObj);
|
this.$refs.arr_data.value = JSON.stringify(lastarray);
|
let batt_test_data = monBarData.vol.map(item => {
|
return item.map(item2 => {
|
return item2[1];
|
})
|
});
|
this.$refs.mon_vol_list.value = JSON.stringify(batt_test_data);
|
let batt_test_tmpdata = monLineData.temp.map(item => {
|
return item.map(item2 => {
|
return item2[1];
|
})
|
});
|
this.$refs.mon_tmp_list.value = JSON.stringify(batt_test_tmpdata);
|
this.$refs.mon_group_list.value = JSON.stringify(allData.dataList);
|
this.$refs.group_vol_qth.value = JSON.stringify(this.groupVolQth);
|
|
this.$refs.all_picture.submit();
|
|
},
|
createGraphByOpt(opt) {
|
allGraph.clear();
|
let lineStyle = {
|
color: "#000"
|
};
|
|
// 设置x轴的颜色
|
if(opt.xAxis[0].axisLine) {
|
opt.xAxis[0].axisLine.lineStyle = lineStyle;
|
}else {
|
opt.xAxis[0].axisLine = {
|
lineStyle,
|
};
|
}
|
|
// 设置x轴刻度的值
|
if(opt.xAxis[0].axisLabel) {
|
opt.xAxis[0].axisLabel.color = "#000";
|
}else {
|
opt.xAxis[0].axisLabel = {
|
color: "#000",
|
};
|
}
|
|
// 设置y轴的颜色
|
if(opt.yAxis[0].axisLine) {
|
opt.yAxis[0].axisLine.lineStyle = lineStyle;
|
}else {
|
opt.yAxis[0].axisLine = {
|
lineStyle,
|
};
|
}
|
|
// 设置y轴刻度的值
|
if(opt.yAxis[0].axisLabel) {
|
opt.yAxis[0].axisLabel.color = "#000";
|
}else {
|
opt.yAxis[0].axisLabel = {
|
color: "#000",
|
};
|
}
|
opt.animation = false;
|
allGraph.setOption(opt);
|
},
|
// 设置内阻信息
|
searchBattresdata() {
|
let batt = this.batt;
|
searchBattresdata(batt.BattGroupId).then(res => {
|
let rs = JSON.parse(res.data.result);
|
if (rs.code == 1) {
|
let data = rs.data;
|
for (let i = 0; i < data.length; i++) {
|
let item = data[i];
|
let battNumText = '#' + item.mon_num;
|
monBarData.jh_curr.push([battNumText, item.mon_JH_curr]);
|
monBarData.res.push([battNumText, item.mon_res]);
|
}
|
}
|
}).catch(error => {
|
console.log(error);
|
});
|
},
|
getTitle(array, units) {
|
let getLow = this.getLow;
|
var title = "";
|
//a=new Title();
|
//alert(Titleobj);
|
Titleobj = new Title();
|
var sum = 0;
|
if (array != undefined && array.length > 0) {
|
Titleobj.setMax(Math.max.apply(null, array));
|
Titleobj.setMin(Math.min.apply(null, array));
|
for (var i = 0; i < array.length; i++) {
|
sum += parseFloat(array[i]);
|
}
|
var batt = this.batt;
|
//console.info(batt);
|
if ("Resistance" == units) {
|
Titleobj.setAvg((sum / array.length).toFixed(3));
|
var low = getLow(3, 2);
|
if (low.low_method == 0) {
|
//根据标称值计算
|
Titleobj.setAlow(((2 - low.low_value) * batt.MonResStd).toFixed(3));
|
low = getLow(3, 3);
|
Titleobj.setClow(((2 - low.low_value) * batt.MonResStd).toFixed(3));
|
} else {
|
//根据平均值计算
|
Titleobj.setAlow(((2 - low.low_value) * Titleobj.getAvg()).toFixed(3));
|
low = getLow(3, 3);
|
Titleobj.setClow(((2 - low.low_value) * Titleobj.getAvg()).toFixed(3));
|
}
|
var count = 0;
|
for (var i = 0; i < array.length; i++) {
|
if (parseFloat(Titleobj.getAlow()) < parseFloat(array[i])) {
|
//console.info(title.getAlow()+"<"+array[i]);
|
count++;
|
}
|
}
|
Titleobj.setLc(count);
|
Titleobj.setLp((count * 100 / array.length).toFixed(1));
|
//console.info(title);
|
} else {
|
if ("Voltage" == units) {
|
Titleobj.setAvg((sum / array.length).toFixed(3));
|
var low = getLow(1, 1);
|
if (low.low_method == 0) {
|
//根据标称值计算
|
Titleobj.setAlow((low.low_value * batt.MonVolStd).toFixed(3));
|
low = getLow(1, 0);
|
Titleobj.setClow((low.low_value * batt.MonVolStd).toFixed(3));
|
} else {
|
//根据平均值计算
|
Titleobj.setAlow((low.low_value * Titleobj.getAvg()).toFixed(3));
|
low = getLow(1, 0);
|
Titleobj.setClow((low.low_value * Titleobj.getAvg()).toFixed(3));
|
}
|
} else if ("Temperature" == units) {
|
Titleobj.setAvg((sum / array.length).toFixed(1));
|
var low = getLow(1, 1);
|
if (low.low_method == 0) {
|
//根据标称值计算
|
Titleobj.setAlow((low.low_value * batt.MonTmpStd).toFixed(1));
|
low = getLow(1, 0);
|
Titleobj.setClow((low.low_value * batt.MonTmpStd).toFixed(1));
|
} else {
|
//根据平均值计算
|
Titleobj.setAlow((low.low_value * Titleobj.getAvg()).toFixed(1));
|
low = getLow(1, 0);
|
Titleobj.setClow((low.low_value * Titleobj.getAvg()).toFixed(1));
|
}
|
} else if ("Conductance" == units) {
|
Titleobj.setAvg((sum / array.length).toFixed(0));
|
var low = getLow(3, 2);
|
if (low.low_method == 0) {
|
//根据标称值计算
|
Titleobj.setAlow((low.low_value * batt.MonSerStd).toFixed(0));
|
low = getLow(3, 3);
|
Titleobj.setClow((low.low_value * batt.MonSerStd).toFixed(0));
|
} else {
|
//根据平均值计算
|
Titleobj.setAlow((low.low_value * Titleobj.getAvg()).toFixed(0));
|
low = getLow(3, 3);
|
Titleobj.setClow((low.low_value * Titleobj.getAvg()).toFixed(0));
|
}
|
} else if ("Actual_capacity" == units) {
|
Titleobj.setAvg((sum / array.length).toFixed(0));
|
var low = getLow(2, 2);
|
if (low.low_method == 0) {
|
//根据标称值计算
|
Titleobj.setAlow((low.low_value * batt.MonCapStd).toFixed(0));
|
//console.info(batt);
|
low = getLow(2, 3);
|
Titleobj.setClow((low.low_value * batt.MonCapStd).toFixed(0));
|
} else {
|
//根据平均值计算
|
Titleobj.setAlow((low.low_value * Titleobj.getAvg()).toFixed(0));
|
low = getLow(2, 3);
|
Titleobj.setClow((low.low_value * Titleobj.getAvg()).toFixed(0));
|
}
|
} else if ("Residual_capacity" == units) {
|
Titleobj.setAvg((sum / array.length).toFixed(0));
|
var low = getLow(1, 1);
|
if (low.low_method == 0) {
|
//根据标称值计算
|
Titleobj.setAlow((low.low_value * Titleobj.getAvg()).toFixed(0));
|
//console.info(batt);
|
low = getLow(1, 0);
|
Titleobj.setClow((low.low_value * Titleobj.getAvg()).toFixed(0));
|
} else {
|
//根据平均值计算
|
Titleobj.setAlow((low.low_value * Titleobj.getAvg()).toFixed(0));
|
//console.info(batt);
|
low = getLow(1, 0);
|
Titleobj.setClow((low.low_value * Titleobj.getAvg()).toFixed(0));
|
}
|
|
} else if ("Percent_total_capacity" == units) {
|
Titleobj.setAvg((sum / array.length).toFixed(2));
|
var low = getLow(2, 2);
|
if (low.low_method == 0) {
|
//根据标称值计算
|
Titleobj.setAlow((low.low_value * batt.MonCapStd).toFixed(2));
|
//console.info(batt);
|
low = getLow(2, 3);
|
Titleobj.setClow((low.low_value * batt.MonCapStd).toFixed(2));
|
} else {
|
//根据平均值计算
|
Titleobj.setAlow((low.low_value * Titleobj.getAvg()).toFixed(2));
|
low = getLow(2, 3);
|
Titleobj.setClow((low.low_value * Titleobj.getAvg()).toFixed(2));
|
}
|
} else if ("MonJHCurr" == units) {
|
//单体均衡
|
Titleobj.setAvg((sum / array.length).toFixed(2));
|
}
|
var count = 0;
|
for (var i = 0; i < array.length; i++) {
|
if (parseFloat(Titleobj.getAlow()) > parseFloat(array[i])) {
|
count++;
|
}
|
}
|
Titleobj.setLc(count);
|
Titleobj.setLp((count * 100 / array.length).toFixed(1));
|
}
|
|
//console.info(Title);
|
title = Titleobj.getAllTile(units);
|
}
|
return title;
|
},
|
searchAll_lowAction() {
|
searchAll_lowAction().then(res => {
|
let rs = JSON.parse(res.data.result);
|
if (rs.code == 1) {
|
this.low_list = rs.data;
|
}
|
}).catch(error => {
|
console.log(error);
|
});
|
},
|
getLow(lowtype, lownametype) {
|
let low_list = this.low_list;
|
if (lowtype != undefined && low_list != undefined && lownametype != undefined) {
|
for (var i = 0; i < low_list.length; i++) {
|
if (lowtype == low_list[i].low_type && lownametype == low_list[i].low_nametype) {
|
return low_list[i];
|
}
|
}
|
}
|
},
|
// 添加标准曲线
|
confirmAddStandardLine() {
|
// 电池信息
|
let batt = this.batt;
|
// 记录信息
|
let testRecord = this.getTestRecord();
|
if (testRecord != -1) {
|
if (testRecord.test_type != 3) {
|
this.$layer.msg('请选择放电数据');
|
return;
|
}
|
//单体电压柱状图
|
let monBarVol = monBarData.vol;
|
let monBarEndVol = monBarVol[this.getDataIndex(monBarVol.length, 100)];
|
let minInfo = getMaxInfo(monBarEndVol.map(item=>{
|
return item[1];
|
}));
|
let note = Math.abs(testRecord.test_cap / (testRecord.test_timelong / 3600));
|
note = note?(batt.MonCapStd/note).toFixed(0):0;
|
if(note == 0) {
|
this.$layer.msg('数据异常，请添加其他数据！');
|
return;
|
}
|
let searchParams = {
|
BattgroupId: batt.BattGroupId,
|
test_record_count: testRecord.test_record_count,
|
monvolstd: batt.MonVolStd,
|
moncapstd: batt.MonCapStd,
|
note: Math.abs(note),
|
battproducer: batt.BattProducer,
|
battmodel: batt.BattModel,
|
mon_num: minInfo.key+1,
|
};
|
const h = this.$createElement;
|
this.$confirm(h('div', null, [
|
h('p', null, '标称容量：' + searchParams.moncapstd + "AH"),
|
h('p', null, '标称电压：' + searchParams.monvolstd + "V"),
|
h('p', null, '电池品牌：' + searchParams.battproducer),
|
h('p', null, '电池型号：' + searchParams.battmodel),
|
h('p', null, '小时率：' + searchParams.note),
|
]), "添加标准曲线", {
|
type: 'null',
|
}).then(() => {
|
this.addStandardLine(searchParams);
|
}).catch(() => {});
|
} else {
|
this.$layer.msg('暂无放电数据,请先选择充放电数据！');
|
}
|
},
|
addStandardLine(params) {
|
// 添加标准曲线
|
this.$apis.dataTest.history.addStandardLine(params).then(res => {
|
let rs = JSON.parse(res.data.result);
|
if (rs.code == 1) {
|
this.$layer.msg("添加标准曲线成功");
|
} else {
|
this.$layer.msg("添加标准曲线失败");
|
}
|
}).catch(error => {
|
console.log(error);
|
});
|
},
|
searchHistorySetting() {
|
this.$apis.pageSetting.realTime.searchParam({
|
categoryId: 11
|
}).then(res=>{
|
let rs = JSON.parse(res.data.result);
|
if(rs.code == 1 && rs.data.length != 0) {
|
let data = rs.data[0];
|
// 驼峰锅底
|
this.humpPotBottom = data.status?true:false;
|
// 显示粒度
|
let data1 = rs.data[1];
|
this.show_num = data1.status;
|
}else {
|
this.humpPotBottom = false;
|
this.show_num = 5;
|
}
|
}).catch(error=>{
|
this.humpPotBottom = false;
|
this.show_num = 5;
|
console.log(error);
|
});
|
}
|
},
|
computed: {
|
battFullName() {
|
let batt = this.batt;
|
if (batt.StationName && batt.BattGroupName) {
|
return batt.StationName + "-" + batt.BattGroupName;
|
}
|
return "电池组全称";
|
},
|
formateBattState() {
|
let battState = this.battState;
|
if (battState.test_type == 3) {
|
return "放电(终止原因：" + battState.stop_reason + ")";
|
} else if (battState.test_type == 2) {
|
return "充电"
|
} else {
|
return "";
|
}
|
},
|
isAio() {
|
// A059设备
|
let batt = this.batt;
|
return regEquipType(batt.FBSDeviceId, ["aio"]);
|
}
|
},
|
mounted() {
|
// 初始化图表
|
this.initChart();
|
this.searchAll_lowAction();
|
this.searchHistorySetting();
|
// 基于准备好的dom，初始化echarts实例
|
allGraph = ECharts.init(this.$refs.allGraph, 'transparent');
|
// 屏幕缩放时触发
|
window.addEventListener("resize", () => {
|
this.resize();
|
});
|
}
|
};
|
</script>
|
|
<style scoped>
|
.page-history {
|
color: #ffffff;
|
}
|
|
.table-cell.text-right {
|
font-size: 14px;
|
}
|
|
.table-row .table-cell {
|
padding-top: 12px;
|
}
|
|
.page-content {
|
position: relative;
|
padding-top: 8px;
|
padding-bottom: 2px;
|
box-sizing: border-box;
|
height: 100%;
|
}
|
|
.history-list {
|
position: absolute;
|
top: 8px;
|
left: 24px;
|
z-index: 99;
|
}
|
|
.flex-box-list {
|
display: flex;
|
flex-direction: row;
|
height: 50%;
|
box-sizing: border-box;
|
}
|
|
.page-content .flex-box {
|
flex: 1;
|
overflow-x: hidden;
|
}
|
|
.slider-container {
|
padding-left: 16px;
|
padding-right: 16px;
|
overflow: hidden;
|
}
|
|
.box-tools {
|
line-height: 32px;
|
}
|
|
.box-tools .iconfont {
|
font-size: 20px;
|
}
|
|
.box-tools .iconfont:hover {
|
cursor: pointer;
|
color: #cfcfcf;
|
}
|
|
.box-tools .iconfont:active {
|
color: #FF0000;
|
}
|
|
.chart-wrapper {
|
position: relative;
|
box-sizing: border-box;
|
margin: 0 16px;
|
height: 100%;
|
padding: 12px;
|
background-image: radial-gradient(#151f4140, #3667ec40);
|
}
|
|
.chart-wrapper:before,
|
.chart-wrapper:after,
|
.chart-wrapper-corner {
|
position: absolute;
|
display: inline-block;
|
content: " ";
|
width: 18px;
|
height: 18px;
|
}
|
|
.chart-wrapper:before {
|
left: 0;
|
top: 0;
|
border-top: 2px solid #00FEFF;
|
border-left: 2px solid #00FEFF;
|
}
|
|
.chart-wrapper:after {
|
left: 0;
|
bottom: 0;
|
border-bottom: 2px solid #00FEFF;
|
border-left: 2px solid #00FEFF;
|
}
|
|
.chart-wrapper-corner.top-right {
|
top: 0;
|
right: 0;
|
border-top: 2px solid #00FEFF;
|
border-right: 2px solid #00FEFF;
|
}
|
|
.chart-wrapper-corner.bottom-right {
|
bottom: 0;
|
right: 0;
|
border-bottom: 2px solid #00FEFF;
|
border-right: 2px solid #00FEFF;
|
}
|
|
.chart-tools-wrapper {
|
position: absolute;
|
top: 12px;
|
right: 12px;
|
z-index: 99;
|
}
|
|
#allGraph {
|
position: absolute;
|
top: -1000px;
|
left: 0;
|
width: 600px;
|
height: 400px;
|
}
|
|
.chart-contain {
|
width: 100%;
|
height: 100%;
|
background-color: #FFFFFF;
|
}
|
|
.chart {
|
width: 100%;
|
height: 100%;
|
}
|
</style>
|
