开发监视接口

common/src/main/java/com/gyee/common/vo/monitor/MatrixLineVo.java

@@ -0,0 +1,15 @@
+package com.gyee.common.vo.monitor;/*
+@author   谢生杰
+@date   2023/4/14-18:09
+*/
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class MatrixLineVo {
+    private String id;
+    private String name;
+    private List<MatrixVo> wtDataList;
+}

common/src/main/java/com/gyee/common/vo/monitor/MatrixProVo.java

@@ -0,0 +1,28 @@
+package com.gyee.common.vo.monitor;/*
+@author   谢生杰
+@date   2023/4/14-18:12
+*/
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class MatrixProVo {
+
+    private String id;
+    private String name;
+    private Integer djts;
+    private Integer bwts;
+    private Integer gzts;
+    private Integer jxts;
+    private Integer xdts;
+    private Integer slts;
+    private Integer lxts;
+    private Double speed;
+    private Double bzgl;
+    private Double llgl;
+    private Double sjgl;
+    private List<MatrixLineVo> lineVos;
+
+}

common/src/main/java/com/gyee/common/vo/monitor/MatrixWpVo.java

@@ -0,0 +1,14 @@
+package com.gyee.common.vo.monitor;/*
+@author   谢生杰
+@date   2023/4/14-18:22
+*/
+
+import lombok.Data;
+
+@Data
+public class MatrixWpVo {
+
+    private String id;
+    private String name;
+
+}

realtime/generationXK-service/src/main/java/com/gyee/generation/init/CacheContext.java

@@ -68,6 +68,8 @@ public class CacheContext implements CommandLineRunner {
     private IProBasicWeatherStationService proBasicWeatherStationService;
     @Resource
     private IProBasicBranchService proBasicBranchService;
+    @Resource
+    private IProBasicEnergyGroupService proBasicEnergyGroupService;
 
     @Value("${runWindpowerstation}")
     private String runWindpowerstation;
@@ -83,9 +85,11 @@ public class CacheContext implements CommandLineRunner {
     public static List<ProBasicPowerstation>  zwpls = new ArrayList<>();
     public static List<ProBasicCompany>  cpls = new ArrayList<>();
     public static List<ProBasicRegion>  rgls = new ArrayList<>();
+    public static List<ProBasicEnergyGroup>  egls = new ArrayList<>();
     public static Map<String,ProBasicProject> pjmap = new HashMap<>();
     public static Map<String,ProBasicLine> lnmap = new HashMap<>();
     public static Map<String,ProBasicRegion> rgmap = new HashMap<>();
+    public static Map<String,ProBasicEnergyGroup> egmap = new HashMap<>();
     public static Map<String,ProBasicCompany> cpmap = new HashMap<>();
 
     public static Map<String,List<ProBasicPowerstation>> cpwpmap = new HashMap<>();
@@ -112,7 +116,7 @@ public class CacheContext implements CommandLineRunner {
     public static Map<String,Map<String, ProBasicPowerstationPoint>> wswppointmap =new HashMap<>();
     public static Map<String,Map<String, ProBasicPowerstationPoint>> companypointmap =new HashMap<>();
     public static Map<String,Map<String, ProBasicPowerstationPoint>> regionpointmap =new HashMap<>();
-
+    public static Map<String,Map<String, ProBasicPowerstationPoint>> grouppointmap =new HashMap<>();
 
     public static Map<String,Map<Double,Double>> zbzglMap = new HashMap<>();
     public static Map<String,ProEconEquipmentmodel> modelMap = new HashMap<>();
@@ -256,6 +260,34 @@ public class CacheContext implements CommandLineRunner {
             }
         }
 
+        egls=proBasicEnergyGroupService.list().stream().filter(i->i.getIsAble()==1 && !i.getParentid().equals("0")).collect(Collectors.toList());
+        if  (!egls.isEmpty())
+        {
+            for(ProBasicEnergyGroup sq:egls)
+            {
+                egmap.put(sq.getId(),sq);
+
+                if (redisService.hasKey(sq.getId()+"0")){
+                    String eg0String = redisService.get(sq.getId()+"0");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    grouppointmap.put(sq.getId()+"0",stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId()+"-1")){
+                    String eg1String = redisService.get(sq.getId()+"-1");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    grouppointmap.put(sq.getId()+"-1",stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId()+"-2")){
+                    String eg2String = redisService.get(sq.getId()+"-2");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    grouppointmap.put(sq.getId()+"-2",stringWindpowerstationpointnewMap);
+                }
+            }
+        }
+
 
         for(ProBasicCompany cp:cpls)
         {

realtime/generationXK-service/src/main/java/com/gyee/generation/service/initalcache/CacheService.java

@@ -54,6 +54,8 @@ public class CacheService {
     private IProBasicSquareService proBasicSquareService;
     @Resource
     private IProBasicBranchService proBasicBranchService;
+    @Resource
+    private IProBasicEnergyGroupService energyGroupService;
 
 
     public void initRedisCache(){
@@ -215,6 +217,26 @@ public class CacheService {
             String s = JSONObject.toJSONString(codeaimap);
             redisService.set(i,s);
         });
+        log.info("--------------------------redisGroup");
+        List<ProBasicEnergyGroup> groups = energyGroupService.list().stream().filter(i->i.getIsAble().equals(1) && !i.getParentid().equals("0")).collect(Collectors.toList());
+        List<String> groupList = new ArrayList<>();
+//        List<String> regList = regs.stream().map(i->i.getId()).collect(Collectors.toList());
+        groups.stream().forEach(group -> {
+            groupList.add(group.getId()+"0");
+            groupList.add(group.getId()+"-1");
+            groupList.add(group.getId()+"-2");
+        });
+        groupList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i);
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i,s);
+        });
         log.info("--------------------------redis理论保证功率");
         Map<String, Map<Double,ProBasicModelPowerRd>> powerrdMap = new HashMap<>();
 

