2025-3-22定制修改导出去掉容量和连接条

whyclxw

2025-03-28 cc86bb05bba08200a2e2bc301bb835f52a708a1f

 src/main/java/com/whyc/service/BattGroupDataService.java

@@ -1,17 +1,16 @@
package com.whyc.service;

import com.whyc.dto.BattGroupStationInfoWithFileParam;
import com.whyc.dto.Response;
import com.whyc.mapper.BattGroupDataMapper;
import com.whyc.pojo.BattgroupData;
import com.whyc.pojo.BattgroupInfo;
import com.whyc.pojo.FileInfo;
import com.whyc.pojo.FileParam;
import com.whyc.pojo.*;
import com.whyc.util.MathUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.NumberFormat;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
@@ -31,90 +30,170 @@
    @Autowired
    private BattGroupInfoService battGroupInfoService;

    public List<BattgroupData> getListWithTestTime(String fileId) {
    @Autowired
    private TestParamService testParamService;

    @Autowired
    private StationInfoService stationInfoService;

    public BattGroupStationInfoWithFileParam getListWithTestTime(String fileId) {
        BattGroupStationInfoWithFileParam info = new BattGroupStationInfoWithFileParam();
        //查询站点信息和文件参数信息
        StationInfo stationInfo = stationInfoService.getByFileId(fileId);

        String battGroupId = battGroupInfoService.getByFileId(fileId).getBattgroupId();
        List<BattgroupData> dataList = mapper.getListWithTestTime(battGroupId);
        //查询系数和阈值是否禁用
        //BattgroupInfo info = battGroupInfoService.getByBattGroupId(fileId);
        FileParam param = fileParamService.getFactorsAndThreshold(fileId);
        if(param.getFactorDisabled() == 1){ //系数和阈值禁用,不需要判断处理阈值
            return dataList;
        FileParam param = fileParamService.getByFileId(fileId);
        TestParam param2 = testParamService.getFactorsAndThreshold();

        info.setStationInfo(stationInfo);
        info.setFileParam(param);
        if(param2.getEnabled() == 0){ //系数和阈值禁用,不需要判断处理阈值
            info.setDataList(dataList);
            return info;
        }
        Float stdVol = param.getBattVol();
        //Float stdVol = param.getBattVol();
        Float stdCap = param.getBattCap();
        Float stdRes = param.getBattRes();
        Float volLowCoeK1 = param.getVolLowCoeK1();
        Float volHighCoeK2 = param.getVolHighCoeK2();
        Float resGoodCoeK3 = param.getResGoodCoeK3();
        Float resBadCoeK4 = param.getResBadCoeK4();
        Float volLowCoeK1 = null;
        Float volHighCoeK2 = null;
        //电压不同,电压阈值不同
        if(param.getBattVol() == 2){
            volLowCoeK1 = param2.getVol2LowCoeK1();
            volHighCoeK2 = param2.getVol2HighCoeK2();
        }
        else if(param.getBattVol() == 1.2){
            volLowCoeK1 = param2.getVol1d2LowCoeK1();
            volHighCoeK2 = param2.getVol1d2HighCoeK2();
        }
        else if(param.getBattVol() == 6){
            volLowCoeK1 = param2.getVol6LowCoeK1();
            volHighCoeK2 = param2.getVol6HighCoeK2();
        }
        else if(param.getBattVol() == 12){
            volLowCoeK1 = param2.getVol12LowCoeK1();
            volHighCoeK2 = param2.getVol12HighCoeK2();
        }else{ //电压非常规值,则默认设置为2v的电压阈值
            volLowCoeK1 = param2.getVol2LowCoeK1();
            volHighCoeK2 = param2.getVol2HighCoeK2();
        }
        Float resGoodCoeK3 = param2.getResGoodCoeK3();
        Float resBadCoeK4 = param2.getResBadCoeK4();
        Float chainRes = param.getChainRes();
        Float finalVolLowCoeK = volLowCoeK1;
        Float finalVolHighCoeK = volHighCoeK2;
        dataList.forEach(data->{
            //判断处理阈值
            Float br = data.getBr();
            Float bv = data.getBv();
            Float cr = data.getCr(); //连接条阻抗
            Float br =  Float.parseFloat(data.getBr());
            Float bs =  Float.parseFloat(data.getBs());
            Float bv =  Float.parseFloat(data.getBv());
            Float cr =  Float.parseFloat(data.getCr()); //连接条阻抗

            if(bv < stdVol*volLowCoeK1){
                data.setLowVolFlag(1);
            }else if(bv > stdVol*volHighCoeK2){
                data.setHighVolFlag(1);
            if(bv!=0.0 && bv <= finalVolLowCoeK){
                data.setLowVolFlag(true);
            }else if(bv >= finalVolHighCoeK){
                data.setHighVolFlag(true);
            }

            if(br > stdRes*resGoodCoeK3){
                if(br > stdRes*resBadCoeK4){
                    data.setHighResFlag2(1);
            if(br >= stdRes*resGoodCoeK3/100){
                if(br >= stdRes*resBadCoeK4/100){
                    data.setHighResFlag2(true);
                }else{
                    data.setHighResFlag1(1);
                    data.setHighResFlag1(true);
                }
            }

            if(cr > chainRes){
                data.setHighChainResFlag(1);
            if(bs <= (1/stdRes)*param2.getSerGoodCoeK6()/100){
                if(bs >= chainRes*param2.getSerBadCoeK7()/100) {
                    data.setHighSerFlag1(true);
                }else {
                    data.setHighSerFlag2(true);
                }
            }
            if(cr >= chainRes*param2.getChainResCoeK5()/100){
                if(cr >= chainRes*param2.getChainResChange()/100) {
                    data.setHighChainResFlag2(true);
                }else {
                    data.setHighChainResFlag1(true);
                }
            }
            /*//预估容量
            if(stdRes==0){
                data.setEstimatedCap(stdCap);
            }else{
                float resRate = stdRes/br;
                if(resRate<=0.5f){
                    data.setEstimatedCap(0f);
                }else {
                    data.setEstimatedCap(stdRes / br * stdCap);
                }
            }*/
            float preCapPercent=MathUtil.getPreCapTest(Float.valueOf(br),stdRes);
            //容量百分比修改
            data.setPreCapPercent(preCapPercent);
            //预估容量
            data.setEstimatedCap(preCapPercent*stdCap);
            //内阻偏差率
            float resDevRate=(Float.valueOf(br)-stdRes)/stdRes;
            data.setResDevRate(resDevRate);
        });
        return dataList;

        info.setDataList(dataList);
        info.setFileParam(param);

        return info;
    }

    public Map<String, String> getStandardDeviation(List<BattgroupData> monList) {
        Map<String,String> map = new HashMap<>();
        Stream<BattgroupData> stream = monList.stream();
        List<Float> bvList = stream.map(BattgroupData::getBv).collect(Collectors.toList());
        List<Float> brList = stream.map(BattgroupData::getBr).collect(Collectors.toList());
        List<Float> crList = stream.map(BattgroupData::getCr).collect(Collectors.toList());
        List<Float> bsList = stream.map(BattgroupData::getBs).collect(Collectors.toList());
        List<Float> bvList = monList.stream().map(BattgroupData::getBv).map(Float::parseFloat).collect(Collectors.toList());
        List<Float> brList = monList.stream().map(BattgroupData::getBr).map(Float::parseFloat).collect(Collectors.toList());
        List<Float> crList = monList.stream().map(BattgroupData::getCr).map(Float::parseFloat).collect(Collectors.toList());
        List<Float> bsList = monList.stream().map(BattgroupData::getBs).map(Float::parseFloat).collect(Collectors.toList());

        NumberFormat percentInstance = NumberFormat.getPercentInstance();
        percentInstance.setMinimumFractionDigits(2);
        float stdDevBv = MathUtil.getStandardDeviation(bvList);
        float stdDevBr = MathUtil.getStandardDeviation(brList);
        float stdDevCr = MathUtil.getStandardDeviation(crList);
        float stdDevBs = MathUtil.getStandardDeviation(bsList);
        map.put("stdDevBv",stdDevBv*100+"%");
        map.put("stdDevBr",stdDevBr*100+"%");
        map.put("stdDevCr",stdDevCr*100+"%");
        map.put("stdDevBs",stdDevBs*100+"%");
        map.put("stdDevBv",percentInstance.format(stdDevBv));
        map.put("stdDevBr",percentInstance.format(stdDevBr));
        map.put("stdDevCr",percentInstance.format(stdDevCr));
        map.put("stdDevBs",percentInstance.format(stdDevBs));
        return map;
    }

    public Response getComparedList(String baseFileId, String fileId) {
        //String baseBattGroupId = battGroupInfoService.getByFileId(baseFileId).getBattgroupId();
        //String battGroupId = battGroupInfoService.getByFileId(fileId).getBattgroupId();
        List<BattgroupData> baseDataList = getListWithTestTime(baseFileId);
        List<BattgroupData> dataList = getListWithTestTime(fileId);
        BattGroupStationInfoWithFileParam baseInfo = getListWithTestTime(baseFileId);
        List<BattgroupData> baseDataList = baseInfo.getDataList();
        BattGroupStationInfoWithFileParam info = getListWithTestTime(fileId);
        List<BattgroupData> dataList = info.getDataList();

        //内阻变化率,均一性;电压变化率,均一性
        Map<String,List<String>> map = new HashMap<>();
        Map<String,Object> map = new HashMap<>();
        List<String> resChangeRate = new LinkedList<>();
        List<String> volChangeRate = new LinkedList<>();
        List<String> resBalanceRate = new LinkedList<>();
        List<String> volBalanceRate = new LinkedList<>();

        float sdBaseBr = MathUtil.getStandardDeviation(baseDataList.stream().map(BattgroupData::getBr).collect(Collectors.toList()));
        float sdBaseBv = MathUtil.getStandardDeviation(baseDataList.stream().map(BattgroupData::getBv).collect(Collectors.toList()));
        float sdBr = MathUtil.getStandardDeviation(dataList.stream().map(BattgroupData::getBr).collect(Collectors.toList()));
        float sdBv = MathUtil.getStandardDeviation(dataList.stream().map(BattgroupData::getBv).collect(Collectors.toList()));
        float sdBaseBr = MathUtil.getStandardDeviation(baseDataList.stream().map(BattgroupData::getBr).map(Float::parseFloat).collect(Collectors.toList()));
        float sdBaseBv = MathUtil.getStandardDeviation(baseDataList.stream().map(BattgroupData::getBv).map(Float::parseFloat).collect(Collectors.toList()));
        float sdBr = MathUtil.getStandardDeviation(dataList.stream().map(BattgroupData::getBr).map(Float::parseFloat).collect(Collectors.toList()));
        float sdBv = MathUtil.getStandardDeviation(dataList.stream().map(BattgroupData::getBv).map(Float::parseFloat).collect(Collectors.toList()));

        resBalanceRate.add(sdBaseBr*100+"%");
        resBalanceRate.add(sdBr*100+"%");
        NumberFormat percentInstance = NumberFormat.getPercentInstance();
        percentInstance.setMinimumFractionDigits(2);

        volBalanceRate.add(sdBaseBv*100+"%");
        volBalanceRate.add(sdBv*100+"%");
        resBalanceRate.add(percentInstance.format(sdBaseBr));
        resBalanceRate.add(percentInstance.format(sdBr));

        volBalanceRate.add(percentInstance.format(sdBaseBv));
        volBalanceRate.add(percentInstance.format(sdBv));

        for (int i = 0; i < dataList.size(); i++) {
            BattgroupData data = dataList.get(i);
@@ -125,8 +204,8 @@
            }
            if(baseData!=null){
                //进行内阻和电压变化率计算
                Float br = data.getBr();
                Float baseBr = baseData.getBr();
                Float br =  Float.parseFloat(data.getBr());
                Float baseBr =  Float.parseFloat(baseData.getBr());
                if(baseBr == 0.0f){
                    if(br == 0.0f){
                        resChangeRate.add("0.0%");
@@ -135,11 +214,11 @@
                    }
                }else {
                    float brFloat = BigDecimal.valueOf(br).subtract(BigDecimal.valueOf(baseBr)).divide(BigDecimal.valueOf(baseBr), 4, BigDecimal.ROUND_HALF_UP).floatValue();
                    resChangeRate.add(brFloat * 100 + "%");
                    resChangeRate.add(percentInstance.format(brFloat));
                }

                Float bv = data.getBv();
                Float baseBv = baseData.getBv();
                Float bv =  Float.parseFloat(data.getBv());
                Float baseBv =  Float.parseFloat(baseData.getBv());
                if(baseBv == 0.0f){
                    if(bv == 0.0f){
                        volChangeRate.add("0.0%");
@@ -148,28 +227,27 @@
                    }
                }else {
                    float bvFloat = BigDecimal.valueOf(bv).subtract(BigDecimal.valueOf(baseBv)).divide(BigDecimal.valueOf(baseBv), 4, BigDecimal.ROUND_HALF_UP).floatValue();
                    volChangeRate.add(bvFloat * 100 + "%");
                    volChangeRate.add(percentInstance.format(bvFloat));
                }
            }
        }
        //将均一性值,也进行变化率计算
        float brFloat = BigDecimal.valueOf(sdBr).subtract(BigDecimal.valueOf(sdBaseBr)).divide(BigDecimal.valueOf(sdBaseBr),4, BigDecimal.ROUND_HALF_UP).floatValue();
        resChangeRate.add(brFloat*100+"%");
        //均一性暂时取消,去除
        /*float brFloat = BigDecimal.valueOf(sdBr).subtract(BigDecimal.valueOf(sdBaseBr)).divide(BigDecimal.valueOf(sdBaseBr),4, BigDecimal.ROUND_HALF_UP).floatValue();
        resChangeRate.add(percentInstance.format(brFloat));

        float bvFloat = BigDecimal.valueOf(sdBv).subtract(BigDecimal.valueOf(sdBaseBv)).divide(BigDecimal.valueOf(sdBaseBv),4, BigDecimal.ROUND_HALF_UP).floatValue();
        volChangeRate.add(bvFloat*100+"%");
        volChangeRate.add(percentInstance.format(bvFloat));*/

        map.put("resChangeRate",resChangeRate);
        map.put("volChangeRate",volChangeRate);
        map.put("resBalanceRate",resBalanceRate);
        map.put("volBalanceRate",volBalanceRate);
        map.put("fileParamBase",baseInfo.getFileParam());
        return new Response().setIII(1,baseDataList,dataList,map,null);
    }

    public static void main(String[] args) {
        Float bv = 0.353f;
        Float baseBv = 0.354f;
        float bvFloat = BigDecimal.valueOf(bv).subtract(BigDecimal.valueOf(baseBv)).divide(BigDecimal.valueOf(baseBv),4,BigDecimal.ROUND_HALF_UP).floatValue();
        System.out.println((bvFloat * 100 + "%"));

    }
}