first commit

pom.xml

@@ -11,7 +11,7 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>com.gct.tool</groupId>
-    <artifactId>data-analyse-tool</artifactId>
+    <artifactId>data-download-tool</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <name>data_analyse_tool</name>
     <description>数据分析工具</description>

src/main/Test/MyTest.java

@@ -29,7 +29,7 @@ public class MyTest {
     @Test
     public void test() {
 //        aoidDailyYieldServicel.list(new QueryWrapper<AoidDailyYield>().eq("prod_date::date",LocalDate.parse("2022-09-27")));
-        dataAnalyseService.produceLiqAnalyse();
+//        dataAnalyseService.produceLiqAnalyse();
 
     }
 }

src/main/java/com/gct/tool/entity/excel/SingleGtData.java

@@ -0,0 +1,38 @@
+package com.gct.tool.entity.excel;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * @author xusirui 2022/11/3
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class SingleGtData {
+
+    @ExcelProperty("井号")
+    public String wellId;
+
+    @ExcelProperty("生产日期")
+    public String prodDate;
+
+    @ExcelProperty("最大载荷")
+    public Double maxLoad;
+
+    @ExcelProperty("最小载荷")
+    public Double minLoad;
+
+    @ExcelProperty("功图")
+    public String workDiagram;
+
+    @ExcelProperty("功图面积")
+    public Double workDiagramArea;
+
+    @ExcelProperty("分析结果")
+    public String analyseResult;
+}

src/main/java/com/gct/tool/service/impl/DataAnalyseService.java

@@ -3,34 +3,32 @@ package com.gct.tool.service.impl;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.ExcelWriter;
 import com.alibaba.excel.write.metadata.WriteSheet;
-import com.baomidou.mybatisplus.core.conditions.interfaces.Func;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.gct.common.util.SGTUtil;
-import com.gct.tool.entity.aoid.AoidDailyYield;
 import com.gct.tool.entity.aoid.AoidSinglegtYield;
 import com.gct.tool.entity.excel.LiqAnalyseData;
+import com.gct.tool.entity.excel.SingleGtData;
 import com.gct.tool.service.aoid.AoidDailyYieldService;
 import com.gct.tool.service.aoid.AoidSinglegtYieldService;
 import com.gct.tool.service.centralbase.CbCdWellSourceService;
-import io.swagger.models.auth.In;
-import org.apache.commons.lang.StringUtils;
-import org.apache.poi.util.StringUtil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.ApplicationArguments;
 import org.springframework.boot.ApplicationRunner;
-import org.springframework.context.ApplicationListener;
+import org.springframework.core.io.ClassPathResource;
 import org.springframework.stereotype.Service;
 
+import java.io.BufferedReader;
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStreamReader;
 import java.time.LocalDate;
