2768 lines
124 KiB
Vue
2768 lines
124 KiB
Vue
<template>
|
|
<div element-loading-text="数据加载中" v-loading="loading">
|
|
<div class="container" id="container">
|
|
<!-- <Muentree ref="treem" v-show="false"></Muentree> -->
|
|
<i @click="closeHandle" class="el-icon-circle-close coles"></i>
|
|
<el-form :inline="true" label-width="90px" class="">
|
|
<el-form-item label="指标类型:">
|
|
<el-select
|
|
v-model="condition"
|
|
multiple
|
|
collapse-tags
|
|
:multiple-limit="limit"
|
|
filterable
|
|
placeholder="请选择指标"
|
|
>
|
|
<el-option-group v-for="group in options" :key="group.label" :label="group.label">
|
|
<el-option
|
|
v-for="item in group.options"
|
|
:key="item.value"
|
|
:label="item.label"
|
|
:value="item.value"
|
|
></el-option>
|
|
</el-option-group>
|
|
</el-select>
|
|
</el-form-item>
|
|
<el-form-item label="值类型:">
|
|
<el-select v-model="formData.valueType" placeholder="请选择类型">
|
|
<el-option
|
|
v-for="item in typeoptions"
|
|
:key="item.value"
|
|
:label="item.label"
|
|
:value="item.value"
|
|
></el-option>
|
|
</el-select>
|
|
</el-form-item>
|
|
<el-form-item label="谐波次数:" v-show="xb">
|
|
<el-select v-model="formData.harmonic" placeholder="请选择谐波">
|
|
<el-option
|
|
v-for="item in harmonicoptions"
|
|
:key="item.value"
|
|
:label="item.label"
|
|
:value="item.value"
|
|
></el-option>
|
|
</el-select>
|
|
</el-form-item>
|
|
<!-- <el-form-item label="CVT型号:" v-show="condition.includes('40')">
|
|
|
|
<el-select v-model="cvt" value-key="value" clearable filterable placeholder="请选择CVT型号">
|
|
<el-option
|
|
v-for="item in cvtList"
|
|
:key="item.value"
|
|
:label="item.label"
|
|
:value="item"
|
|
></el-option>
|
|
</el-select>
|
|
</el-form-item> -->
|
|
<el-form-item v-show="jxb" label="间谐波次数:">
|
|
<el-select v-model="formData.inHarmonic" placeholder="请选择间谐波">
|
|
<el-option
|
|
v-for="item in inharmonicoptions"
|
|
:key="item.value"
|
|
:label="item.label"
|
|
:value="item.value"
|
|
></el-option>
|
|
</el-select>
|
|
</el-form-item>
|
|
</el-form>
|
|
</div>
|
|
<el-form :inline="true" :model="formData" class="demo-form-inline">
|
|
<el-form-item>
|
|
<timeindex
|
|
ref="chilenform"
|
|
@querfromdata="querfromdata"
|
|
:interval="interval"
|
|
:treenode="treenode"
|
|
:dataTree="dataTree"
|
|
></timeindex>
|
|
</el-form-item>
|
|
<el-form-item>
|
|
<el-button type="primary" @click="querfromdatad" icon="el-icon-search">查询</el-button>
|
|
</el-form-item>
|
|
<el-form-item>
|
|
<el-button type="text" @click="closeHandle">
|
|
条件筛选
|
|
<i :class="!view ? 'el-icon-arrow-down' : 'el-icon-arrow-right'"></i>
|
|
</el-button>
|
|
</el-form-item>
|
|
<!-- <el-form-item>
|
|
<el-button type="primary" size="" @click="timechange" icon="el-icon-caret-bottom" round plain>条件筛选</el-button>
|
|
</el-form-item> -->
|
|
</el-form>
|
|
<el-row
|
|
ref="tubiao"
|
|
id="tubiao"
|
|
:gutter="10"
|
|
style="overflow:scroll;height:calc(100vh - 195px);cursor:pointer;scrollbar-arrow-color:#302D30;'"
|
|
>
|
|
<el-col :span="24" v-for="(item, index) in list" :key="index" style="margin-top: 10px">
|
|
<div ref="kk" :id="item.id" style="'width:100%;background:#fff;height:calc(100vh - 100px);"></div>
|
|
</el-col>
|
|
</el-row>
|
|
</div>
|
|
</template>
|
|
<script>
|
|
import Muentree from '@/views/cgy-components/menuTree/index1'
|
|
import timeindex from '@/views/cgy-components/TimePicker/timeindext'
|
|
import api from '@/api/harmonic/onlineData'
|
|
import yan from '@/assets/commjs/color'
|
|
import { cvtList } from './cvtList.js'
|
|
|
|
//import qsdata from "@/views/components/data1";
|
|
export default {
|
|
components: {
|
|
timeindex,
|
|
Muentree
|
|
},
|
|
data() {
|
|
return {
|
|
cvtList: cvtList,
|
|
//指标
|
|
node: [],
|
|
arr: [],
|
|
view: false,
|
|
activeNames: ['0'],
|
|
loading: false,
|
|
Traceability: [],
|
|
url: require('@/assets/point.png'),
|
|
cvt: {},
|
|
options: [
|
|
{
|
|
label: '电压趋势',
|
|
options: [
|
|
{
|
|
value: '10',
|
|
label: '相电压有效值'
|
|
},
|
|
{
|
|
value: '11',
|
|
label: '线电压有效值'
|
|
},
|
|
{
|
|
value: '12',
|
|
label: '电压偏差'
|
|
},
|
|
{
|
|
value: '13',
|
|
label: '三相电压不平衡'
|
|
},
|
|
{
|
|
value: '14',
|
|
label: '电压不平衡'
|
|
},
|
|
{
|
|
value: '15',
|
|
label: '电压总谐波畸变率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '电流趋势',
|
|
options: [
|
|
{
|
|
value: '20',
|
|
label: '电流有效值'
|
|
},
|
|
{
|
|
value: '21',
|
|
label: '电流总谐波畸变率'
|
|
},
|
|
{
|
|
value: '22',
|
|
label: '负序电流'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '频率趋势',
|
|
options: [
|
|
{
|
|
value: '30',
|
|
label: '频率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '谐波趋势',
|
|
options: [
|
|
{ value: '39', label: '谐波电流定位' },
|
|
{
|
|
value: '40',
|
|
label: '谐波电压含有率'
|
|
},
|
|
{
|
|
value: '43',
|
|
label: '谐波电流幅值'
|
|
},
|
|
{
|
|
value: '44',
|
|
label: '谐波电压相角'
|
|
},
|
|
{
|
|
value: '45',
|
|
label: '谐波电流相角'
|
|
},
|
|
{
|
|
value: '46',
|
|
label: '间谐波电压含有率'
|
|
},
|
|
// {
|
|
// value: '47',
|
|
// label: '间谐波电流含有率'
|
|
// },
|
|
// {
|
|
// value: '48',
|
|
// label: '间谐波电压幅值'
|
|
// },
|
|
{
|
|
value: '49',
|
|
label: '间谐波电流幅值'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '功率趋势',
|
|
options: [
|
|
{
|
|
value: '50',
|
|
label: '谐波有功功率'
|
|
},
|
|
{
|
|
value: '51',
|
|
label: '谐波无功功率'
|
|
},
|
|
{
|
|
value: '52',
|
|
label: '谐波视在功率'
|
|
},
|
|
{
|
|
value: '53',
|
|
label: '三相有功功率'
|
|
},
|
|
{
|
|
value: '54',
|
|
label: '三相无功功率'
|
|
},
|
|
{
|
|
value: '55',
|
|
label: '三相视在功率'
|
|
},
|
|
{
|
|
value: '56',
|
|
label: '三相总有功功率'
|
|
},
|
|
{
|
|
value: '57',
|
|
label: '三相总无功功率'
|
|
},
|
|
{
|
|
value: '58',
|
|
label: '三相总视在功率'
|
|
},
|
|
{
|
|
value: '59',
|
|
label: '视在功率因数'
|
|
},
|
|
{
|
|
value: '591',
|
|
label: '位移功率因数'
|
|
},
|
|
{
|
|
value: '592',
|
|
label: '总视在功率因数'
|
|
},
|
|
{
|
|
value: '593',
|
|
label: '总位移功率因数'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '闪变趋势',
|
|
options: [
|
|
{
|
|
value: '60',
|
|
label: '短时电压闪变'
|
|
},
|
|
{
|
|
value: '61',
|
|
label: '长时电压闪变'
|
|
},
|
|
{
|
|
value: '62',
|
|
label: '电压波动'
|
|
}
|
|
]
|
|
}
|
|
],
|
|
options1: [
|
|
{
|
|
label: '电压趋势',
|
|
options: [
|
|
{
|
|
value: '11',
|
|
label: '线电压有效值'
|
|
},
|
|
{
|
|
value: '12',
|
|
label: '电压偏差'
|
|
},
|
|
{
|
|
value: '15',
|
|
label: '电压总谐波畸变率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '电流趋势',
|
|
options: [
|
|
{
|
|
value: '20',
|
|
label: '电流有效值'
|
|
},
|
|
{
|
|
value: '21',
|
|
label: '电流总谐波畸变率'
|
|
},
|
|
{
|
|
value: '22',
|
|
label: '负序电流'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '频率趋势',
|
|
options: [
|
|
{
|
|
value: '30',
|
|
label: '频率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '谐波趋势',
|
|
options: [
|
|
{ value: '39', label: '谐波电流定位' },
|
|
{
|
|
value: '40',
|
|
label: '谐波电压含有率'
|
|
},
|
|
{
|
|
value: '43',
|
|
label: '谐波电流幅值'
|
|
},
|
|
{
|
|
value: '46',
|
|
label: '间谐波电压含有率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '功率趋势',
|
|
options: [
|
|
{
|
|
value: '56',
|
|
label: '三相总有功功率'
|
|
},
|
|
{
|
|
value: '57',
|
|
label: '三相总无功功率'
|
|
},
|
|
{
|
|
value: '58',
|
|
label: '三相总视在功率'
|
|
},
|
|
{
|
|
value: '59',
|
|
label: '视在功率因数'
|
|
},
|
|
{
|
|
value: '591',
|
|
label: '位移功率因数'
|
|
},
|
|
{
|
|
value: '592',
|
|
label: '总视在功率因数'
|
|
},
|
|
{
|
|
value: '593',
|
|
label: '总位移功率因数'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '闪变趋势',
|
|
options: [
|
|
{
|
|
value: '60',
|
|
label: '短时电压闪变'
|
|
},
|
|
{
|
|
value: '61',
|
|
label: '长时电压闪变'
|
|
},
|
|
{
|
|
value: '62',
|
|
label: '电压波动'
|
|
}
|
|
]
|
|
}
|
|
],
|
|
options2: [
|
|
{
|
|
label: '电压趋势',
|
|
options: [
|
|
{
|
|
value: '11',
|
|
label: '线电压有效值'
|
|
},
|
|
{
|
|
value: '12',
|
|
label: '电压偏差'
|
|
},
|
|
{
|
|
value: '15',
|
|
label: '电压总谐波畸变率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '电流趋势',
|
|
options: [
|
|
{
|
|
value: '20',
|
|
label: '电流有效值'
|
|
},
|
|
{
|
|
value: '21',
|
|
label: '电流总谐波畸变率'
|
|
},
|
|
{
|
|
value: '22',
|
|
label: '负序电流'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '频率趋势',
|
|
options: [
|
|
{
|
|
value: '30',
|
|
label: '频率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '谐波趋势',
|
|
options: [
|
|
{ value: '39', label: '谐波电流定位' },
|
|
{
|
|
value: '40',
|
|
label: '谐波电压含有率'
|
|
},
|
|
{
|
|
value: '43',
|
|
label: '谐波电流幅值'
|
|
},
|
|
|
|
{
|
|
value: '46',
|
|
label: '间谐波电压含有率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '功率趋势',
|
|
options: [
|
|
{
|
|
value: '56',
|
|
label: '三相总有功功率'
|
|
},
|
|
{
|
|
value: '57',
|
|
label: '三相总无功功率'
|
|
},
|
|
{
|
|
value: '58',
|
|
label: '三相总视在功率'
|
|
},
|
|
{
|
|
value: '59',
|
|
label: '视在功率因数'
|
|
},
|
|
{
|
|
value: '591',
|
|
label: '位移功率因数'
|
|
},
|
|
{
|
|
value: '592',
|
|
label: '总视在功率因数'
|
|
},
|
|
{
|
|
value: '593',
|
|
label: '总位移功率因数'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '闪变趋势',
|
|
options: [
|
|
{
|
|
value: '60',
|
|
label: '短时电压闪变'
|
|
},
|
|
{
|
|
value: '61',
|
|
label: '长时电压闪变'
|
|
},
|
|
{
|
|
value: '62',
|
|
label: '电压波动'
|
|
}
|
|
]
|
|
}
|
|
],
|
|
options3: [
|
|
{
|
|
label: '电压趋势',
|
|
options: [
|
|
{
|
|
value: '10',
|
|
label: '相电压有效值'
|
|
},
|
|
{
|
|
value: '11',
|
|
label: '线电压有效值'
|
|
},
|
|
{
|
|
value: '12',
|
|
label: '电压偏差'
|
|
},
|
|
{
|
|
value: '13',
|
|
label: '三相电压不平衡'
|
|
},
|
|
{
|
|
value: '14',
|
|
label: '电压不平衡'
|
|
},
|
|
{
|
|
value: '15',
|
|
label: '电压总谐波畸变率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '电流趋势',
|
|
options: [
|
|
{
|
|
value: '20',
|
|
label: '电流有效值'
|
|
},
|
|
{
|
|
value: '21',
|
|
label: '电流总谐波畸变率'
|
|
},
|
|
{
|
|
value: '22',
|
|
label: '负序电流'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '频率趋势',
|
|
options: [
|
|
{
|
|
value: '30',
|
|
label: '频率'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '谐波趋势',
|
|
options: [
|
|
{ value: '39', label: '谐波电流定位' },
|
|
{
|
|
value: '40',
|
|
label: '谐波电压含有率'
|
|
},
|
|
{
|
|
value: '43',
|
|
label: '谐波电流幅值'
|
|
},
|
|
{
|
|
value: '44',
|
|
label: '谐波电压相角'
|
|
},
|
|
{
|
|
value: '45',
|
|
label: '谐波电流相角'
|
|
},
|
|
{
|
|
value: '46',
|
|
label: '间谐波电压含有率'
|
|
},
|
|
// {
|
|
// value: '47',
|
|
// label: '间谐波电流含有率'
|
|
// },
|
|
// {
|
|
// value: '48',
|
|
// label: '间谐波电压幅值'
|
|
// },
|
|
{
|
|
value: '49',
|
|
label: '间谐波电流幅值'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '功率趋势',
|
|
options: [
|
|
{
|
|
value: '50',
|
|
label: '谐波有功功率'
|
|
},
|
|
{
|
|
value: '51',
|
|
label: '谐波无功功率'
|
|
},
|
|
{
|
|
value: '52',
|
|
label: '谐波视在功率'
|
|
},
|
|
{
|
|
value: '53',
|
|
label: '三相有功功率'
|
|
},
|
|
{
|
|
value: '54',
|
|
label: '三相无功功率'
|
|
},
|
|
{
|
|
value: '55',
|
|
label: '三相视在功率'
|
|
},
|
|
{
|
|
value: '56',
|
|
label: '三相总有功功率'
|
|
},
|
|
{
|
|
value: '57',
|
|
label: '三相总无功功率'
|
|
},
|
|
{
|
|
value: '58',
|
|
label: '三相总视在功率'
|
|
},
|
|
{
|
|
value: '59',
|
|
label: '视在功率因数'
|
|
},
|
|
{
|
|
value: '591',
|
|
label: '位移功率因数'
|
|
},
|
|
{
|
|
value: '592',
|
|
label: '总视在功率因数'
|
|
},
|
|
{
|
|
value: '593',
|
|
label: '总位移功率因数'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: '闪变趋势',
|
|
options: [
|
|
{
|
|
value: '60',
|
|
label: '短时电压闪变'
|
|
},
|
|
{
|
|
value: '61',
|
|
label: '长时电压闪变'
|
|
},
|
|
{
|
|
value: '62',
|
|
label: '电压波动'
|
|
}
|
|
]
|
|
}
|
|
],
|
|
vh: null,
|
|
vhh: null,
|
|
//时间间隔
|
|
interval: 4,
|
|
//限制指标个数
|
|
limit: 3,
|
|
condition: ['10', '11', '12'],
|
|
formData: {
|
|
valueType: 1,
|
|
harmonic: 2,
|
|
inHarmonic: 1
|
|
},
|
|
//值类型
|
|
typeoptions: [
|
|
{ label: '平均值', value: 1 },
|
|
{ label: '最小值', value: 2 },
|
|
{ label: '最大值', value: 3 },
|
|
{ label: 'cp95值', value: 4 }
|
|
],
|
|
typeoptions1: [
|
|
{ label: '平均值', value: 1 },
|
|
{ label: '最小值', value: 2 },
|
|
{ label: '最大值', value: 3 },
|
|
{ label: 'cp95值', value: 4 }
|
|
],
|
|
typeoptions2: [{ label: '平均值', value: 1 }],
|
|
//谐波次数
|
|
harmonicoptions: [
|
|
{ label: '2次', value: 2 },
|
|
{ label: '3次', value: 3 },
|
|
{ label: '4次', value: 4 },
|
|
{ label: '5次', value: 5 },
|
|
{ label: '6次', value: 6 },
|
|
{ label: '7次', value: 7 },
|
|
{ label: '8次', value: 8 },
|
|
{ label: '9次', value: 9 },
|
|
{ label: '10次', value: 10 },
|
|
{ label: '11次', value: 11 },
|
|
{ label: '12次', value: 12 },
|
|
{ label: '13次', value: 13 },
|
|
{ label: '14次', value: 14 },
|
|
{ label: '15次', value: 15 },
|
|
{ label: '16次', value: 16 },
|
|
{ label: '17次', value: 17 },
|
|
{ label: '18次', value: 18 },
|
|
{ label: '19次', value: 19 },
|
|
{ label: '20次', value: 20 },
|
|
{ label: '21次', value: 21 },
|
|
{ label: '22次', value: 22 },
|
|
{ label: '23次', value: 23 },
|
|
{ label: '24次', value: 24 },
|
|
{ label: '25次', value: 25 },
|
|
{ label: '26次', value: 26 },
|
|
{ label: '27次', value: 27 },
|
|
{ label: '28次', value: 28 },
|
|
{ label: '29次', value: 29 },
|
|
{ label: '30次', value: 30 },
|
|
{ label: '31次', value: 31 },
|
|
{ label: '32次', value: 32 },
|
|
{ label: '33次', value: 33 },
|
|
{ label: '34次', value: 34 },
|
|
{ label: '35次', value: 35 },
|
|
{ label: '36次', value: 36 },
|
|
{ label: '37次', value: 37 },
|
|
{ label: '38次', value: 38 },
|
|
{ label: '39次', value: 39 },
|
|
{ label: '40次', value: 40 },
|
|
{ label: '41次', value: 41 },
|
|
{ label: '42次', value: 42 },
|
|
{ label: '43次', value: 43 },
|
|
{ label: '44次', value: 44 },
|
|
{ label: '45次', value: 45 },
|
|
{ label: '46次', value: 46 },
|
|
{ label: '47次', value: 47 },
|
|
{ label: '48次', value: 48 },
|
|
{ label: '49次', value: 49 },
|
|
{ label: '50次', value: 50 }
|
|
],
|
|
//简谐波次数
|
|
inharmonicoptions: [
|
|
{ label: '0.5次', value: 1 },
|
|
{ label: '1.5次', value: 2 },
|
|
{ label: '2.5次', value: 3 },
|
|
{ label: '3.5次', value: 4 },
|
|
{ label: '4.5次', value: 5 },
|
|
{ label: '5.5次', value: 6 },
|
|
{ label: '6.5次', value: 7 },
|
|
{ label: '7.5次', value: 8 },
|
|
{ label: '8.5次', value: 9 },
|
|
{ label: '9.5次', value: 10 },
|
|
{ label: '10.5次', value: 11 },
|
|
{ label: '11.5次', value: 12 },
|
|
{ label: '12.5次', value: 13 },
|
|
{ label: '13.5次', value: 14 },
|
|
{ label: '14.5次', value: 15 },
|
|
{ label: '15.5次', value: 16 }
|
|
],
|
|
//谐波简谐波控制
|
|
xb: false,
|
|
jxb: false,
|
|
list: [],
|
|
echartlist: [],
|
|
formData: {
|
|
condition: ['10', '11', '12'],
|
|
harmonic: 2,
|
|
inHarmonic: 1,
|
|
lineId: window.sessionStorage.getItem('fist'),
|
|
ptType: 0,
|
|
searchBeginTime: '',
|
|
searchEndTime: '',
|
|
valueType: 1
|
|
},
|
|
interval: 4,
|
|
nodeid: this.linelist,
|
|
deptIndex: ''
|
|
}
|
|
},
|
|
props: {
|
|
treenode: {
|
|
type: Object,
|
|
default: undefined
|
|
},
|
|
dataTree: {
|
|
type: Array,
|
|
default: undefined
|
|
},
|
|
linelist: {
|
|
type: Array,
|
|
default: undefined
|
|
},
|
|
ptType: {
|
|
type: Number,
|
|
default: undefined
|
|
}
|
|
// views: {
|
|
// type: Boolean,
|
|
// default: undefined,
|
|
// },
|
|
},
|
|
watch: {
|
|
ptType(newVal) {
|
|
if (newVal == 0) {
|
|
this.options = this.options3
|
|
this.condition = ['10', '11', '12']
|
|
} else if (newVal == 1) {
|
|
this.options = this.options1
|
|
this.condition = ['11', '12', '15']
|
|
} else if (newVal == 2) {
|
|
this.options = this.options2
|
|
this.condition = ['11', '12', '15']
|
|
}
|
|
},
|
|
//监听指标变化
|
|
condition(newVal, oldval) {
|
|
//console.log("🚀 ~ file: wtqsfenew.vue:885 ~ condition ~ newVal:", newVal)
|
|
//判断一个指标时
|
|
if (newVal.length == 1) {
|
|
if (
|
|
newVal.includes('40') ||
|
|
newVal.includes('43') ||
|
|
newVal.includes('44') ||
|
|
newVal.includes('50') ||
|
|
newVal.includes('39') ||
|
|
newVal.includes('51') ||
|
|
newVal.includes('52') ||
|
|
newVal.includes('45')
|
|
) {
|
|
this.xb = true
|
|
} else {
|
|
this.xb = false
|
|
}
|
|
if (newVal.includes('46') || newVal.includes('47') || newVal.includes('48') || newVal.includes('49')) {
|
|
this.jxb = true
|
|
} else {
|
|
this.jxb = false
|
|
}
|
|
}
|
|
//判断2个指标时
|
|
if (newVal.length == 2) {
|
|
if (
|
|
newVal.includes('40') ||
|
|
newVal.includes('43') ||
|
|
newVal.includes('44') ||
|
|
(newVal.includes('45') && newVal.includes('46')) ||
|
|
newVal.includes('47') ||
|
|
newVal.includes('48') ||
|
|
newVal.includes('49') ||
|
|
newVal.includes('50') ||
|
|
newVal.includes('39') ||
|
|
newVal.includes('51') ||
|
|
newVal.includes('52')
|
|
) {
|
|
this.xb = true
|
|
this.jxb = true
|
|
}
|
|
if (
|
|
newVal.includes('40') ||
|
|
newVal.includes('43') ||
|
|
newVal.includes('44') ||
|
|
newVal.includes('45') ||
|
|
newVal.includes('50') ||
|
|
newVal.includes('39') ||
|
|
newVal.includes('51') ||
|
|
newVal.includes('52')
|
|
) {
|
|
this.xb = true
|
|
} else {
|
|
this.xb = false
|
|
}
|
|
if (newVal.includes('46') || newVal.includes('47') || newVal.includes('48') || newVal.includes('49')) {
|
|
this.jxb = true
|
|
} else {
|
|
this.jxb = false
|
|
}
|
|
}
|
|
//判断3个指标时
|
|
if (newVal.length == 3) {
|
|
if (
|
|
(newVal.includes('40') ||
|
|
newVal.includes('43') ||
|
|
newVal.includes('44') ||
|
|
newVal.includes('50') ||
|
|
newVal.includes('39') ||
|
|
newVal.includes('51') ||
|
|
newVal.includes('52') ||
|
|
newVal.includes('45')) &&
|
|
(newVal.includes('46') || newVal.includes('47') || newVal.includes('48') || newVal.includes('49'))
|
|
) {
|
|
this.xb = true
|
|
this.jxb = true
|
|
} else {
|
|
this.xb = false
|
|
this.jxb = false
|
|
}
|
|
if (newVal.includes('46') || newVal.includes('47') || newVal.includes('48') || newVal.includes('49')) {
|
|
this.jxb = true
|
|
} else {
|
|
this.jxb = false
|
|
}
|
|
if (
|
|
newVal.includes('40') ||
|
|
newVal.includes('43') ||
|
|
newVal.includes('44') ||
|
|
newVal.includes('45') ||
|
|
newVal.includes('50') ||
|
|
newVal.includes('39') ||
|
|
newVal.includes('51') ||
|
|
newVal.includes('52')
|
|
) {
|
|
this.xb = true
|
|
} else {
|
|
this.xb = false
|
|
}
|
|
}
|
|
//判断无指标时
|
|
if (newVal.length == 0) {
|
|
this.jxb = false
|
|
this.xb = false
|
|
}
|
|
//根据指标判断值类型
|
|
if (newVal.includes('60') || newVal.includes('61') || newVal.includes('62')) {
|
|
this.typeoptions = this.typeoptions2
|
|
} else {
|
|
this.typeoptions = this.typeoptions1
|
|
}
|
|
},
|
|
checked: function (a, b) {
|
|
if (!a) {
|
|
this.panindexOptions.forEach(m => {
|
|
m.children.forEach(n => {
|
|
n.disabled = false
|
|
})
|
|
})
|
|
}
|
|
},
|
|
linelist(val) {
|
|
if (val.length > 0 && val[0] == null) {
|
|
this.querfromdatad()
|
|
} else {
|
|
this.node.push(window.sessionStorage.getItem('fist'))
|
|
this.querfromdatad()
|
|
}
|
|
}
|
|
},
|
|
created() {
|
|
var info = window.sessionStorage.getItem('Info')
|
|
info = eval('(' + info + ')')
|
|
this.deptIndex = info.deptId
|
|
//this.fiveTreeData()
|
|
},
|
|
mounted() {
|
|
this.vhh = window.sessionStorage.getItem('appheight') - 180 + 'px'
|
|
this.vh = window.sessionStorage.getItem('appheight') / 2.5 + 'px'
|
|
|
|
//this.queryData();
|
|
},
|
|
methods: {
|
|
querfromdata(a, b, c) {},
|
|
//获取5层树
|
|
async fiveTreeData() {
|
|
var data = {
|
|
deptIndex: this.deptIndex,
|
|
monitorFlag: 2,
|
|
powerFlag: 2,
|
|
loadType: null,
|
|
manufacturer: null,
|
|
serverName: 'harmonic-boot',
|
|
statisticalType: '',
|
|
scale: null
|
|
}
|
|
await api.getTerminalTreeForFive(data).then(res => {
|
|
if (res.code === 'A0000') {
|
|
this.arr = res.data
|
|
}
|
|
})
|
|
},
|
|
// 算法
|
|
algorithm(name) {
|
|
let pathInfo = this.$router.resolve({
|
|
path: '/algorithm/algorithm',
|
|
query: {
|
|
name: name
|
|
}
|
|
})
|
|
window.open(pathInfo.href, '算法帮助')
|
|
},
|
|
handleChange(val) {
|
|
//console.log(val);
|
|
},
|
|
closeHandle() {
|
|
if (this.view) {
|
|
this.view = false
|
|
} else {
|
|
this.view = true
|
|
}
|
|
//console.log('关闭和展开');
|
|
const dom = document.getElementById('container')
|
|
const closeDom = document.getElementsByClassName('close')[0]
|
|
if (!dom.className.match(/(?:^|\s)expend(?!\S)/)) {
|
|
dom.className = 'container expend'
|
|
} else {
|
|
dom.className = 'container close-container'
|
|
}
|
|
},
|
|
//日期组件触发事件
|
|
querfromdatad() {
|
|
this.loading = true
|
|
this.interval = this.$refs.chilenform.intervald
|
|
//监测点赋值
|
|
|
|
//this.timeValue = data;
|
|
this.formData.searchBeginTime = this.$refs.chilenform.timeValue[0]
|
|
this.formData.searchEndTime = this.$refs.chilenform.timeValue[1]
|
|
this.formData.condition = JSON.parse(JSON.stringify(this.condition))
|
|
console.log('🚀 ~ querfromdatad ~ this.formData.condition:', this.condition, this.formData.condition)
|
|
|
|
setTimeout(() => {
|
|
this.node.push(window.sessionStorage.getItem('fist'))
|
|
let datanode = { lineId: this.linelist.length == 0 ? this.node : this.linelist }
|
|
this.formData.lineId = datanode.lineId
|
|
// this.formData.lineId = datanode.lineId==null?this.linelist.push(this.arr[0].children[0].children[0].children[0].id):datanode.lineId
|
|
}, 800)
|
|
let directionValue = -1
|
|
for (let i = 0; i < this.formData.condition.length; i++) {
|
|
if (this.formData.condition[i] == '39') {
|
|
this.formData.condition[i] = '50'
|
|
directionValue = i
|
|
}
|
|
}
|
|
setTimeout(() => {
|
|
this.Traceability = []
|
|
// if (this.formData.condition.includes('39')) {
|
|
// api.getHistoryResult({
|
|
// ...this.formData,
|
|
// condition: ['50', '50']
|
|
// }).then(res => {
|
|
// if (res.code == 'A0000') {
|
|
// this.Traceability = res.data
|
|
// }
|
|
// })
|
|
// }
|
|
|
|
api.getHistoryResult(this.formData).then(res => {
|
|
if (res.code == 'A0000') {
|
|
this.list = []
|
|
if (directionValue >= 0) {
|
|
res.data[directionValue].targetName = '谐波电流方向'
|
|
this.Traceability = [res.data[directionValue]]
|
|
console.log('🚀 ~ api.getHistoryResult ~ this.Traceability :', this.Traceability)
|
|
}
|
|
this.shujuchuli(res)
|
|
}
|
|
})
|
|
}, 1500)
|
|
},
|
|
// queryData() {
|
|
// console.log("数据源", qsdata);
|
|
// this.shujuchuli(qsdata);
|
|
// },
|
|
//处理数据
|
|
//处理数据
|
|
shujuchuli(res) {
|
|
this.loading = true
|
|
var shujuData = res.data
|
|
shujuData.forEach((item, i) => {
|
|
let keyNum=1
|
|
//判断是否存在暂降点
|
|
if(item.targetName=='谐波电压含有率'){
|
|
keyNum=this.cvt.children != undefined? this.cvt.children[0].children[this.formData.harmonic-2].children[0].label:1
|
|
}
|
|
console.log("🚀 ~ shujuData.forEach ~ keyNum:", keyNum)
|
|
|
|
if (item.eventDetail !== null || item.eventDetail == []) {
|
|
//向项别中添加暂降点
|
|
var chufa = []
|
|
item.phaiscType.push('暂态触发点')
|
|
//判断是否有限值(有上下限)
|
|
if (item.topLimit !== 0 && item.lowerLimit !== 0) {
|
|
item.phaiscType.push('上限')
|
|
item.phaiscType.push('下限')
|
|
if (item.minValue !== null && item.maxValue !== null) {
|
|
//最小值等于下限值
|
|
|
|
//图列为A,B,C,暂降,上限,下限
|
|
if (item.phaiscType.length == 6) {
|
|
let avalue = []
|
|
let bvalue = []
|
|
let cvalue = []
|
|
let topLimit = []
|
|
let lowerLimit = []
|
|
item.maxValue = item.topLimit
|
|
item.minValue = item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
avalue.push([item.value[j][0], (item.value[j][1]/keyNum).toFixed(2)])
|
|
} else {
|
|
avalue.push([])
|
|
}
|
|
//判断存在缺失值b
|
|
if (item.value[j][2] != undefined) {
|
|
bvalue.push([item.value[j][0], (item.value[j][2]/keyNum).toFixed(2)])
|
|
} else {
|
|
bvalue.push([])
|
|
}
|
|
//判断存在缺失值c
|
|
if (item.value[j][3] != undefined) {
|
|
cvalue.push([item.value[j][0], (item.value[j][3]/keyNum).toFixed(2)])
|
|
} else {
|
|
cvalue.push([])
|
|
}
|
|
//上下限值
|
|
topLimit.push([item.value[j][0], item.topLimit])
|
|
lowerLimit.push([item.value[j][0], item.lowerLimit])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
avalue = []
|
|
bvalue = []
|
|
cvalue = []
|
|
}
|
|
//不存在一个暂降点或1个 //处理暂降点
|
|
if (item.eventDetail.length > 0) {
|
|
for (var k = 0; k < item.eventDetail.length; k++) {
|
|
chufa.push([
|
|
item.eventDetail[k].time,
|
|
item.minValue.toFixed(2),
|
|
item.eventDetail[k].id,
|
|
99
|
|
])
|
|
}
|
|
}
|
|
let shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
avalue: avalue,
|
|
bvalue: bvalue,
|
|
cvalue: cvalue,
|
|
topLimit: topLimit,
|
|
lowerLimit: lowerLimit,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
//图列为频率等,暂降,上限,下限
|
|
if (item.phaiscType.length == 4) {
|
|
let gvalue = []
|
|
let topLimit = []
|
|
let lowerLimit = []
|
|
item.maxValue = item.topLimit
|
|
item.minValue = item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
gvalue.push([item.value[j][0], item.value[j][1].toFixed(2)])
|
|
} else {
|
|
gvalue.push([])
|
|
}
|
|
//上下限值
|
|
topLimit.push([item.value[j][0], item.topLimit])
|
|
lowerLimit.push([item.value[j][0], item.lowerLimit])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
gvalue = []
|
|
}
|
|
//不存在一个暂降点或1个 //处理暂降点
|
|
if (item.eventDetail.length > 0) {
|
|
for (var k = 0; k < item.eventDetail.length; k++) {
|
|
chufa.push([
|
|
item.eventDetail[k].time,
|
|
item.minValue.toFixed(2),
|
|
item.eventDetail[k].id,
|
|
99
|
|
])
|
|
}
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
gvalue: gvalue,
|
|
topLimit: topLimit,
|
|
lowerLimit: lowerLimit,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
} else {
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: null,
|
|
avalue: [],
|
|
bvalue: [],
|
|
cvalue: [],
|
|
topLimit: [],
|
|
lowerLimit: [],
|
|
chufa: []
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
}
|
|
//有上限值
|
|
if (item.topLimit !== 0 && item.lowerLimit == 0) {
|
|
item.phaiscType.push('上限')
|
|
if (item.minValue !== null && item.maxValue !== null) {
|
|
//最小值等于下限值
|
|
//图列为A,B,C,暂降,上限
|
|
if (item.phaiscType.length == 5) {
|
|
let avalue = []
|
|
let bvalue = []
|
|
let cvalue = []
|
|
let topLimit = []
|
|
item.maxValue = item.topLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
avalue.push([item.value[j][0], (item.value[j][1]/keyNum).toFixed(2)])
|
|
} else {
|
|
avalue.push([])
|
|
}
|
|
//判断存在缺失值b
|
|
if (item.value[j][2] != undefined) {
|
|
bvalue.push([item.value[j][0], (item.value[j][2]/keyNum).toFixed(2)])
|
|
} else {
|
|
bvalue.push([])
|
|
}
|
|
//判断存在缺失值c
|
|
if (item.value[j][3] != undefined) {
|
|
cvalue.push([item.value[j][0], (item.value[j][3]/keyNum).toFixed(2)])
|
|
} else {
|
|
cvalue.push([])
|
|
}
|
|
//上限值
|
|
topLimit.push([item.value[j][0], item.topLimit])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
avalue = []
|
|
bvalue = []
|
|
cvalue = []
|
|
}
|
|
//不存在一个暂降点或1个 //处理暂降点
|
|
if (item.eventDetail.length > 0) {
|
|
for (var k = 0; k < item.eventDetail.length; k++) {
|
|
chufa.push([
|
|
item.eventDetail[k].time,
|
|
item.minValue.toFixed(2),
|
|
item.eventDetail[k].id,
|
|
99
|
|
])
|
|
}
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
avalue: avalue,
|
|
bvalue: bvalue,
|
|
cvalue: cvalue,
|
|
topLimit: topLimit,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
//图列为频率等,暂降,上限
|
|
if (item.phaiscType.length == 3) {
|
|
let gvalue = []
|
|
let topLimit = []
|
|
item.maxValue = item.topLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
gvalue.push([item.value[j][0], item.value[j][1].toFixed(2)])
|
|
} else {
|
|
gvalue.push([])
|
|
}
|
|
//上限值
|
|
topLimit.push([item.value[j][0], item.topLimit])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
gvalue = []
|
|
}
|
|
//不存在一个暂降点或1个 //处理暂降点
|
|
if (item.eventDetail.length > 0) {
|
|
for (var k = 0; k < item.eventDetail.length; k++) {
|
|
chufa.push([item.eventDetail[k].time, item.minValue.toFixed(2)])
|
|
}
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
gvalue: gvalue,
|
|
topLimit: topLimit,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
} else {
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: null,
|
|
avalue: [],
|
|
bvalue: [],
|
|
cvalue: [],
|
|
topLimit: [],
|
|
lowerLimit: [],
|
|
chufa: []
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
}
|
|
//有下限值
|
|
if (item.topLimit == 0 && item.lowerLimit !== 0) {
|
|
item.phaiscType.push('下限')
|
|
if (item.minValue !== null && item.maxValue !== null) {
|
|
//最小值等于下限值
|
|
//图列为A,B,C,暂降,下限
|
|
if (item.phaiscType.length == 5) {
|
|
let avalue = []
|
|
let bvalue = []
|
|
let cvalue = []
|
|
let lowerLimit = []
|
|
item.minValue = item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
avalue.push([item.value[j][0], (item.value[j][1]/keyNum).toFixed(2)])
|
|
} else {
|
|
avalue.push([])
|
|
}
|
|
//判断存在缺失值b
|
|
if (item.value[j][2] != undefined) {
|
|
bvalue.push([item.value[j][0], (item.value[j][2]/keyNum).toFixed(2)])
|
|
} else {
|
|
bvalue.push([])
|
|
}
|
|
//判断存在缺失值c
|
|
if (item.value[j][3] != undefined) {
|
|
cvalue.push([item.value[j][0], (item.value[j][3]/keyNum).toFixed(2)])
|
|
} else {
|
|
cvalue.push([])
|
|
}
|
|
//下限值
|
|
lowerLimit.push([item.value[j][0], item.lowerLimit.toFixed(2)])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
avalue = []
|
|
bvalue = []
|
|
cvalue = []
|
|
}
|
|
//不存在一个暂降点或1个 //处理暂降点
|
|
if (item.eventDetail.length > 0) {
|
|
for (var k = 0; k < item.eventDetail.length; k++) {
|
|
chufa.push([item.eventDetail[k].time, item.minValue.toFixed(2)])
|
|
}
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
avalue: avalue,
|
|
bvalue: bvalue,
|
|
cvalue: cvalue,
|
|
lowerLimit: lowerLimit,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
//图列为频率等,暂降,下限
|
|
if (item.phaiscType.length == 3) {
|
|
let gvalue = []
|
|
let lowerLimit = []
|
|
item.minValue = item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
gvalue.push([item.value[j][0], item.value[j][1].toFixed(2)])
|
|
} else {
|
|
gvalue.push([])
|
|
}
|
|
//下限值
|
|
lowerLimit.push([item.value[j][0], item.lowerLimit.toFixed(2)])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
gvalue = []
|
|
}
|
|
//不存在一个暂降点或1个 //处理暂降点
|
|
if (item.eventDetail.length > 0) {
|
|
for (var k = 0; k < item.eventDetail.length; k++) {
|
|
chufa.push([item.eventDetail[k].time, item.minValue.toFixed(2)])
|
|
}
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
gvalue: gvalue,
|
|
lowerLimit: lowerLimit,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
} else {
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: null,
|
|
avalue: [],
|
|
bvalue: [],
|
|
cvalue: [],
|
|
topLimit: [],
|
|
lowerLimit: [],
|
|
chufa: []
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
}
|
|
//无限值
|
|
if (item.topLimit == 0 && item.lowerLimit == 0) {
|
|
if (item.minValue !== null && item.maxValue !== null) {
|
|
//最小值等于下限值
|
|
//图列为A,B,C,暂降
|
|
if (item.phaiscType.length == 4) {
|
|
let avalue = []
|
|
let bvalue = []
|
|
let cvalue = []
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
avalue.push([item.value[j][0], (item.value[j][1]/keyNum).toFixed(2)])
|
|
} else {
|
|
avalue.push([])
|
|
}
|
|
//判断存在缺失值b
|
|
if (item.value[j][2] != undefined) {
|
|
bvalue.push([item.value[j][0], (item.value[j][2]/keyNum).toFixed(2)])
|
|
} else {
|
|
bvalue.push([])
|
|
}
|
|
//判断存在缺失值c
|
|
if (item.value[j][3] != undefined) {
|
|
cvalue.push([item.value[j][0], (item.value[j][3]/keyNum).toFixed(2)])
|
|
} else {
|
|
cvalue.push([])
|
|
}
|
|
}
|
|
//数据为空
|
|
} else {
|
|
avalue = []
|
|
bvalue = []
|
|
cvalue = []
|
|
}
|
|
//不存在一个暂降点或1个 //处理暂降点
|
|
if (item.eventDetail.length > 0) {
|
|
for (var k = 0; k < item.eventDetail.length; k++) {
|
|
chufa.push([
|
|
item.eventDetail[k].time,
|
|
item.minValue.toFixed(2),
|
|
item.eventDetail[k].id,
|
|
99
|
|
])
|
|
}
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue:
|
|
item.minValue > 1 ? (item.minValue - 0.5).toFixed(2) : item.minValue.toFixed(2),
|
|
maxValue: item.maxValue.toFixed(3),
|
|
avalue: avalue,
|
|
bvalue: bvalue,
|
|
cvalue: cvalue,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
//图列为频率等,暂降
|
|
if (item.phaiscType.length == 2) {
|
|
let gvalue = []
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
gvalue.push([item.value[j][0], item.value[j][1].toFixed(2)])
|
|
} else {
|
|
gvalue.push([])
|
|
}
|
|
}
|
|
//数据为空
|
|
} else {
|
|
gvalue = []
|
|
}
|
|
//不存在一个暂降点或1个 //处理暂降点
|
|
if (item.eventDetail.length > 0) {
|
|
for (var k = 0; k < item.eventDetail.length; k++) {
|
|
chufa.push([
|
|
item.eventDetail[k].time,
|
|
item.minValue.toFixed(2),
|
|
item.eventDetail[k].id,
|
|
99
|
|
])
|
|
}
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: item.minValue.toFixed(3),
|
|
maxValue: item.maxValue.toFixed(3),
|
|
gvalue: gvalue,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
} else {
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: null,
|
|
avalue: [],
|
|
bvalue: [],
|
|
cvalue: [],
|
|
topLimit: [],
|
|
lowerLimit: [],
|
|
chufa: []
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
}
|
|
} else if (item.eventDetail == null) {
|
|
//判断是否有限值(有上下限)
|
|
if (item.topLimit !== 0 && item.lowerLimit !== 0) {
|
|
item.phaiscType.push('上限')
|
|
item.phaiscType.push('下限')
|
|
if (item.minValue !== null && item.maxValue !== null) {
|
|
//最小值等于下限值
|
|
//图列为A,B,C,上限,下限
|
|
if (item.phaiscType.length == 5) {
|
|
let avalue = []
|
|
let bvalue = []
|
|
let cvalue = []
|
|
let topLimit = []
|
|
let lowerLimit = []
|
|
item.maxValue = item.topLimit
|
|
item.minValue = item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
avalue.push([item.value[j][0], (item.value[j][1]/keyNum).toFixed(2)])
|
|
} else {
|
|
avalue.push([])
|
|
}
|
|
//判断存在缺失值b
|
|
if (item.value[j][2] != undefined) {
|
|
bvalue.push([item.value[j][0], (item.value[j][2]/keyNum).toFixed(2)])
|
|
} else {
|
|
bvalue.push([])
|
|
}
|
|
//判断存在缺失值c
|
|
if (item.value[j][3] != undefined) {
|
|
cvalue.push([item.value[j][0], (item.value[j][3]/keyNum).toFixed(2)])
|
|
} else {
|
|
cvalue.push([])
|
|
}
|
|
//上下限值
|
|
topLimit.push([item.value[j][0], item.topLimit.toFixed(2)])
|
|
lowerLimit.push([item.value[j][0], item.lowerLimit.toFixed(2)])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
avalue = []
|
|
bvalue = []
|
|
cvalue = []
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
avalue: avalue,
|
|
bvalue: bvalue,
|
|
cvalue: cvalue,
|
|
topLimit: topLimit,
|
|
lowerLimit: lowerLimit
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
//图列为频率等,上限,下限
|
|
if (item.phaiscType.length == 3) {
|
|
let gvalue = []
|
|
let topLimit = []
|
|
let lowerLimit = []
|
|
item.maxValue = item.topLimit
|
|
item.minValue = item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
gvalue.push([item.value[j][0], item.value[j][1].toFixed(2)])
|
|
} else {
|
|
gvalue.push([])
|
|
}
|
|
//上下限值
|
|
topLimit.push([item.value[j][0], item.topLimit.toFixed(2)])
|
|
lowerLimit.push([item.value[j][0], item.lowerLimit.toFixed(2)])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
gvalue = []
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
gvalue: gvalue,
|
|
topLimit: topLimit,
|
|
lowerLimit: lowerLimit,
|
|
chufa: chufa
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
} else {
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: null,
|
|
avalue: [],
|
|
bvalue: [],
|
|
cvalue: [],
|
|
topLimit: [],
|
|
lowerLimit: [],
|
|
chufa: []
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
}
|
|
//有上限值
|
|
if (item.topLimit !== 0 && item.lowerLimit == 0) {
|
|
item.phaiscType.push('上限')
|
|
if (item.minValue !== null) {
|
|
//最小值等于下限值
|
|
//图列为A,B,C,上限
|
|
if (item.phaiscType.length == 4) {
|
|
let avalue = []
|
|
let bvalue = []
|
|
let cvalue = []
|
|
let topLimit = []
|
|
item.maxValue = item.topLimit
|
|
// item.minValue=item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
avalue.push([item.value[j][0], (item.value[j][1]/keyNum).toFixed(2)])
|
|
} else {
|
|
avalue.push([])
|
|
}
|
|
//判断存在缺失值b
|
|
if (item.value[j][2] != undefined) {
|
|
bvalue.push([item.value[j][0], (item.value[j][2]/keyNum).toFixed(2)])
|
|
} else {
|
|
bvalue.push([])
|
|
}
|
|
//判断存在缺失值c
|
|
if (item.value[j][3] != undefined) {
|
|
cvalue.push([item.value[j][0], (item.value[j][3]/keyNum).toFixed(2)])
|
|
} else {
|
|
cvalue.push([])
|
|
}
|
|
//上限值
|
|
topLimit.push([item.value[j][0], item.topLimit.toFixed(2)])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
avalue = []
|
|
bvalue = []
|
|
cvalue = []
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
maxValue: item.maxValue.toFixed(3),
|
|
minValue: item.minValue.toFixed(3),
|
|
avalue: avalue,
|
|
bvalue: bvalue,
|
|
cvalue: cvalue,
|
|
topLimit: topLimit
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
//图列为频率等,上限
|
|
if (item.phaiscType.length == 2) {
|
|
let gvalue = []
|
|
let topLimit = []
|
|
item.maxValue = item.topLimit
|
|
// item.minValue=item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
gvalue.push([item.value[j][0], item.value[j][1].toFixed(2)])
|
|
} else {
|
|
gvalue.push([])
|
|
}
|
|
//上限值
|
|
topLimit.push([item.value[j][0], item.topLimit.toFixed(2)])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
gvalue = []
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: item.minValue.toFixed(3),
|
|
maxValue: item.maxValue.toFixed(3),
|
|
gvalue: gvalue,
|
|
topLimit: topLimit
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
} else {
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: null,
|
|
avalue: [],
|
|
bvalue: [],
|
|
cvalue: [],
|
|
topLimit: [],
|
|
lowerLimit: [],
|
|
chufa: []
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
}
|
|
//有下限值
|
|
if (item.topLimit == 0 && item.lowerLimit !== 0) {
|
|
item.phaiscType.push('下限')
|
|
if (item.minValue !== null) {
|
|
//最小值等于下限值
|
|
//图列为A,B,C,下限
|
|
if (item.phaiscType.length == 4) {
|
|
let avalue = []
|
|
let bvalue = []
|
|
let cvalue = []
|
|
let lowerLimit = []
|
|
// item.maxValue=item.topLimit
|
|
item.minValue = item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
avalue.push([item.value[j][0], (item.value[j][1]/keyNum).toFixed(2)])
|
|
} else {
|
|
avalue.push([])
|
|
}
|
|
//判断存在缺失值b
|
|
if (item.value[j][2] != undefined) {
|
|
bvalue.push([item.value[j][0], (item.value[j][2]/keyNum).toFixed(2)])
|
|
} else {
|
|
bvalue.push([])
|
|
}
|
|
//判断存在缺失值c
|
|
if (item.value[j][3] != undefined) {
|
|
cvalue.push([item.value[j][0], (item.value[j][3]/keyNum).toFixed(2)])
|
|
} else {
|
|
cvalue.push([])
|
|
}
|
|
//下限值
|
|
lowerLimit.push([item.value[j][0], item.lowerLimit.toFixed(2)])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
avalue = []
|
|
bvalue = []
|
|
cvalue = []
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: item.minValue.toFixed(3),
|
|
maxValue: item.maxValue.toFixed(3),
|
|
avalue: avalue,
|
|
bvalue: bvalue,
|
|
cvalue: cvalue,
|
|
lowerLimit: lowerLimit
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
//图列为频率等,下限
|
|
if (item.phaiscType.length == 2) {
|
|
let gvalue = []
|
|
let lowerLimit = []
|
|
// item.maxValue=item.topLimit
|
|
item.minValue = item.lowerLimit
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
gvalue.push([item.value[j][0], item.value[j][1].toFixed(2)])
|
|
} else {
|
|
gvalue.push([])
|
|
}
|
|
//下限值
|
|
lowerLimit.push([item.value[j][0], item.lowerLimit.toFixed(2)])
|
|
}
|
|
//数据为空
|
|
} else {
|
|
gvalue = []
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: item.minValue.toFixed(3),
|
|
maxValue: item.maxValue.toFixed(3),
|
|
gvalue: gvalue,
|
|
lowerLimit: lowerLimit
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
} else {
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: null,
|
|
avalue: [],
|
|
bvalue: [],
|
|
cvalue: [],
|
|
topLimit: [],
|
|
lowerLimit: [],
|
|
chufa: []
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
}
|
|
//无限值
|
|
if (item.topLimit == 0 && item.lowerLimit == 0) {
|
|
if (item.minValue !== null) {
|
|
//最小值等于下限值
|
|
//图列为A,B,C
|
|
if (item.phaiscType.length == 3) {
|
|
let avalue = []
|
|
let bvalue = []
|
|
let cvalue = []
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
avalue.push([item.value[j][0], (item.value[j][1]/keyNum).toFixed(2)])
|
|
} else {
|
|
avalue.push([])
|
|
}
|
|
//判断存在缺失值b
|
|
if (item.value[j][2] != undefined) {
|
|
bvalue.push([item.value[j][0], (item.value[j][2]/keyNum).toFixed(2)])
|
|
} else {
|
|
bvalue.push([])
|
|
}
|
|
//判断存在缺失值c
|
|
if (item.value[j][3] != undefined) {
|
|
cvalue.push([item.value[j][0], (item.value[j][3]/keyNum).toFixed(2)])
|
|
} else {
|
|
cvalue.push([])
|
|
}
|
|
}
|
|
//数据为空
|
|
} else {
|
|
avalue = []
|
|
bvalue = []
|
|
cvalue = []
|
|
}
|
|
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: item.minValue.toFixed(3),
|
|
maxValue: item.maxValue.toFixed(3),
|
|
avalue: avalue,
|
|
bvalue: bvalue,
|
|
cvalue: cvalue
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
//图列为频率等
|
|
if (item.phaiscType.length == 1) {
|
|
let gvalue = []
|
|
//判断数据是否存在
|
|
if (item.value !== null) {
|
|
for (var j = 0; j < item.value.length; j++) {
|
|
//判断存在缺失值a
|
|
if (item.value[j][1] != undefined) {
|
|
gvalue.push([item.value[j][0], item.value[j][1].toFixed(2)])
|
|
} else {
|
|
gvalue.push([])
|
|
}
|
|
}
|
|
//数据为空
|
|
} else {
|
|
gvalue = []
|
|
}
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: item.minValue.toFixed(3),
|
|
maxValue: item.maxValue.toFixed(3),
|
|
gvalue: gvalue
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
} else {
|
|
var shuju = {
|
|
id: 'qushifenx' + i,
|
|
title: item.lineName + '--' + item.targetName,
|
|
targetName: item.targetName,
|
|
legend: item.phaiscType,
|
|
valueName: item.unit[0],
|
|
minValue: null,
|
|
avalue: [],
|
|
bvalue: [],
|
|
cvalue: [],
|
|
topLimit: [],
|
|
lowerLimit: [],
|
|
chufa: []
|
|
}
|
|
this.list.push(shuju)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
this.Rendering()
|
|
},
|
|
|
|
Rendering() {
|
|
this.loading = true
|
|
this.list.forEach(item => {
|
|
var opitonserise = []
|
|
item.legend.forEach(item2 => {
|
|
if (item.avalue !== undefined && (item2 == 'A相' || item2 == 'AB相' || item2 == '零序电压')) {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
smooth: true,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#FFCC00'
|
|
}
|
|
},
|
|
|
|
data: item.avalue
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (
|
|
item.bvalue !== undefined &&
|
|
(item2 == 'B相' || item2 == 'BC相' || item2 == '正序电压')
|
|
) {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
smooth: true,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#339900'
|
|
}
|
|
},
|
|
|
|
data: item.bvalue
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (
|
|
item.cvalue !== undefined &&
|
|
(item2 == 'C相' || item2 == 'CA相' || item2 == '负序电压')
|
|
) {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
smooth: true,
|
|
barWidth: 22,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#FF3300'
|
|
}
|
|
},
|
|
data: item.cvalue
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (item.topLimit !== undefined && item2 == '上限') {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
smooth: true,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#FF33FF',
|
|
lineStyle: {
|
|
width: 2,
|
|
color: '#FF33FF',
|
|
type: 'dotted' //'dotted'虚线 'solid'实线
|
|
}
|
|
}
|
|
},
|
|
data: item.topLimit
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (item.lowerLimit !== undefined && item2 == '下限') {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
smooth: true,
|
|
barWidth: 22,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#3399FF',
|
|
lineStyle: {
|
|
width: 2,
|
|
color: '#3399FF',
|
|
type: 'dotted' //'dotted'虚线 'solid'实线
|
|
}
|
|
}
|
|
},
|
|
data: item.lowerLimit
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (item.chufa !== undefined && item2 == '暂态触发点') {
|
|
var data = {
|
|
name: item2,
|
|
type: 'scatter',
|
|
symbol: 'image://' + this.url,
|
|
symbolSize: 16,
|
|
itemStyle: {
|
|
width: '22px',
|
|
height: '22px'
|
|
},
|
|
data: item.chufa
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (item.gvalue !== undefined && item2 == '频率') {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
smooth: true,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#990099',
|
|
lineStyle: {
|
|
width: 2,
|
|
color: '#990099',
|
|
type: 'solid' //'dotted'虚线 'solid'实线
|
|
}
|
|
}
|
|
},
|
|
data: item.gvalue
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (item.gvalue !== undefined && item2 == '负序电流') {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
barWidth: 22,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#999933'
|
|
}
|
|
},
|
|
data: item.gvalue
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (item.gvalue !== undefined && item2 == '三相电压不平衡度') {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
barWidth: 22,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#FF6600'
|
|
}
|
|
},
|
|
data: item.gvalue
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (
|
|
item.gvalue !== undefined &&
|
|
(item2 == '三相总有功功率' || item2 == '三相总无功功率' || item2 == '三相总视在功率')
|
|
) {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
barWidth: 22,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#0033ff'
|
|
}
|
|
},
|
|
data: item.gvalue
|
|
}
|
|
opitonserise.push(data)
|
|
} else if (item.gvalue !== undefined && (item2 == '总视在功率因数' || item2 == '总位移功率因数')) {
|
|
var data = {
|
|
name: item2,
|
|
symbol: 'none',
|
|
symbolSize: 5,
|
|
type: 'line',
|
|
barWidth: 22,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#00FF00'
|
|
}
|
|
},
|
|
|
|
data: item.gvalue
|
|
}
|
|
opitonserise.push(data)
|
|
} else {
|
|
opitonserise.push([])
|
|
}
|
|
})
|
|
if (item.valueName == undefined) {
|
|
item.valueName = '无'
|
|
}
|
|
//console.log('渲染数据体',opitonserise)
|
|
item.serise = opitonserise
|
|
})
|
|
|
|
this.$nextTick(() => {
|
|
this.getEcharts()
|
|
})
|
|
},
|
|
getEcharts() {
|
|
this.loading = true
|
|
var arr = []
|
|
const echarts = require('echarts')
|
|
let index = ''
|
|
// console.log(123123, this.list)
|
|
this.list.forEach((item, i) => {
|
|
index = i
|
|
let domeId = document.getElementById(item.id)
|
|
setTimeout(() => {
|
|
domeId.style.width = document.getElementById('tubiao').offsetWidth - 20 + 'px'
|
|
if (this.list.length == 1) {
|
|
domeId.style.height = window.sessionStorage.getItem('appheight') - 130 + 'px'
|
|
} else {
|
|
domeId.style.height = window.sessionStorage.getItem('appheight') / 2.3 + 'px'
|
|
}
|
|
}, 0)
|
|
var myChartes = echarts.init(domeId)
|
|
this.myChartes = myChartes
|
|
let echartsColor = JSON.parse(window.localStorage.echartsColor)
|
|
myChartes.clear()
|
|
var option = {
|
|
backgroundColor: '#fff',
|
|
title: {
|
|
left: 'center',
|
|
text: item.title,
|
|
textStyle: {
|
|
fontSize: yan.EchartObject.xNamefontSize,
|
|
color: echartsColor.WordColor
|
|
}
|
|
},
|
|
tooltip: {
|
|
trigger: 'axis',
|
|
axisPointer: {
|
|
//type: "shadow",
|
|
type: 'cross', // 默认为直线，可选为：'line' | 'shadow'
|
|
label: {
|
|
color: '#fff',
|
|
fontSize: 16
|
|
}
|
|
},
|
|
textStyle: {
|
|
color: '#fff',
|
|
fontStyle: 'normal',
|
|
opacity: 0.35,
|
|
fontSize: 14
|
|
},
|
|
backgroundColor: 'rgba(0,0,0,0.35)',
|
|
|
|
formatter: function (params) {
|
|
var tips = ''
|
|
tips += '时刻:' + params[0].data[0] + '</br/>'
|
|
for (var i = 0; i < params.length; i++) {
|
|
if (params[i].seriesName == '暂态触发点') {
|
|
tips += ''
|
|
return tips
|
|
}
|
|
if (params[i].seriesName == 'A相谐波电流方向') {
|
|
tips +=
|
|
params[i].value[1] > 0
|
|
? 'A相谐波电流方向:流入<br/>'
|
|
: params[i].value[1] == 0
|
|
? 'A相谐波电流方向:无<br/>'
|
|
: 'A相谐波电流方向:流出<br/>'
|
|
} else if (params[i].seriesName == 'B相谐波电流方向') {
|
|
tips +=
|
|
params[i].value[1] > 0
|
|
? 'B相谐波电流方向:流入<br/>'
|
|
: params[i].value[1] == 0
|
|
? 'B相谐波电流方向:无<br/>'
|
|
: 'B相谐波电流方向:流出<br/>'
|
|
} else if (params[i].seriesName == 'C相谐波电流方向') {
|
|
tips +=
|
|
params[i].value[1] > 0
|
|
? 'C相谐波电流方向:流入<br/>'
|
|
: params[i].value[1] == 0
|
|
? 'C相谐波电流方向:无<br/>'
|
|
: 'C相谐波电流方向:流出<br/>'
|
|
} else if (params[i].seriesName == '总谐波电流方向') {
|
|
tips +=
|
|
params[i].value[1] > 0
|
|
? '总谐波电流方向:流入<br/>'
|
|
: params[i].value[1] == 0
|
|
? '总谐波电流方向:无<br/>'
|
|
: '总谐波电流方向:流出<br/>'
|
|
} else if (params[i].seriesName == '正序电压') {
|
|
let str = (params[i].value[1] * 1).toString()
|
|
let reg = str.indexOf('.') > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g
|
|
let str1 = str.replace(reg, '$1,')
|
|
tips += params[i].seriesName + ':' + str1 + 'kV<br/>'
|
|
} else if (params[i].seriesName == '零序电压' || params[i].seriesName == '负序电压') {
|
|
let str = (params[i].value[1] * 1).toString()
|
|
let reg = str.indexOf('.') > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g
|
|
let str1 = str.replace(reg, '$1,')
|
|
tips += params[i].seriesName + ':' + str1 + 'V<br/>'
|
|
} else if (params[i].seriesName !== '正序电压') {
|
|
let str = (params[i].value[1] * 1).toString()
|
|
let reg = str.indexOf('.') > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g
|
|
let str1 = str.replace(reg, '$1,')
|
|
tips += params[i].seriesName + ':' + str1 + '<br/>'
|
|
} else {
|
|
let str = (params[i].value[2] * 1).toString()
|
|
let reg = str.indexOf('.') > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g
|
|
let str1 = str.replace(reg, '$1,')
|
|
tips += params[i].seriesName + ':' + str1 + '<br/>'
|
|
|
|
let str2 = (params[i].value[3] * 1).toString()
|
|
let reg2 = str2.indexOf('.') > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g
|
|
let str12 = str.replace(reg2, '$1,')
|
|
// if(params[i].seriesName){
|
|
|
|
// }
|
|
tips += params[i].seriesName + ':' + str12 + '<br/>'
|
|
}
|
|
}
|
|
|
|
return tips
|
|
}
|
|
},
|
|
grid: yan.EchartObject.grid8,
|
|
legend: {
|
|
left: '140px',
|
|
verticalAlign: 'top',
|
|
enabled: true,
|
|
itemDistance: 5,
|
|
textStyle: {
|
|
color: echartsColor.WordColor,
|
|
rich: {
|
|
a: {
|
|
verticalAlign: 'middle'
|
|
}
|
|
},
|
|
|
|
padding: [0, 0, 0, 0] //[上、右、下、左]
|
|
}
|
|
|
|
// itemHeight: 14,
|
|
// itemWidth: 14,
|
|
// data: item.legend,
|
|
// textStyle: {
|
|
// color: echartsColor.WordColor
|
|
// }
|
|
},
|
|
|
|
dataZoom: yan.EchartObject.dataZoom,
|
|
xAxis: [
|
|
{
|
|
name: yan.EchartObject.time,
|
|
nameTextStyle: {
|
|
color: echartsColor.WordColor
|
|
},
|
|
type: 'time',
|
|
axisLine: {
|
|
show: true,
|
|
onZero: false,
|
|
lineStyle: {
|
|
color: echartsColor.thread
|
|
}
|
|
},
|
|
axisLabel: {
|
|
textStyle: {
|
|
fontFamily: 'dinproRegular',
|
|
color: echartsColor.WordColor
|
|
}
|
|
}
|
|
}
|
|
],
|
|
toolbox: {
|
|
show: true,
|
|
feature: {
|
|
dataZoom: {
|
|
// bottom: '10px',
|
|
yAxisIndex: 'none'
|
|
},
|
|
//saveAsImage: {},
|
|
myFull: {
|
|
show: true,
|
|
title: '全屏查看',
|
|
id: item.id,
|
|
icon: 'path://M432.45,595.444c0,2.177-4.661,6.82-11.305,6.82c-6.475,0-11.306-4.567-11.306-6.82s4.852-6.812,11.306-6.812C427.841,588.632,432.452,593.191,432.45,595.444L432.45,595.444z M421.155,589.876c-3.009,0-5.448,2.495-5.448,5.572s2.439,5.572,5.448,5.572c3.01,0,5.449-2.495,5.449-5.572C426.604,592.371,424.165,589.876,421.155,589.876L421.155,589.876z M421.146,591.891c-1.916,0-3.47,1.589-3.47,3.549c0,1.959,1.554,3.548,3.47,3.548s3.469-1.589,3.469-3.548C424.614,593.479,423.062,591.891,421.146,591.891L421.146,591.891zM421.146,591.891',
|
|
onclick: e => {
|
|
let element = document.getElementById(item.id)
|
|
if (element.requestFullScreen) {
|
|
// HTML W3C 提议
|
|
element.requestFullScreen()
|
|
} else if (element.msRequestFullscreen) {
|
|
// IE11
|
|
element.msRequestFullScreen()
|
|
} else if (element.webkitRequestFullScreen) {
|
|
// Webkit (works in Safari5.1 and Chrome 15)
|
|
element.webkitRequestFullScreen()
|
|
} else if (element.mozRequestFullScreen) {
|
|
// Firefox (works in nightly)
|
|
element.mozRequestFullScreen()
|
|
}
|
|
// 退出全屏
|
|
if (element.requestFullScreen) {
|
|
document.exitFullscreen()
|
|
} else if (element.msRequestFullScreen) {
|
|
} else if (element.webkitRequestFullScreen) {
|
|
document.webkitCancelFullScreen()
|
|
} else if (element.mozRequestFullScreen) {
|
|
document.mozCancelFullScreen()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
yAxis: [
|
|
// (item.minValue - 0.5).toFixed(2)
|
|
{
|
|
type: 'value',
|
|
// nameGap:5,
|
|
// boundaryGap: [0.2, 0.2],
|
|
// min:item.minValue>0?(item.minValue>50?Number(item.minValue)-Number(item.minValue*0.01):Number(item.minValue)-Number(item.minValue*0.05)):(item.minValue<-1?Number(item.minValue)+Number(item.minValue*0.01):Number(item.minValue)-Number(item.minValue*0.01)),
|
|
// max:item.maxValue>50?
|
|
// (item.maxValue<100?
|
|
// Number(item.maxValue)+Number(item.maxValue*0.3)
|
|
// :Number(item.maxValue)+Number(item.maxValue*0.1))
|
|
// :(item.maxValue<10?
|
|
// (item.maxValue>0&&item.maxValue<1?
|
|
// (Number(item.maxValue)+Number(item.maxValue*0.002))
|
|
// :(Number(item.maxValue)+Number(item.maxValue*0.005))
|
|
// ):(Number(item.maxValue)+Number(item.maxValue*0.01))),
|
|
min: item.minValue,
|
|
//max: Number(item.maxValue)+Number(item.maxValue*0.05),
|
|
// splitNumber : 1,
|
|
name: item.valueName,
|
|
axisLabel: {
|
|
interval: 0,
|
|
formatter: function (value, index) {
|
|
return value.toFixed(3)
|
|
},
|
|
left: '20px',
|
|
color: echartsColor.WordColor
|
|
},
|
|
|
|
axisLine: {
|
|
show: true,
|
|
onZero: false, //-----------重点
|
|
lineStyle: {
|
|
color: echartsColor.thread
|
|
}
|
|
},
|
|
splitLine: {
|
|
lineStyle: {
|
|
// 使用深浅的间隔色
|
|
color: [echartsColor.thread],
|
|
type: 'dashed',
|
|
opacity: 0.5
|
|
}
|
|
}
|
|
}
|
|
],
|
|
series: item.serise
|
|
}
|
|
let aValues = []
|
|
let bValues = []
|
|
let CValues = []
|
|
let ZValues = []
|
|
|
|
if (
|
|
this.Traceability.length > 0 &&
|
|
this.Traceability[0].value != null &&
|
|
this.Traceability[0].value.length > 0
|
|
) {
|
|
this.Traceability[0].value.forEach(val50 => {})
|
|
for (let i = 0; i < this.Traceability[0].value.length; i++) {
|
|
let T = this.Traceability[0].value[i][0]
|
|
let A = this.Traceability[0].value[i][1]
|
|
let B = this.Traceability[0].value[i][2]
|
|
let C = this.Traceability[0].value[i][3]
|
|
let Z = A + B + C
|
|
aValues.push([T, A > 0 ? 1 : A == 0 ? 0 : -1])
|
|
bValues.push([T, B > 0 ? 1 : B == 0 ? 0 : -1])
|
|
CValues.push([T, C > 0 ? 1 : C == 0 ? 0 : -1])
|
|
ZValues.push([T, Z > 0 ? 1 : Z == 0 ? 0 : -1])
|
|
}
|
|
}
|
|
|
|
if (item.targetName == '谐波电流方向') {
|
|
option.tooltip.axisPointer = null
|
|
option.yAxis[0] = {
|
|
type: 'value',
|
|
interval: 1,
|
|
min: -2, //最小值
|
|
max: 2,
|
|
axisLine: {
|
|
show: true,
|
|
onZero: false, //-----------重点
|
|
lineStyle: {
|
|
color: echartsColor.thread
|
|
}
|
|
},
|
|
splitLine: {
|
|
lineStyle: {
|
|
// 使用深浅的间隔色
|
|
color: [echartsColor.thread],
|
|
type: 'dashed',
|
|
opacity: 0.5
|
|
}
|
|
},
|
|
axisLabel: {
|
|
formatter: function (value) {
|
|
if (value == 0) {
|
|
return '无'
|
|
} else if (value == -1) {
|
|
return '流出'
|
|
} else if (value == 1) {
|
|
return '流入'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
option.series = [
|
|
{
|
|
name: 'A相谐波电流方向',
|
|
type: 'line',
|
|
|
|
data: aValues,
|
|
symbol: 'none',
|
|
symbolSize: 0,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#FFCC00'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'B相谐波电流方向',
|
|
type: 'line',
|
|
|
|
data: bValues,
|
|
symbol: 'none',
|
|
symbolSize: 0,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#339900'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'C相谐波电流方向',
|
|
type: 'line',
|
|
|
|
data: CValues,
|
|
symbol: 'none',
|
|
symbolSize: 0,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#FF3300'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: '总谐波电流方向',
|
|
type: 'line',
|
|
|
|
data: ZValues,
|
|
symbol: 'none',
|
|
symbolSize: 0,
|
|
itemStyle: {
|
|
normal: {
|
|
color: '#0033ff'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
}
|
|
myChartes.setOption(option)
|
|
window.echartsArr.push(myChartes)
|
|
setTimeout(() => {
|
|
this.loading = false
|
|
}, 100)
|
|
myChartes.on('click', function (params) {
|
|
if (_this.boxFlg) {
|
|
_this.boxFlg = false
|
|
return
|
|
}
|
|
if (params.data[3] == 99) {
|
|
_this.$emit('BoXi', params.data[2])
|
|
_this.boxFlg = true
|
|
}
|
|
})
|
|
|
|
arr.push(myChartes)
|
|
})
|
|
echarts.connect(arr)
|
|
this.arrtu = arr
|
|
|
|
let _this = this
|
|
_this.$erd.listenTo(_this.$refs.kk, element => {
|
|
_this.$nextTick(() => {
|
|
for (var i = 0; i < arr.length; i++) {
|
|
// domeId.style.width = document.getElementById("quntu").offsetWidth - 0 + 'px'
|
|
arr[i].resize()
|
|
}
|
|
})
|
|
})
|
|
|
|
//let c = Date.now();
|
|
// console.log("渲染完", c);
|
|
}
|
|
}
|
|
}
|
|
</script>
|
|
<style lang="less" scoped>
|
|
// .myDIV {
|
|
// width:42%;height:100px;background:#fff;position:absolute;z-index:100;opacity:0.9;
|
|
// right: 0;
|
|
// top:-100px;
|
|
// overflow: hidden;
|
|
// -webkit-animation: mymove 0.5s infinite; /* Chrome, Safari, Opera */
|
|
// animation: mymove 0.5s infinite;
|
|
// }
|
|
// @-webkit-keyframes mymove {
|
|
// 50% {top: 0px;}
|
|
// }
|
|
|
|
// /* Standard syntax */
|
|
// @keyframes mymove {
|
|
// 50% {top: 0px;}
|
|
// }
|
|
|
|
.el-button--text {
|
|
color: #003078;
|
|
font-size: px;
|
|
font-weight: bold;
|
|
}
|
|
</style>
|
|
<style lang="scss" scoped>
|
|
.container {
|
|
/* margin: auto; */
|
|
top: 0px;
|
|
right: 0;
|
|
width: 46%;
|
|
height: 0px;
|
|
z-index: 2000;
|
|
position: absolute;
|
|
background-color: #e4e7ebb9;
|
|
overflow: auto;
|
|
scroll-behavior: smooth;
|
|
-radius: 20px;
|
|
}
|
|
/* 隐藏滚动条 */
|
|
::-webkit-scrollbar {
|
|
display: block;
|
|
width: 8px !important;
|
|
}
|
|
.expend {
|
|
animation: expend ease 5s forwards;
|
|
}
|
|
.close-container {
|
|
animation: no-expend ease 1s forwards;
|
|
}
|
|
@keyframes expend {
|
|
from {
|
|
top: 0px;
|
|
height: auto;
|
|
}
|
|
to {
|
|
height: auto;
|
|
top: 0px;
|
|
}
|
|
}
|
|
@keyframes no-expend {
|
|
from {
|
|
height: 20%;
|
|
top: 0px;
|
|
}
|
|
to {
|
|
top: 0px;
|
|
height: 0px;
|
|
}
|
|
}
|
|
.coles {
|
|
position: absolute;
|
|
right: 0;
|
|
font-size: 20px;
|
|
cursor: pointer;
|
|
}
|
|
</style>
|