修改区间曲线偏差1、2、3、4、5、6表写入事件

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

@@ -1,7 +1,5 @@
 package com.gyee.runeconomy;
 
-import com.gyee.runeconomy.service.initalcache.CacheService;
-import com.gyee.runeconomy.util.SpringUtils;
 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
@@ -14,8 +12,8 @@ public class RunEconomyApplication {
     public static void main(String[] args) {
         SpringApplication.run(RunEconomyApplication.class, args);
 
-        CacheService cacheService= SpringUtils.getBean("cacheService");
-        cacheService.initRedisCache();
+//        CacheService cacheService= SpringUtils.getBean("cacheService");
+//        cacheService.initRedisCache();
     }
 
 }

web/runeconomy-xk/src/main/java/com/gyee/runeconomy/init/CacheContext.java

@@ -0,0 +1,426 @@
+package com.gyee.runeconomy.init;
+
+
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.gyee.common.model.StringUtils;
+import com.gyee.runeconomy.service.realtimelibrary.TheoreticalPowerService;
+import com.gyee.runeconomy.util.redis.RedisService;
+import com.gyee.runeconomy.model.auto.*;
+import com.gyee.runeconomy.service.auto.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @ClassName : CacheContext
+ * @Author : xieshengjie
+ * @Date: 2021/5/18 9:35
+ * @Description : 缓存
+ */
+@Component
+public class CacheContext implements CommandLineRunner {
+    Logger logger = LoggerFactory.getLogger(CacheContext.class);
+
+    @Resource
+    private IProBasicEquipmentService proBasicEquipmentService;
+    @Resource
+    private IProBasicLineService proBasicLineService;
+    @Resource
+    private IProBasicProjectService proBasicProjectService;
+
+    @Resource
+    private IProBasicPowerstationService proBasicWindpowerstationService;
+    @Resource
+    private IProBasicMeterPointService proBasicMeterPointService;
+    @Resource
+    private IProEconEquipmentmodelService proEconEquipmentmodelService;
+
+    @Resource
+    private IProBasicWindturbinePowerService proBasicWindturbinePowerService;
+    @Resource
+    private RedisService redisService;
+    @Resource
+    private IProBasicModelPowerService proBasicModelPowerService;
+    @Resource
+    private IProBasicSubStationService proBasicSubStationService;
+    @Resource
+    private IProBasicSquareService proBasicSquareService;
+    @Resource
+    private IProBasicCompanyService proBasicCompanyService;
+    @Resource
+    private IProBasicRegionService proBasicRegionService;
+    @Resource
+    private TheoreticalPowerService theoreticalPowerService;
+
+    @Resource
+    private IProBasicModelPowerRdService proBasicModelPowerRdService;
+
+    @Value("${runWindpowerstation}")
+    private String runWindpowerstation;
+
+    public static List<ProBasicEquipment> wtls = new ArrayList<>();
+    public static List<ProBasicProject> pjls = new ArrayList<>();
+    public static List<ProBasicLine>  lnls = new ArrayList<>();
+    public static List<ProBasicSubStation>  subwpls = new ArrayList<>();
+
+    public static List<ProBasicSquare> sqls = new ArrayList<>();
+    public static List<ProBasicPowerstation>  wpls = new ArrayList<>();
+    public static List<ProBasicPowerstation>  zwpls = new ArrayList<>();
+    public static List<ProBasicCompany>  cpls = new ArrayList<>();
+    public static List<ProBasicRegion>  rgls = 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,ProBasicCompany> cpmap = new HashMap<>();
+
+    public static Map<String,List<ProBasicPowerstation>> cpwpmap = new HashMap<>();
+
+    public static Map<String,List<ProBasicCompany>> rgcpmap = new HashMap<>();
+    public static Map<String,ProBasicSquare> sqmap = new HashMap<>();
+    public static Map<String, ProBasicPowerstation> wpmap = new HashMap<>();
+    public static List<ProBasicMeterPoint>  meterpoints = new ArrayList<>();
+    public static Map<String,ProBasicMeterPoint>  meterpointMap = new HashMap<>();
+    public static Map<String,List<ProBasicProject>> wppromap = new HashMap<>();
+    public static Map<String,List<ProBasicLine>> prolinemap = new HashMap<>();
+    public static Map<String,List<ProBasicEquipment>> wpwtmap = new HashMap<>();
+    public static Map<String,List<ProBasicEquipment>> pjwtmap = new HashMap<>();
+    public static Map<String,List<ProBasicEquipment>> lnwtmap = new HashMap<>();
+
+
+    public static Map<String,List<ProBasicEquipment>> sqwtmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicEquipmentPoint>> wtpAimap = new HashMap<>();// 风电机测点AI表
+    public static Map<String,Map<String, ProBasicPowerstationPoint>> linepointmap =new HashMap<>();
+    public static Map<String,Map<String, ProBasicPowerstationPoint>> propointmap =new HashMap<>();
+    public static Map<String,Map<String, ProBasicPowerstationPoint>> wppointmap =new HashMap<>();
+    public static Map<String,Map<String, ProBasicPowerstationPoint>> subwppointmap =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<Double,Double>> zbzglMap = new HashMap<>();
+    public static Map<String,ProEconEquipmentmodel> modelMap = new HashMap<>();
+    public static Map<String,Map<Double,Double>> zzsglMap = new HashMap<>();
+    public static Map<String,Double> modelpower = new HashMap<>();
+
+    public static Map<String,String> wtstandardmap = new HashMap<>();
+    public static Map<String, ProBasicEquipment> wtmap = new HashMap<>();
+
+    public static Map<String,Map<Double,ProBasicModelPower>> modelpowermap = new TreeMap<>();
+
+    public static List<ProBasicModelPower> mpls=new ArrayList<>();
+
+    public static List<ProEconEquipmentmodel> equipmentmodels=new ArrayList<>();
+
+    public static Map<String,List<ProBasicEquipment>> subWtsMap = new HashMap<>();
+    public static List<ProBasicModelPowerRd> theoreticalPowerList=new ArrayList<>();
+    public static Map<String, Map<Double,ProBasicModelPowerRd>> theoreticalPowerMap = new HashMap<>(); //理论，保证功率
+    public static Map<String, Map<Double,ProEconWtPowerCurveFitting>> curveFittingPowerMap = new HashMap<>(); //自算，最优功率
+    public static Map<String,List<ProBasicStatusPoint>> statusMap = new HashMap<>();
+
+    @Override
+    public void run(String... args) throws Exception {
+        logger.info("缓存开始------------------------------------------------------------");
+
+
+        List<String> runWpids = Arrays.asList(runWindpowerstation.split(","));
+        logger.info(runWpids.get(0)+"------------------"+runWpids.size());
+
+        theoreticalPowerList= proBasicModelPowerRdService.list();
+        equipmentmodels = proEconEquipmentmodelService.list();
+        equipmentmodels.stream().forEach(e->{
+            modelMap.put(e.getId(),e);
+        });
+        mpls=proBasicModelPowerService.list();
+        mpls.sort(Comparator.comparing(ProBasicModelPower::getSpeed));
+        if(!mpls.isEmpty())
+        {
+
+            for(ProBasicModelPower mp:mpls)
+            {
+                if(modelpowermap.containsKey(mp.getModelId()))
+                {
+                    Map<Double,ProBasicModelPower> tempmap=modelpowermap.get(mp.getModelId());
+                    tempmap.put(mp.getSpeed(),mp);
+
+                }else {
+                    Map<Double,ProBasicModelPower> tempmap=new HashMap<>();
+                    tempmap.put(mp.getSpeed(),mp);
+                    modelpowermap.put(mp.getModelId(),tempmap);
+                }
+            }
+        }
+        sqls=proBasicSquareService.list().stream().filter(i->runWpids.contains(i.getWindpowerstationId()) && i.getIsAble()==1).collect(Collectors.toList());
+        if (!sqls.isEmpty())
+        {
+            for(ProBasicSquare sq:sqls)
+            {
+                sqmap.put(sq.getId(),sq);
+            }
+        }
+
+        cpls=proBasicCompanyService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+        if (!cpls.isEmpty())
+        {
+            for(ProBasicCompany sq:cpls)
+            {
+                cpmap.put(sq.getId(),sq);
+
+                if (redisService.hasKey(sq.getId()+"0")){
+                    String cp0String = redisService.get(sq.getId()+"0");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    companypointmap.put(sq.getId()+"0",stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId()+"-1")){
+                    String cp1String = redisService.get(sq.getId()+"-1");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    companypointmap.put(sq.getId()+"-1",stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId()+"-2")){
+                    String cp2String = redisService.get(sq.getId()+"-2");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    companypointmap.put(sq.getId()+"-2",stringWindpowerstationpointnewMap);
+                }
+
+
+
+
+            }
+
+        }
+
+
+        rgls=proBasicRegionService.list().stream().filter(i->i.getIsAble()==1).collect(Collectors.toList());
+        if  (!rgls.isEmpty())
+        {
+            for(ProBasicRegion sq:rgls)
+            {
+                rgmap.put(sq.getId(),sq);
+
+                if (redisService.hasKey(sq.getId()+"0")){
+                    String cp0String = redisService.get(sq.getId()+"0");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    regionpointmap.put(sq.getId()+"0",stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId()+"-1")){
+                    String cp1String = redisService.get(sq.getId()+"-1");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    regionpointmap.put(sq.getId()+"-1",stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId()+"-2")){
+                    String cp2String = redisService.get(sq.getId()+"-2");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    regionpointmap.put(sq.getId()+"-2",stringWindpowerstationpointnewMap);
+                }
+            }
+        }
+
+
+        for(ProBasicCompany cp:cpls)
+        {
+            if (rgcpmap.containsKey(cp.getRegionId())){
+                rgcpmap.get(cp.getRegionId()).add(cp);
+            }else {
+                List<ProBasicCompany> wps = new ArrayList<>();
+                wps.add(cp);
+                rgcpmap.put(cp.getRegionId(),wps);
+            }
+        }
+
+        for(ProBasicPowerstation wp:wpls)
+        {
+            if (cpwpmap.containsKey(wp.getCompanyId())){
+                cpwpmap.get(wp.getCompanyId()).add(wp);
+            }else {
+                List<ProBasicPowerstation> wps = new ArrayList<>();
+                wps.add(wp);
+                cpwpmap.put(wp.getCompanyId(),wps);
+            }
+        }
+
+
+        wtls = proBasicEquipmentService.list().stream().filter(i->runWpids.contains(i.getWindpowerstationId()) && i.getIsable()==1).collect(Collectors.toList());
+        logger.info(wtls.size()+"");
+        wtls.forEach(wt->{
+            if(modelMap.containsKey(wt.getModelId()))
+            {
+                ProEconEquipmentmodel equipmentmodel = modelMap.get(wt.getModelId());
+                modelpower.put(wt.getId(),equipmentmodel.getPowerProduction().doubleValue());
+            }
+
+
+            wtmap.put(wt.getId(),wt);
+            //标杆风机初始化
+            wtstandardmap.put(wt.getId(),wt.getId());
+            String wtString = redisService.get(wt.getId());
+            Map<String, ProBasicEquipmentPoint> stringWindturbinetestingpointnewMap = JSONObject.parseObject(wtString, new TypeReference<Map<String, ProBasicEquipmentPoint>>() {
+            });
+            wtpAimap.put(wt.getId(),stringWindturbinetestingpointnewMap);
+
+
+            if (wpwtmap.containsKey(wt.getWindpowerstationId())){
+                wpwtmap.get(wt.getWindpowerstationId()).add(wt);
+            }else {
+                List<ProBasicEquipment> wps = new ArrayList<>();
+                wps.add(wt);
+                wpwtmap.put(wt.getWindpowerstationId(),wps);
+            }
+
+            if (pjwtmap.containsKey(wt.getProjectId())){
+                pjwtmap.get(wt.getProjectId()).add(wt);
+            }else {
+                List<ProBasicEquipment> pjs = new ArrayList<>();
+                pjs.add(wt);
+                pjwtmap.put(wt.getProjectId(),pjs);
+            }
+            if (lnwtmap.containsKey(wt.getLineId())){
+                lnwtmap.get(wt.getLineId()).add(wt);
+            }else {
+                List<ProBasicEquipment> lnls = new ArrayList<>();
+                lnls.add(wt);
+                lnwtmap.put(wt.getLineId(),lnls);
+            }
+
+            if (sqwtmap.containsKey(wt.getSquareId())){
+                sqwtmap.get(wt.getSquareId()).add(wt);
+            }else {
+                List<ProBasicEquipment> lnls = new ArrayList<>();
+                lnls.add(wt);
+                sqwtmap.put(wt.getSquareId(),lnls);
+            }
+        });
+
+        //初始化标杆风机
+        for(ProBasicEquipment wt:wtls)
+        {
+            if(wpwtmap.containsKey(wt.getLineId()))
+            {
+                List<ProBasicEquipment> wts=wpwtmap.get(wt.getLineId());
+                for(ProBasicEquipment w:wts)
+                {
+                    if(StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard()!=0)
+                    {
+                        wtstandardmap.put(wt.getId(),w.getId());
+                        break;
+                    }
+                }
+            }
+            if(pjwtmap.containsKey(wt.getLineId()))
+            {
+                List<ProBasicEquipment> wts=pjwtmap.get(wt.getLineId());
+                for(ProBasicEquipment w:wts)
+                {
+                    if(StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard()!=0)
+                    {
+                        wtstandardmap.put(wt.getId(),w.getId());
+                        break;
+                    }
+                }
+            }
+            if(lnwtmap.containsKey(wt.getLineId()))
+            {
+                List<ProBasicEquipment> wts=lnwtmap.get(wt.getLineId());
+                for(ProBasicEquipment w:wts)
+                {
+                    if(StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard()!=0)
+                    {
+                        wtstandardmap.put(wt.getId(),w.getId());
+                        break;
+                    }
+                }
+            }
+        }
+
+
+
+        pjls = proBasicProjectService.list().stream().filter(i->runWpids.contains(i.getWindpowerstationId()) && i.getIsAble()==1).collect(Collectors.toList());
+        pjls.stream().forEach(p->{
+            pjmap.put(p.getId(),p);
+            if (wppromap.containsKey(p.getWindpowerstationId())){
+                wppromap.get(p.getWindpowerstationId()).add(p);
+            }else {
+                List<ProBasicProject> prolist = new ArrayList<>();
+                prolist.add(p);
+                wppromap.put(p.getWindpowerstationId(),prolist);
+            }
+            String pjString = redisService.get(p.getId());
+            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(pjString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            propointmap.put(p.getId(),stringWindpowerstationpointnewMap);
+
+        });
+
+        subwpls = proBasicSubStationService.list().stream().filter(i->runWpids.contains(i.getWindpowerstationId()) && i.getIsAble()==1).collect(Collectors.toList());
+        subwpls.stream().forEach(sub->{
+
+            String subString = redisService.get(sub.getId());
+            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(subString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            subwppointmap.put(sub.getId(),stringWindpowerstationpointnewMap);
+
+//            List<ProBasicEquipment> collect = wtls.stream().filter(wt -> wt.getSubstationId().equals(sub.getId())).collect(Collectors.toList());
+//            subWtsMap.put(sub.getId(),collect);
+
+        });
+
+
+        lnls = proBasicLineService.list().stream().filter(i-> StringUtils.isNotNull(pjmap.get(i.getProjectId())) && runWpids.contains(pjmap.get(i.getProjectId()).getWindpowerstationId()) && i.getIsAble()==1).collect(Collectors.toList());
+        lnls.stream().forEach(l->{
+            lnmap.put(l.getId(),l);
+            if (prolinemap.containsKey(l.getProjectId())){
+                prolinemap.get(l.getProjectId()).add(l);
+            }else {
+                List<ProBasicLine> lineList = new ArrayList<>();
+                lineList.add(l);
+                prolinemap.put(l.getProjectId(),lineList);
+            }
+            String lnString = redisService.get(l.getId());
+            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(lnString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            linepointmap.put(l.getId(),stringWindpowerstationpointnewMap);
+        });
+
+
+        zwpls = proBasicWindpowerstationService.list().stream().filter(i->i.getIsAble()==1).collect(Collectors.toList());;
+        wpls = proBasicWindpowerstationService.list().stream().filter(i->runWpids.contains(i.getId()) && i.getIsAble()==1).collect(Collectors.toList());;
+        meterpoints = proBasicMeterPointService.list().stream().filter(i->runWpids.contains(i.getWindpowerstationId()) && i.getIsAble()==1).collect(Collectors.toList());
+        meterpoints.stream().forEach(meterpoint -> {
+            meterpointMap.put(meterpoint.getId(),meterpoint);
+        });
+
+
+        wpls.stream().forEach(wp->{
+
+            wpmap.put(wp.getId(),wp);
+            String wpString = redisService.get(wp.getId());
+            Map<String, ProBasicPowerstationPoint> stringMapMap = JSONObject.parseObject(wpString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            wppointmap.put(wp.getId(),stringMapMap);
+        });
+
+
+        String llglString = redisService.get("ZLLGL");
+        theoreticalPowerMap = JSONObject.parseObject(llglString, new TypeReference<Map<String, Map<Double,ProBasicModelPowerRd>>>() {
+        });
+
+        String sszzt = redisService.get("SSZZT");
+        statusMap = JSONObject.parseObject(sszzt, new TypeReference<Map<String,List<ProBasicStatusPoint>>>() {
+        });
+
+
+
+        logger.info("缓存结束------------------------------------------------------------");
+    }
+}

web/runeconomy-xk/src/main/java/com/gyee/runeconomy/service/realtimelibrary/TheoreticalPowerService.java

@@ -0,0 +1,51 @@
+package com.gyee.runeconomy.service.realtimelibrary;/*
+@author   谢生杰
+@date   2022/11/6-12:07
+*/
+
+import com.gyee.runeconomy.init.CacheContext;
+import com.gyee.runeconomy.model.auto.ProEconWtPowerCurveFitting;
+import com.gyee.runeconomy.service.auto.IProBasicModelPowerRdService;
+import com.gyee.runeconomy.service.auto.IProEconWtPowerCurveFittingService;
+import com.gyee.runeconomy.util.realtimesource.IEdosUtil;
+import com.gyee.runeconomy.util.redis.RedisService;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class TheoreticalPowerService {
+
+    @Resource
+    private RedisService redisService;
+    @Resource
+    private IProBasicModelPowerRdService proBasicModelPowerRdService;
+    @Resource
+    private IProEconWtPowerCurveFittingService proEconWtPowerCurveFittingService;
+    @Resource
+    private IEdosUtil edosUtil;
+    /**
+     * 缓存自算功率，最优功率
+     * 1个月
+     */
+    public void updateCachePower(){
+        Map<String, Map<Double,ProEconWtPowerCurveFitting>> resultMap = new HashMap<>();
+
+        List<ProEconWtPowerCurveFitting> econWtPowerCurveFittings = proEconWtPowerCurveFittingService.list();
+        econWtPowerCurveFittings.stream().forEach(curveFitting->{
+            if (resultMap.containsKey(curveFitting.getWindturbineId())){
+                resultMap.get(curveFitting.getWindturbineId()).put(curveFitting.getSpeed(),curveFitting);
+            }else {
+                Map<Double,ProEconWtPowerCurveFitting> powerMap = new HashMap<>();
+                powerMap.put(curveFitting.getSpeed(),curveFitting);
+                resultMap.put(curveFitting.getWindturbineId(),powerMap);
+            }
+        });
+        CacheContext.curveFittingPowerMap = resultMap;
+    }
+
+
+}

web/runeconomy-xk/src/main/resources/application-test.yml

@@ -105,6 +105,9 @@ logging:
     root: info
     com.example: debug
 initialcode: INITIAL
-
+db:
+  #url: http://127.0.0.1:8011/ts
+  url: http://192.168.11.250:8011/ts
+runWindpowerstation: SD_GDDL_RZLX_FDC_STA