-import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.*;
-import java.util.function.Function;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 /**
  * @author xusirui 2022/9/28
@@ -38,12 +36,15 @@ import java.util.stream.Stream;
 @Service
 public class DataAnalyseService implements ApplicationRunner {
 
-    @Value("${produce-date}")
-    String produceDate;
-
     @Value("${gt-total}")
     Integer gtTotal;
 
+    @Value("${begin-date}")
+    String beginDate;
+
+    @Value("${end-date}")
+    String endDate;
+
     @Autowired
     AoidDailyYieldService aoidDailyYieldService;
 
@@ -62,295 +63,83 @@ public class DataAnalyseService implements ApplicationRunner {
         if (!file.exists()) file.mkdirs();
     }
 
-    public void produceLiqAnalyse() {
-        String fileName = excelFileBasePath + "liqAnalyse-" + produceDate + ".xlsx";
-        File file = new File(fileName);
-        if (!file.exists()) {
-            try {
-                file.createNewFile();
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
+    public void produceLiqAnalyseTotal(){
+        for(LocalDate date = LocalDate.parse(beginDate);date.isBefore(LocalDate.parse(endDate));date = date.plusMonths(1)){
+            produceLiqAnalyseMonth(date);
         }
-
-        Map<String, List<String>> wellByWorkArea = cbCdWellSourceService.divideWellByWorkArea();
-        HashMap<String, List<String>> copyMap = new HashMap<>();
-        copyMap.put("第一采油作业区",wellByWorkArea.get("第一采油作业区"));
-        copyMap.put("第二采油作业区",wellByWorkArea.get("第二采油作业区"));
-        copyMap.put("第三采油作业区",wellByWorkArea.get("第三采油作业区"));
-        wellByWorkArea = copyMap;
-
-        ExcelWriter excelWriter = EasyExcel.write(fileName, LiqAnalyseData.class).build();
-
-        wellByWorkArea.forEach((workArea, wellIdList) -> {
-            WriteSheet writeSheet = EasyExcel.writerSheet(workArea).build();
-
-            List<LiqAnalyseData> liqAnalyseDataList = aoidDailyYieldService.list(new QueryWrapper<AoidDailyYield>()
-                    .eq("prod_date::date", LocalDate.parse(produceDate))
-                    .in("well_id", wellIdList)).stream().map(aoidDailyYield -> {
-                LiqAnalyseData liqAnalyseData = new LiqAnalyseData();
-                liqAnalyseData.setLiqProd(aoidDailyYield.getLiqProdDaily());
-                liqAnalyseData.setLiqProd2(aoidDailyYield.getA2LiqProdDaily());
-                liqAnalyseData.setWellId(aoidDailyYield.getWellId());
-                liqAnalyseData.setProdDate(aoidDailyYield.getProdDate().format(formatter));
-                if (!Objects.isNull(aoidDailyYield.getLiqProdDaily()) && !Objects.isNull(aoidDailyYield.getA2LiqProdDaily())) {
-                    if (aoidDailyYield.getA2LiqProdDaily() > 1e-6)
-                        liqAnalyseData.setErrorRate(Math.abs(aoidDailyYield.getLiqProdDaily() - aoidDailyYield.getA2LiqProdDaily()) / aoidDailyYield.getA2LiqProdDaily());
-                    else liqAnalyseData.setErrorRate(100.0);
-                }
-                liqAnalyseData.setAoidDailyYield(aoidDailyYield);
-                return liqAnalyseData;
-            }).filter(liqAnalyseData -> Objects.nonNull(liqAnalyseData.getErrorRate()) && liqAnalyseData.getLiqProd() < 200)
-                    .collect(Collectors.toList());
-
-            liqAnalyseDataList.sort(Comparator.comparingDouble(LiqAnalyseData::getErrorRate));
-            // init
-            liqAnalyseDataList.forEach(liqAnalyseData -> {
-                liqAnalyseData.setAnalyseResult("");
-                List<AoidSinglegtYield> aoidSinglegtYieldList = aoidSinglegtYieldService.list(new QueryWrapper<AoidSinglegtYield>()
-                        .eq("well_id", liqAnalyseData.getWellId())
-                        .between("prod_date", LocalDate.parse(produceDate).minusDays(1).atTime(16, 0, 0),
-                                LocalDate.parse(produceDate).atTime(16, 0, 0)));
-                liqAnalyseData.setAoidSinglegtYieldList(aoidSinglegtYieldList);
-            });
-        /*    liqAnalyseDataList.forEach(liqAnalyseData ->
-                    liqAnalyseData.setAnalyseResult(liqAnalyseData.analyseResult + judgeIntermittenceOpen(liqAnalyseData.wellId)));
-            liqAnalyseDataList.forEach(liqAnalyseData ->
-                    liqAnalyseData.setAnalyseResult(liqAnalyseData.analyseResult + judgeRatioUndulate(liqAnalyseData.wellId)));*/
-            liqAnalyseDataList.forEach(liqAnalyseData ->
-                    liqAnalyseData.setAnalyseResult(liqAnalyseData.analyseResult + judgeZhcAndRcy(liqAnalyseData)));
-
-            liqAnalyseDataList.forEach(this::calTheoryLiq);
-            System.out.println("calculate theory liq success");
-            liqAnalyseDataList.forEach(this::calLoadDifferenceVariance);
-            System.out.println("calculate load difference variance success");
-            liqAnalyseDataList.forEach(this::calYxccVariance);
-            System.out.println("calculate effect stroke variance success");
-            liqAnalyseDataList.forEach(this::calTheoryLoadDiff);
-            System.out.println("calculate theory load difference success");
-            excelWriter.write(liqAnalyseDataList, writeSheet);
-        });
-        excelWriter.finish();
     }
 