realtime/generationXK-service/src/main/java/com/gyee/generation/service/realtimelibrary/RegionCalreService.java

@@ -4,10 +4,7 @@ import com.gyee.common.contant.ContantXk;
 import com.gyee.common.model.PointData;
 import com.gyee.common.util.DateUtils;
 import com.gyee.generation.init.CacheContext;
-import com.gyee.generation.model.auto.ProBasicCompany;
-import com.gyee.generation.model.auto.ProBasicPowerstation;
-import com.gyee.generation.model.auto.ProBasicPowerstationPoint;
-import com.gyee.generation.model.auto.ProBasicRegion;
+import com.gyee.generation.model.auto.*;
 import com.gyee.generation.util.PointUtil;
 import com.gyee.generation.util.realtimesource.IEdosUtil;
 import org.springframework.stereotype.Service;
@@ -57,6 +54,33 @@ public class RegionCalreService  {
         edosUtil.sendMultiPoint(resultList);
     }
 
+    public void groupCal() throws Exception {
+
+
+        Date currentDate = DateUtils.getCurrentDate();
+        List<ProBasicEnergyGroup> egls = CacheContext.egls;
+        List<ProBasicPowerstation> zwpls = CacheContext.zwpls;
+        Map<String, Map<String, ProBasicPowerstationPoint>> grouppointmap = CacheContext.grouppointmap;
+        Map<String, Map<String, ProBasicPowerstationPoint>> wppointmap = CacheContext.wppointmap;
+        List<PointData> resultList = new ArrayList<>();
+        egls.stream().forEach(group->{
+            List<ProBasicPowerstation> wps0 = zwpls.stream().filter(wp -> wp.getGroupId().equals(group.getId())).collect(Collectors.toList());
+            List<ProBasicPowerstation> wps1 = wps0.stream().filter(wp -> wp.getId().contains("_FDC_")).collect(Collectors.toList());
+            List<ProBasicPowerstation> wps2 = wps0.stream().filter(wp -> wp.getId().contains("_GDC_")).collect(Collectors.toList());
+            if (wps1.size()>0)
+                weightingGroup(currentDate, grouppointmap, wppointmap, resultList, group, wps1, "-1");
+            if (wps2.size()>0)
+                weightingGroup(currentDate, grouppointmap, wppointmap, resultList, group, wps2, "-2");
+            if (wps0.size()>0)
+                weightingGroup(currentDate, grouppointmap, wppointmap, resultList, group, wps0, "0");
+
+        });
+        edosUtil.sendMultiPoint(resultList);
+    }
+
+
+
+
     public void RegionCal() throws Exception {
         Date currentDate = DateUtils.getCurrentDate();
         List<ProBasicRegion> rgls = CacheContext.rgls;
@@ -1002,5 +1026,448 @@ public class RegionCalreService  {
         resultList.add(PointUtil.createPointData(currentDate,slts.get(),zsltsPoint.getNemCode(),zsltsPoint.getName()));
         resultList.add(PointUtil.createPointData(currentDate,lxts.get(),zlxtsPoint.getNemCode(),zlxtsPoint.getName()));
     }
+    private void weightingGroup(Date currentDate, Map<String, Map<String, ProBasicPowerstationPoint>> grouppointmap, Map<String, Map<String, ProBasicPowerstationPoint>> wppointmap, List<PointData> resultList, ProBasicEnergyGroup group, List<ProBasicPowerstation> wps, String type) {
+        Map<String, ProBasicPowerstationPoint> powerstationPointMap = grouppointmap.get(group.getId()+type);
+        int fdcsize = wps.stream().filter(wp -> wp.getId().contains("_FDC_") && wp.getSpare3().equals("1")).collect(Collectors.toList()).size();
+        int gdcsize = wps.stream().filter(wp -> wp.getId().contains("_GDC_") && wp.getSpare3().equals("1")).collect(Collectors.toList()).size();
+        if (fdcsize==0)
+            fdcsize = 1;
+        if (gdcsize==0)
+            gdcsize=1;
+        ProBasicPowerstationPoint zsspjfsPoint = null;
+        ProBasicPowerstationPoint zsspjgzdPoint = null;
+        if (type.equals("-1")){
+            zsspjfsPoint = powerstationPointMap.get(ContantXk.SSPJFS);
+
+        }else if(type.equals("-2")){
+            zsspjgzdPoint = powerstationPointMap.get(ContantXk.SSPJGZD);
+
+        }else {
+            zsspjfsPoint = powerstationPointMap.get(ContantXk.SSPJFS);
+            zsspjgzdPoint = powerstationPointMap.get(ContantXk.SSPJGZD);
+        }
+
+        ProBasicPowerstationPoint zaqtsPoint = powerstationPointMap.get(ContantXk.AQTS);
+        ProBasicPowerstationPoint zczztPoint = powerstationPointMap.get(ContantXk.CZZT);
+        ProBasicPowerstationPoint zsszglPoint = powerstationPointMap.get(ContantXk.SSZGL);
+        ProBasicPowerstationPoint zsszllglPoint = powerstationPointMap.get(ContantXk.SSZLLGL);
+        ProBasicPowerstationPoint zsszbzglPoint = powerstationPointMap.get(ContantXk.SSZBZGL);
+        ProBasicPowerstationPoint zssznhglzsPoint = powerstationPointMap.get(ContantXk.SSZNHGLZS);
+        ProBasicPowerstationPoint zsszzyglPoint = powerstationPointMap.get(ContantXk.SSZZYGL);
+        ProBasicPowerstationPoint zsszkyglPoint = powerstationPointMap.get(ContantXk.SSZKYGL);
+        ProBasicPowerstationPoint zycglPoint = powerstationPointMap.get(ContantXk.ZYCGL);
+
+        ProBasicPowerstationPoint zgztsmxPoint = powerstationPointMap.get(ContantXk.GZTSMX);
+        ProBasicPowerstationPoint zcnslmxPoint = powerstationPointMap.get(ContantXk.CNSLGZTSMX);
+        ProBasicPowerstationPoint zjxtsmxPoint = powerstationPointMap.get(ContantXk.JXTSMX);
+        ProBasicPowerstationPoint zcnjxmxPoint = powerstationPointMap.get(ContantXk.CNSLJXTSMX);
+        ProBasicPowerstationPoint zdjtsmxPoint = powerstationPointMap.get(ContantXk.DJTSMX);
+        ProBasicPowerstationPoint zqxjclmxPoint = powerstationPointMap.get(ContantXk.QXJCLTSMX);
+        ProBasicPowerstationPoint zsdtjmxPoint = powerstationPointMap.get(ContantXk.SDTJTSMX);
+        ProBasicPowerstationPoint zxntsmxPoint = powerstationPointMap.get(ContantXk.XNTSMX);
+        ProBasicPowerstationPoint zxdtjmxPoint = powerstationPointMap.get(ContantXk.XDTJTSMX);
+        ProBasicPowerstationPoint zxdjclmxPoint = powerstationPointMap.get(ContantXk.XDJCLTSMX);
+        ProBasicPowerstationPoint zcwsldwmxPoint = powerstationPointMap.get(ContantXk.CWSLDWTSMX);
+        ProBasicPowerstationPoint zcwsltqmxPoint = powerstationPointMap.get(ContantXk.CWSLTQTSMX);
+        ProBasicPowerstationPoint zlxtsmxPoint = powerstationPointMap.get(ContantXk.LXTSMX);
+        ProBasicPowerstationPoint ztxzdmxPoint = powerstationPointMap.get(ContantXk.TXZDTSMX);
+        ProBasicPowerstationPoint zdjtsPoint = powerstationPointMap.get(ContantXk.DJTS);
+        ProBasicPowerstationPoint zyxtsPoint = powerstationPointMap.get(ContantXk.YXTS);
+        ProBasicPowerstationPoint zgztsPoint = powerstationPointMap.get(ContantXk.GZTJTS);
+        ProBasicPowerstationPoint zwhtsPoint = powerstationPointMap.get(ContantXk.JXTJTS);
+        ProBasicPowerstationPoint zxdtsPoint = powerstationPointMap.get(ContantXk.XDTS);
+        ProBasicPowerstationPoint zsltsPoint = powerstationPointMap.get(ContantXk.SLTS);
+        ProBasicPowerstationPoint zlxtsPoint = powerstationPointMap.get(ContantXk.TXZDTS);
+        AtomicReference<Double> sspjfs = new AtomicReference<>((double) 0);
+        AtomicReference<Double> sspjgzd = new AtomicReference<>((double) 0);
+        AtomicReference<Double> sszgl = new AtomicReference<>((double) 0);
+        AtomicReference<Double> zllgl = new AtomicReference<>((double) 0);
+        AtomicReference<Double> zbzgl = new AtomicReference<>((double) 0);
+        AtomicReference<Double> znhglzs = new AtomicReference<>((double) 0);
+        AtomicReference<Double> zzygl = new AtomicReference<>((double) 0);
+        AtomicReference<Double> zkygl = new AtomicReference<>((double) 0);
+        AtomicReference<Double> zycgl = new AtomicReference<>((double) 0);
+
+        AtomicReference<Double> gztsmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> cngzmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> jxtsmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> cnjxmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> djtsmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> qxjclmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> sdtjmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> xntsmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> xdtjmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> xdjclmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> cwsldwmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> cwsltqmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> lxtsmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> txzdmx = new AtomicReference<>((double) 0);
+        AtomicReference<Double> yxts = new AtomicReference<>((double) 0);
+        AtomicReference<Double> gzts = new AtomicReference<>((double) 0);
+        AtomicReference<Double> lxts = new AtomicReference<>((double) 0);
+        AtomicReference<Double> whts = new AtomicReference<>((double) 0);
+        AtomicReference<Double> xdts = new AtomicReference<>((double) 0);
+        AtomicReference<Double> slts = new AtomicReference<>((double) 0);
+        AtomicReference<Double> djts = new AtomicReference<>((double) 0);
+        Double zczzt = 0.0;
+        List<Double> aqtsList = new ArrayList<>();
+//        wps.stream().forEach(wp->{
+        for(ProBasicPowerstation wp : wps) {
+
+            Map<String, ProBasicPowerstationPoint> powerstationPointMap1 = wppointmap.get(wp.getId());
+
+            ProBasicPowerstationPoint sspjfsPoint = null;
+            ProBasicPowerstationPoint sspjgzdPoint = null;
+
+            if (wp.getId().contains("_FDC_")) {
+                sspjfsPoint = powerstationPointMap1.get(ContantXk.SSPJFS);
+
+            } else if (wp.getId().contains("_GDC_")) {
+                sspjgzdPoint = powerstationPointMap1.get(ContantXk.SSPJGZD);
+
+            }
+            ProBasicPowerstationPoint aqtsPoint = powerstationPointMap1.get(ContantXk.AQTS);
+            ProBasicPowerstationPoint czztPoint = powerstationPointMap1.get(ContantXk.CZZT);
+            ProBasicPowerstationPoint sszglPoint = powerstationPointMap1.get(ContantXk.SSZGL);
+            ProBasicPowerstationPoint sszllglPoint = powerstationPointMap1.get(ContantXk.SSZLLGL);
+            ProBasicPowerstationPoint sszbzglPoint = powerstationPointMap1.get(ContantXk.SSZBZGL);
+            ProBasicPowerstationPoint ssznhglzsPoint = powerstationPointMap1.get(ContantXk.SSZNHGLZS);
+            ProBasicPowerstationPoint sszzyglPoint = powerstationPointMap1.get(ContantXk.SSZZYGL);
+            ProBasicPowerstationPoint sszkyglPoint = powerstationPointMap1.get(ContantXk.SSZKYGL);
+            ProBasicPowerstationPoint sszycglPoint = powerstationPointMap1.get(ContantXk.ZYCGL);
+
+            ProBasicPowerstationPoint gztsmxPoint = powerstationPointMap1.get(ContantXk.GZTSMX);
+            ProBasicPowerstationPoint cnslmxPoint = powerstationPointMap1.get(ContantXk.CNSLGZTSMX);
+            ProBasicPowerstationPoint jxtsmxPoint = powerstationPointMap1.get(ContantXk.JXTSMX);
+            ProBasicPowerstationPoint cnjxmxPoint = powerstationPointMap1.get(ContantXk.CNSLJXTSMX);
+            ProBasicPowerstationPoint djtsmxPoint = powerstationPointMap1.get(ContantXk.DJTSMX);
+            ProBasicPowerstationPoint qxjclmxPoint = powerstationPointMap1.get(ContantXk.QXJCLTSMX);
+            ProBasicPowerstationPoint sdtjmxPoint = powerstationPointMap1.get(ContantXk.SDTJTSMX);
+            ProBasicPowerstationPoint xntsmxPoint = powerstationPointMap1.get(ContantXk.XNTSMX);
+            ProBasicPowerstationPoint xdtjmxPoint = powerstationPointMap1.get(ContantXk.XDTJTSMX);
+            ProBasicPowerstationPoint xdjclmxPoint = powerstationPointMap1.get(ContantXk.XDJCLTSMX);
+            ProBasicPowerstationPoint cwsldwmxPoint = powerstationPointMap1.get(ContantXk.CWSLDWTSMX);
+            ProBasicPowerstationPoint cwsltqmxPoint = powerstationPointMap1.get(ContantXk.CWSLTQTSMX);
+            ProBasicPowerstationPoint lxtsmxPoint = powerstationPointMap1.get(ContantXk.LXTSMX);
+            ProBasicPowerstationPoint txzdmxPoint = powerstationPointMap1.get(ContantXk.TXZDTSMX);
+            ProBasicPowerstationPoint djtsPoint = powerstationPointMap1.get(ContantXk.DJTS);
+            ProBasicPowerstationPoint yxtsPoint = powerstationPointMap1.get(ContantXk.YXTS);
+            ProBasicPowerstationPoint gztsPoint = powerstationPointMap1.get(ContantXk.GZTJTS);
+            ProBasicPowerstationPoint whtsPoint = powerstationPointMap1.get(ContantXk.JXTJTS);
+            ProBasicPowerstationPoint xdtsPoint = powerstationPointMap1.get(ContantXk.XDTS);
+            ProBasicPowerstationPoint sltsPoint = powerstationPointMap1.get(ContantXk.SLTS);
+            ProBasicPowerstationPoint lxtsPoint = powerstationPointMap1.get(ContantXk.TXZDTS);
+
+
+            try {
+                double temp = edosUtil.getRealData(aqtsPoint).getPointValueInDouble();
+                aqtsList.add(temp);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+            try {
+                double temp1 = edosUtil.getRealData(czztPoint).getPointValueInDouble();
+                if (temp1 == 0) {
+                    continue;
+                }else {
+                    zczzt = 1.0;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+            if (wp.getId().contains("_FDC_")) {
+                ProBasicPowerstationPoint finalSspjfsPoint = sspjfsPoint;
+                sspjfs.updateAndGet(v -> {
+                    try {
+                        return new Double((double) (v + edosUtil.getRealData(finalSspjfsPoint).getPointValueInDouble()));
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                    return v;
+                });
+
+            } else if (wp.getId().contains("_GDC_")) {
+                ProBasicPowerstationPoint finalSspjgzdPoint = sspjgzdPoint;
+                sspjgzd.updateAndGet(v -> {
+                    try {
+                        return new Double((double) (v + edosUtil.getRealData(finalSspjgzdPoint).getPointValueInDouble()));
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                    return v;
+                });
+            }
+            sszgl.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(sszglPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            zllgl.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(sszllglPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            zbzgl.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(sszbzglPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            znhglzs.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(ssznhglzsPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            zzygl.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(sszzyglPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            zkygl.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(sszkyglPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            zycgl.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(sszycglPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+
+
+            gztsmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(gztsmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            cngzmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(cnslmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            jxtsmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(jxtsmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            cnjxmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(cnjxmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            djtsmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(djtsmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            qxjclmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(qxjclmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            sdtjmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(sdtjmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            xntsmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(xntsmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            xdtjmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(xdtjmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            xdjclmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(xdjclmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            cwsldwmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(cwsldwmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            cwsltqmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(cwsltqmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            lxtsmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(lxtsmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            txzdmx.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(txzdmxPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            djts.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(djtsPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            yxts.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(yxtsPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            gzts.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(gztsPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            whts.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(whtsPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            xdts.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(xdtsPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            slts.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(sltsPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+            lxts.updateAndGet(v -> {
+                try {
+                    return new Double((double) (v + edosUtil.getRealData(lxtsPoint).getPointValueInDouble()));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return v;
+            });
+        }
+        if (type.equals("-1")){
+            resultList.add(PointUtil.createPointData(currentDate,sspjfs.get()/fdcsize,zsspjfsPoint.getNemCode(),zsspjfsPoint.getName()));
+
+        }else if(type.equals("-2")){
+            resultList.add(PointUtil.createPointData(currentDate,sspjgzd.get()/gdcsize,zsspjgzdPoint.getNemCode(),zsspjgzdPoint.getName()));
+
+        }else {
+            resultList.add(PointUtil.createPointData(currentDate,sspjfs.get()/fdcsize,zsspjfsPoint.getNemCode(),zsspjfsPoint.getName()));
+            resultList.add(PointUtil.createPointData(currentDate,sspjgzd.get()/gdcsize,zsspjgzdPoint.getNemCode(),zsspjgzdPoint.getName()));
+        }
 
+        Double aqts = Collections.max(aqtsList);
+        resultList.add(PointUtil.createPointData(currentDate,aqts,zaqtsPoint.getNemCode(),zaqtsPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,zczzt,zczztPoint.getNemCode(),zczztPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,sszgl.get(),zsszglPoint.getNemCode(),zsszglPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,zllgl.get(),zsszllglPoint.getNemCode(),zsszllglPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,zbzgl.get(),zsszbzglPoint.getNemCode(),zsszbzglPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,znhglzs.get(),zssznhglzsPoint.getNemCode(),zssznhglzsPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,zzygl.get(),zsszzyglPoint.getNemCode(),zsszzyglPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,zkygl.get(),zsszkyglPoint.getNemCode(),zsszkyglPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,zycgl.get(),zycglPoint.getNemCode(),zycglPoint.getName()));
+
+        resultList.add(PointUtil.createPointData(currentDate,gztsmx.get(),zgztsmxPoint.getNemCode(),zgztsmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,cngzmx.get(),zcnslmxPoint.getNemCode(),zcnslmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,jxtsmx.get(),zjxtsmxPoint.getNemCode(),zjxtsmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,cnjxmx.get(),zcnjxmxPoint.getNemCode(),zcnjxmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,djtsmx.get(),zdjtsmxPoint.getNemCode(),zdjtsmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,qxjclmx.get(),zqxjclmxPoint.getNemCode(),zqxjclmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,sdtjmx.get(),zsdtjmxPoint.getNemCode(),zsdtjmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,xntsmx.get(),zxntsmxPoint.getNemCode(),zxntsmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,xdtjmx.get(),zxdtjmxPoint.getNemCode(),zxdtjmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,xdjclmx.get(),zxdjclmxPoint.getNemCode(),zxdjclmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,cwsldwmx.get(),zcwsldwmxPoint.getNemCode(),zcwsldwmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,cwsltqmx.get(),zcwsltqmxPoint.getNemCode(),zcwsltqmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,lxtsmx.get(),zlxtsmxPoint.getNemCode(),zlxtsmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,txzdmx.get(),ztxzdmxPoint.getNemCode(),ztxzdmxPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,djts.get(),zdjtsPoint.getNemCode(),zdjtsPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,yxts.get(),zyxtsPoint.getNemCode(),zyxtsPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,gzts.get(),zgztsPoint.getNemCode(),zgztsPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,whts.get(),zwhtsPoint.getNemCode(),zwhtsPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,xdts.get(),zxdtsPoint.getNemCode(),zxdtsPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,slts.get(),zsltsPoint.getNemCode(),zsltsPoint.getName()));
+        resultList.add(PointUtil.createPointData(currentDate,lxts.get(),zlxtsPoint.getNemCode(),zlxtsPoint.getName()));
+    }
 }

realtime/generationXK-service/src/main/java/com/gyee/generation/task/SaticScheduleCALTask.java

@@ -192,6 +192,7 @@ public class SaticScheduleCALTask {
         try {
             regionCalreService.companyCal();
             regionCalreService.RegionCal();
+            regionCalreService.groupCal();
         } catch (Exception e) {
             e.printStackTrace();
         }
@@ -210,6 +211,7 @@ public class SaticScheduleCALTask {
         try {
             regionCalService.companyCal();
             regionCalService.RegionCal();
+            regionCalService.groupCal();
         } catch (Exception e) {
             e.printStackTrace();
         }

web/runeconomy-xk/src/main/java/com/gyee/runeconomy/RunEconomyApplication.java

@@ -1,5 +1,6 @@
 package com.gyee.runeconomy;
 
+
 import com.gyee.runeconomy.config.GyeeConfig;
 import com.gyee.runeconomy.util.SpringUtils;
 import lombok.extern.log4j.Log4j2;

web/runeconomy-xk/src/main/java/com/gyee/runeconomy/controller/CommonController.java

@@ -134,6 +134,34 @@ public class CommonController {
     }
 
     /**
+     * 查询期次测点
+     *
+     * @return
+     */
+    @GetMapping("/findProPoints")
+    @ResponseBody
+    @ApiOperation(value = "查询场站测点", notes = "查询场站测点")
+    public R findProPoints(@RequestParam(value = "uniformcodes", required = true) String unifromcodes,
+                          @RequestParam(value = "wpid", required = true) String wpid) {
+
+        Map<String, Map<String, ProBasicPowerstationPoint>> propointmap = CacheContext.propointmap;
+        Map<String, ProBasicPowerstationPoint> powerstationPointMap = propointmap.get(wpid);
+
+        List<ProBasicPowerstationPoint> resultList = new ArrayList<>();
+
+        String[] split = unifromcodes.split(",");
+        Arrays.stream(split).forEach(s -> {
+            resultList.add(powerstationPointMap.get(s));
+        });
+
+        if (StringUtils.isNotNull(resultList)) {
+            return R.data(ResultMsg.ok(resultList));
+        } else {
+            return R.error(ResultMsg.error());
+        }
+    }
+
+    /**
      * 查询测点曲线
      *
      * @return

web/runeconomy-xk/src/main/java/com/gyee/runeconomy/service/monitor/MatrixService.java

@@ -7,7 +7,9 @@ package com.gyee.runeconomy.service.monitor;
 import com.gyee.common.contant.ContantXk;
 import com.gyee.common.model.PointData;
 import com.gyee.common.util.DoubleUtils;
+import com.gyee.common.vo.monitor.MatrixLineVo;
 import com.gyee.common.vo.monitor.MatrixPowerVo;
+import com.gyee.common.vo.monitor.MatrixProVo;
 import com.gyee.common.vo.monitor.MatrixVo;
 import com.gyee.runeconomy.init.CacheContext;
 import com.gyee.runeconomy.model.auto.*;
@@ -463,6 +465,8 @@ public class MatrixService {
         wpPoints.add(pointMap.get(ContantXk.ZYCGL).getNemCode());
 
         List<PointData> realData = edosUtil.getRealData(wpPoints);
+        resultMap.put("wpid",powerstation.getId());
+        resultMap.put("wpname",powerstation.getAname());
         resultMap.put("jrts",powerstation.getJrquantityJz()+powerstation.getJrquantityJz()+powerstation.getJrwindQuantityLd()+powerstation.getJrwindQuantityHs());
         resultMap.put("dfts",realData.get(0).getPointValueInDouble());
         resultMap.put("sdtjts",realData.get(1).getPointValueInDouble());
@@ -529,8 +533,11 @@ public class MatrixService {
         Map<String, List<ProBasicProject>> wppromap = CacheContext.wppromap;
         List<ProBasicProject> projects = wppromap.get(wpid);
         Map<String, Map<String, ProBasicPowerstationPoint>> propointmap = CacheContext.propointmap;
-        Map<String,Object> proMap = new HashMap<>();
+        Map<String,Map<String,Object>> wpdatamap = new HashMap<>();
+        List<MatrixProVo> proVos = new ArrayList<>();
         projects.stream().forEach(p->{
+            Map<String,Object> proMap = new HashMap<>();
+            MatrixProVo provo = new MatrixProVo();
             List<String> procodes = new ArrayList<>();
             Map<String, ProBasicPowerstationPoint> powerstationPointMap = propointmap.get(p.getId());
             procodes.add(powerstationPointMap.get(ContantXk.DJTS).getNemCode());
@@ -555,26 +562,30 @@ public class MatrixService {
                 e.printStackTrace();
             }
             if (StringUtils.isNotEmpty(prodatas)){
-                proMap.put("djts",prodatas.get(0).getPointValueInDouble());
-                proMap.put("bwts",prodatas.get(1).getPointValueInDouble());
-                proMap.put("gzts",prodatas.get(2).getPointValueInDouble());
-                proMap.put("jxts",prodatas.get(3).getPointValueInDouble());
-                proMap.put("xdts",prodatas.get(4).getPointValueInDouble());
-                proMap.put("slts",prodatas.get(5).getPointValueInDouble());
-                proMap.put("lxts",prodatas.get(6).getPointValueInDouble());
-                proMap.put("speed",prodatas.get(7).getPointValueInDouble());
-                proMap.put("bzgl",prodatas.get(8).getPointValueInDouble());
-                proMap.put("llgl",prodatas.get(9).getPointValueInDouble());
-                proMap.put("sjgl",prodatas.get(10).getPointValueInDouble());
+                provo.setDjts((int) prodatas.get(0).getPointValueInDouble());
+                provo.setBwts((int) prodatas.get(1).getPointValueInDouble());
+                provo.setGzts((int) prodatas.get(2).getPointValueInDouble());
+                provo.setJxts((int) prodatas.get(3).getPointValueInDouble());
+                provo.setXdts((int) prodatas.get(4).getPointValueInDouble());
+                provo.setSlts((int) prodatas.get(5).getPointValueInDouble());
+                provo.setLxts((int) prodatas.get(6).getPointValueInDouble());
+                provo.setSpeed(prodatas.get(7).getPointValueInDouble());
+                provo.setBzgl(prodatas.get(8).getPointValueInDouble());
+                provo.setLlgl(prodatas.get(9).getPointValueInDouble());
+                provo.setSjgl(prodatas.get(10).getPointValueInDouble());
+
             }
+
             //线路
             Map<String, List<ProBasicLine>> prolinemap = CacheContext.prolinemap;
             Map<String, List<ProBasicEquipment>> lnwtmap = CacheContext.lnwtmap;
             Map<String, Map<String, ProBasicEquipmentPoint>> wtpAimap = CacheContext.wtpAimap;
             Map<String, Double> modelpower = CacheContext.modelpower;
             List<ProBasicLine> lines = prolinemap.get(p.getId());
-            Map<String,Object> lineMap = new HashMap<>();
+            Map<String,Map<String,Object>> lineresultMap = new HashMap<>();
+            List<MatrixLineVo> lineVos = new ArrayList<>();
             lines.stream().forEach(line->{
+                MatrixLineVo linevo = new MatrixLineVo();
                 List<ProBasicEquipment> equipments = lnwtmap.get(line.getId());
                 List<String> wtPoints = new ArrayList<>();
                 equipments.stream().forEach(wt->{
@@ -620,13 +631,17 @@ public class MatrixService {
                         volist.add(vo);
                     }
                 }
-                lineMap.put("lineInfo",line.getAname());
-                lineMap.put("wtDatas",volist);
+                linevo.setId(line.getId());
+                linevo.setName(line.getAname());
+                linevo.setWtDataList(volist);
+                lineVos.add(linevo);
             });
-            proMap.put("lineData",lineMap);
-            proMap.put("proInfo",p.getAname());
+            provo.setLineVos(lineVos);
+            provo.setId(p.getId());
+            provo.setName(p.getName());
+            proVos.add(provo);
         });
-        resultMap.put("proDatas",proMap);
+        resultMap.put("wpDatas",proVos);
 
         return resultMap;
     }

web/runeconomy-xk/src/main/java/com/gyee/runeconomy/service/monitor/StationMonitorService.java

@@ -144,7 +144,7 @@ public class StationMonitorService {
         resultMap.put("nfdl",realData.get(23).getPointValueInDouble());
         resultMap.put("sspjfsgzd",realData.get(24).getPointValueInDouble());
         resultMap.put("yggl",realData.get(25).getPointValueInDouble());
-        resultMap.put("fhl",(proBasicPowerstation.getJrwindCapacity()+proBasicPowerstation.getJrCapacity())!=0?realData.get(25).getPointValueInDouble()/(proBasicPowerstation.getJrwindCapacity()+proBasicPowerstation.getJrCapacity()):0);
+        resultMap.put("fhl",(proBasicPowerstation.getJrwindCapacity()+proBasicPowerstation.getJrCapacity())!=0?realData.get(25).getPointValueInDouble()/(proBasicPowerstation.getJrwindCapacity()+proBasicPowerstation.getJrCapacity())*100:0);
         resultMap.put("ylyxs",realData.get(26).getPointValueInDouble());
         resultMap.put("nlyxs",realData.get(27).getPointValueInDouble());
         resultMap.put("yfgnlyl",realData.get(28).getPointValueInDouble());