-    public void calTheoryLiq(LiqAnalyseData liqAnalyseData) {
-        Double dailyLiq = liqAnalyseData.getAoidDailyYield().getLiqProdDaily();
-        if (Objects.isNull(dailyLiq)) {
-            return;
-        }
-        double deltaLiq = 1000;
-        for (AoidSinglegtYield aoidSinglegtYield : liqAnalyseData.getAoidSinglegtYieldList()) {
-            Double singleLiq = aoidSinglegtYield.getLiqProdDaily();
-            if (Objects.nonNull(singleLiq)) {
-                if (Math.abs(singleLiq - dailyLiq) < deltaLiq) {
-                    deltaLiq = Math.abs(singleLiq - dailyLiq);
-                    Double bj = aoidSinglegtYield.getBj();
-                    Double yxcc = aoidSinglegtYield.getYxcc();
-                    Double cc = aoidSinglegtYield.getFrequence();
-                    liqAnalyseData.setTheoryLiqProd(get2EffectMath(1440 * Math.PI * bj * bj / 4 * yxcc * cc / 1e6));
-                }
-            }
-        }
-    }
-
-    public void calTheoryLoadDiff(LiqAnalyseData liqAnalyseData){
-        double maxTheoryLoadDiff = 0;
-        double minTheoryLoadDiff = 999;
-        for (AoidSinglegtYield aoidSinglegtYield : liqAnalyseData.getAoidSinglegtYieldList()) {
-            if (aoidSinglegtYield.getSgtIsLegal()!=1)continue;
-            Double[][] sgt = SGTUtil.encodeToDoubleArray(aoidSinglegtYield.getSgt());
-            Double[] maxStroke = Arrays.stream(sgt).max(Comparator.comparingDouble(x -> x[0])).get();
-            double theoryLoadDiff = 0;
-            for (double i=0;i<maxStroke[0];i+=0.02){
-                double l = i;
-                double r = l+0.02;
-                List<Double[]> list = Arrays.stream(sgt).filter(x -> l <= x[0] && x[0] < r).collect(Collectors.toList());
-                if (list.isEmpty())continue;
-                Double maxLoad = list.stream().max(Comparator.comparingDouble(x -> x[1])).get()[1];
-                Double minLoad = list.stream().min(Comparator.comparingDouble(x -> x[1])).get()[1];
-                theoryLoadDiff = Math.max(theoryLoadDiff,maxLoad-minLoad);
+    public List<String> readWellIds(){
+        try{
+            ClassPathResource resource = new ClassPathResource("wellIds.txt");
+            BufferedReader br = new BufferedReader(new InputStreamReader(resource.getInputStream()));
+            String wellId;
+            List<String> wellIds = new ArrayList<>();
+            while ((wellId = br.readLine())!=null){
+                wellIds.add(wellId);
             }
-            maxTheoryLoadDiff = Math.max(maxTheoryLoadDiff,theoryLoadDiff);
-            minTheoryLoadDiff = Math.min(maxTheoryLoadDiff,theoryLoadDiff);
-        }
-        liqAnalyseData.setMaxTheoryLoadDiff(maxTheoryLoadDiff);
-        liqAnalyseData.setMinTheoryLoadDiff(minTheoryLoadDiff);
-    }
-
-    public void calYxccVariance(LiqAnalyseData liqAnalyseData){
-        List<Double> yxccs = liqAnalyseData.getAoidSinglegtYieldList()
-                .stream()
-                .map(AoidSinglegtYield::getYxcc)
-                .filter(Objects::nonNull)
-                .collect(Collectors.toList());
-        Double maxYxcc = 0d;
-        for (int i = 0; i < yxccs.size(); i++) {
-            if (yxccs.get(i)>maxYxcc)maxYxcc = yxccs.get(i);
+            return wellIds;
+        }catch (Exception e){
+            e.printStackTrace();
         }
-        if (maxYxcc==0)return;
-        for (int i = 0; i < yxccs.size(); i++) {
-            yxccs.set(i,yxccs.get(i)/maxYxcc*10);
-        }
-        Double aveYxcc = 0d;
-        for (int i = 0; i < yxccs.size(); i++) {
-            aveYxcc += yxccs.get(i);
-        }
-        aveYxcc/=yxccs.size();
-        double variance = 0d;
-        for (int i = 0; i < yxccs.size(); i++) {
-            variance+=(yxccs.get(i)-aveYxcc)*(yxccs.get(i)-aveYxcc);
-        }
-        variance/=yxccs.size();
-        liqAnalyseData.setEffectStrokeVariance(variance);
+        return new ArrayList<>();
     }
 
-    public void calLoadDifferenceVariance(LiqAnalyseData liqAnalyseData) {
-        List<Double> loadDiffs = liqAnalyseData.getAoidSinglegtYieldList()
-                .stream()
-                .map(aoidSinglegtYield -> {
-                    if (aoidSinglegtYield.getSgtIsLegal() == 0) return 0d;
-                    double[][] sgt = SGTUtil.encodeToUseArray(aoidSinglegtYield.getSgt());
-                    double[] maxLoadP = Arrays.stream(sgt).max(Comparator.comparingDouble(x -> x[1])).get();
-                    double[] minLoadP = Arrays.stream(sgt).min(Comparator.comparingDouble(x -> x[1])).get();
-                    return maxLoadP[1] - minLoadP[1];
-                }).collect(Collectors.toList());
-        if (loadDiffs.isEmpty()) return;
-        Double maxloadDiff = 0d;
-        for (int i = 0; i < loadDiffs.size(); i++) {
-            if (loadDiffs.get(i) > maxloadDiff) maxloadDiff = loadDiffs.get(i);
-        }
-        if (maxloadDiff == 0) return;
-        liqAnalyseData.setMaxLoadDiff(maxloadDiff);
-        liqAnalyseData.setPumpDepth(liqAnalyseData.getAoidDailyYield().getBs());
-        liqAnalyseData.setSubmergenceDegree(liqAnalyseData.getAoidDailyYield().getCmd());
-        for (int i = 0; i < loadDiffs.size(); i++) {
-            loadDiffs.set(i, loadDiffs.get(i) / maxloadDiff * 10);
-        }
-        Double aveLoadDiff = 0d;
-        for (int i = 0; i < loadDiffs.size(); i++) {
-            aveLoadDiff += loadDiffs.get(i);
-        }
-        aveLoadDiff /= loadDiffs.size();
-        double variance = 0;
-        for (int i = 0; i < loadDiffs.size(); i++) {
-            variance += (loadDiffs.get(i) - aveLoadDiff) * (loadDiffs.get(i) - aveLoadDiff);
-        }
-        variance /= loadDiffs.size();
-        liqAnalyseData.setLoadDifferenceVariance(get2EffectMath(variance));
-    }
-
-    private <T> List<T> getNonNullList(List<AoidSinglegtYield> list, Function<? super AoidSinglegtYield, T> getFun) {
-        return list.stream().map(getFun).filter(Objects::nonNull).collect(Collectors.toList());
-    }
-
-    private Double get2EffectMath(Double num) {
-        return Double.parseDouble(String.format("%.2f", num));
-    }
-
-    public String judgeIntermittenceOpen(String wellId) {
-
-        List<AoidSinglegtYield> list = aoidSinglegtYieldService.list(new QueryWrapper<AoidSinglegtYield>()
-                .eq("well_id", wellId)
-                .between("prod_date", LocalDate.parse(produceDate).minusDays(7).atTime(23, 59, 59),
-                        LocalDate.parse(produceDate).atTime(23, 59, 59)));
-        Map<LocalDate, Integer> map = new TreeMap<>((date1, date2) -> {
-            if (date1.isBefore(date2)) return -1;
-            if (date1.isAfter(date2)) return 1;
-            return 0;
-        });
-        list.forEach(aoidSinglegtYield -> {
-            LocalDate date = aoidSinglegtYield.getProdDate().toLocalDate();
-            map.putIfAbsent(date, 0);
-            if (aoidSinglegtYield.getStroke() != 0 && !StringUtils.isBlank(aoidSinglegtYield.getSgt())) {
-                map.put(date, map.get(date) + 1);
-            }
-        });
-        Integer[] counts = map.entrySet().stream().map(entry -> entry.getValue()).collect(Collectors.toList()).toArray(new Integer[]{});
-        for (int i = 0; i < counts.length; i++) {
-            if (counts[i] < gtTotal) counts[i] = 1;
-            else counts[i] = 0;
-            if (i >= 2 && counts[i] + counts[i - 1] + counts[i - 2] == 3) return "间开;";
-        }
-        return "";
-    }
-
-    public String judgeRatioUndulate(String wellId) {
-        List<AoidSinglegtYield> list = aoidSinglegtYieldService.list(new QueryWrapper<AoidSinglegtYield>()
-                .eq("well_id", wellId)
-                .eq("prod_date::date", LocalDate.parse(produceDate)));
-        String ans = "";
-        for (int i = 0; i < list.size(); i++) {
-            AoidSinglegtYield aoidSinglegtYield = list.get(i);
-
-            if (aoidSinglegtYield.getBdxs() > 2 || aoidSinglegtYield.getBdxs() < 0.1) {
-                ans += "标定系数异常;";
-                break;
+    public void produceLiqAnalyseMonth(LocalDate beginDate) {
+        String fileName = excelFileBasePath + "功图数据-" + beginDate.format(DateTimeFormatter.ofPattern("yyyy-MM")) + ".xlsx";
+        File file = new File(fileName);
+        if (!file.exists()) {
+            try {
+                file.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
             }
         }
-
-        List<Double> bdxss = list.stream().map(AoidSinglegtYield::getBdxs).filter(Objects::nonNull).collect(Collectors.toList());
-        if (bdxss.isEmpty()) ans += "标定系数缺失";
-        else {
-            Double maxBdxs = bdxss.stream().max(Double::compare).get();
-            Double minBdxs = bdxss.stream().min(Double::compare).get();
-            if (maxBdxs - minBdxs > 0.1) ans += "标定系数变化;";
-        }
-
-        List<Double> yxccs = list.stream().map(AoidSinglegtYield::getYxcc).filter(Objects::nonNull).collect(Collectors.toList());
-        if (yxccs.isEmpty()) {
-            ans += "部分有效冲程无法计算;";
-        } else {
-            Double maxYxcc = yxccs.stream().max(Double::compare).get();
-            Double minYxcc = yxccs.stream().min(Double::compare).get();
-            if (maxYxcc - minYxcc > maxYxcc * 0.5) ans += "供液不稳;";
-        }
-
-        return ans;
-    }
-
-    public String judgeZhcAndRcy(LiqAnalyseData liqAnalyseData) {
-        String ans = "";
-        List<AoidSinglegtYield> list = liqAnalyseData.getAoidSinglegtYieldList();
-
-        List<Double> loadDiffs = liqAnalyseData.getAoidSinglegtYieldList()
-                .stream()
-                .map(aoidSinglegtYield -> {
-                    if (aoidSinglegtYield.getSgtIsLegal() == 0) return 0d;
-                    double[][] sgt = SGTUtil.encodeToUseArray(aoidSinglegtYield.getSgt());
-                    double[] maxLoadP = Arrays.stream(sgt).max(Comparator.comparingDouble(x -> x[1])).get();
-                    double[] minLoadP = Arrays.stream(sgt).min(Comparator.comparingDouble(x -> x[1])).get();
-                    return maxLoadP[1] - minLoadP[1];
-                }).collect(Collectors.toList());
-        if (loadDiffs.isEmpty()) ans += "载荷差缺失";
-        else {
-            Double maxLoadDiff = loadDiffs.stream().max(Double::compare).get();
-            Double minLoadDiff = loadDiffs.stream().min(Double::compare).get();
-
-            if (maxLoadDiff * 0.6 > minLoadDiff && maxLoadDiff - minLoadDiff > 4) ans += "载荷差波动超过40%;";
-            else if (maxLoadDiff * 0.7 > minLoadDiff && maxLoadDiff - minLoadDiff > 3) ans += "载荷差波动超过30%;";
-            else if (maxLoadDiff * 0.8 > minLoadDiff && maxLoadDiff - minLoadDiff > 2) ans += "载荷差波动超过20%;";
-        }
-
-        List<Double> liqProds = list.stream().map(AoidSinglegtYield::getLiqProdDaily).filter(Objects::nonNull).collect(Collectors.toList());
-        if (loadDiffs.isEmpty()) ans += "液量缺失";
-        else {
-            Double maxSingleRcl = liqProds.stream().max(Double::compare).get();
-            Double minSingleRcl = liqProds.stream().min(Double::compare).get();
-
-            if (maxSingleRcl * 0.6 > minSingleRcl && maxSingleRcl - minSingleRcl > 1.2) ans += "单张功图液量波动超过40%;";
-            else if (maxSingleRcl * 0.7 > minSingleRcl && maxSingleRcl - minSingleRcl > 0.9) ans += "单张功图液量波动超过30%;";
-            else if (maxSingleRcl * 0.8 > minSingleRcl && maxSingleRcl - minSingleRcl > 0.6) ans += "单张功图液量波动超过20%;";
-            else if (maxSingleRcl * 0.9 > minSingleRcl && maxSingleRcl - minSingleRcl > 0.3) ans += "单张功图液量波动超过10%;";
+        ExcelWriter excelWriter = EasyExcel.write(fileName, SingleGtData.class).build();
+        List<String> wellIds = readWellIds();
+        for (LocalDate date = beginDate;date.isBefore(beginDate.plusMonths(1));date = date.plusDays(1)){
+            System.out.println(date.format(DateTimeFormatter.ISO_LOCAL_DATE));
+            final LocalDate produceDate = date;
+                WriteSheet writeSheet = EasyExcel.writerSheet("第二采油作业区").build();
+                List<SingleGtData> singleGtDatas = aoidSinglegtYieldService.list(new QueryWrapper<AoidSinglegtYield>()
+                        .eq("prod_date::date", produceDate)
+                        .in("well_id",wellIds))
+                        .stream()
+                        .filter(aoidSinglegtYield -> aoidSinglegtYield.getSgtIsLegal() == 1)
+                        .map(aoidSinglegtYield -> {
+                            SingleGtData singleGtData = new SingleGtData();
+                            singleGtData.setProdDate(aoidSinglegtYield.getProdDate().format(formatter));
+                            singleGtData.setWorkDiagram(aoidSinglegtYield.getSgt());
+                            double[][] sgt = SGTUtil.encodeToUseArray(aoidSinglegtYield.getSgt());
+                            double[] maxLoadP = Arrays.stream(sgt).max(Comparator.comparingDouble(x -> x[1])).get();
+                            double[] minLoadP = Arrays.stream(sgt).min(Comparator.comparingDouble(x -> x[1])).get();
+                            singleGtData.setMaxLoad(maxLoadP[1]);
+                            singleGtData.setMinLoad(minLoadP[1]);
+                            singleGtData.setWellId(aoidSinglegtYield.getWellId());
+                            singleGtData.setAnalyseResult(aoidSinglegtYield.getEczdjg());
+                            double s = 0;
+                            for (int i = 0; i < sgt.length / 2 - 1; i++) {
+                                double h = Math.abs(sgt[i][0] - sgt[i + 1][0]);
+                                double Si = (sgt[i][1] + sgt[i + 1][1]) * h / 2.0;
+                                s += Si;
+                            }
+                            for (int i = sgt.length / 2 - 1; i < sgt.length - 1; i++) {
+                                double h = Math.abs(sgt[i][0] - sgt[i + 1][0]);
+                                double Si = (sgt[i][1] + sgt[i + 1][1]) * h / 2.0;
+                                s -= Si;
+                            }
+                            singleGtData.setWorkDiagramArea(s);
+                            return singleGtData;
+                        }).collect(Collectors.toList());
+                excelWriter.write(singleGtDatas, writeSheet);
         }
-
-
-        return ans;
+        excelWriter.finish();
     }
 
 
     @Override
     public void run(ApplicationArguments args) throws Exception {
-        produceLiqAnalyse();
+        produceLiqAnalyseTotal();
         System.exit(0);
     }
 }

src/main/resources/application-dev.yml

@@ -55,5 +55,6 @@ swagger:
     key-name: token
   enabled: true
 
-produce-date: 2022-09-27
-gt-total: 48
+gt-total: 48
+begin-date: 2022-05-01
+end-date: 2022-11-01

src/main/resources/application-pro.yml

@@ -55,5 +55,6 @@ swagger:
     key-name: token
   enabled: true
 
-produce-date: 2022-10-25
-gt-total: 24
+gt-total: 24
+begin-date: 2022-05-01
+end-date: 2022-11-01

src/main/resources/wellIds.txt

@@ -0,0 +1,100 @@
+0004
+0010
+0016A
+0023
+00251
+00252
+0028
+0030
+0031
+0035
+0036
+0037
+0039
+0041
+00453
+0047
+0051
+0055
+0059
+0064
+0068
+0070
+0073
+0079
+0083
+0084
+0089
+0090
+0095
+0207
+0208
+0209
+0211
+0213
+0218
+0605
+0608
+0616
+0617
+0706
+0708
+0709
+0781
+0912
+0913
+0914
+7601
+7603
+7608
+CH0405
+CH0507
+CH0509
+CH21008
+CH21076
+CH21077
+CH35001
+CH35004
+CH35014
+CH35015
+CH35026
+CH35027
+CH3505
+CH3507
+CH3508
+CH3516
+CH7209
+CH7244
+CHD35007
+h0113
+h0115
+h0117
+h0118
+h0120
+h0124
+h0126
+h0127
+h0128
+h0131
+h0133
+h0143
+h0145
+h0155
+h0156
+h0161
+h0164
+h0169
+h0174
+h0203
+h0225
+h0226
+h0229
+h0239
+h0542
+h0546
+h0549
+h0552
+h0554
+h0558
+h0559
+h0570