2024-03-19 13:16:00 锅炉供热模型接口开发

dntd-common/src/main/java/com/dky/utils/GetTargetDeviceList.java

@@ -0,0 +1,21 @@
+package com.dky.utils;
+
+
+import com.dky.utils.entity.SysDeviceHeatScene;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GetTargetDeviceList {
+
+    public static List<SysDeviceHeatScene> main(String args, List<SysDeviceHeatScene> alternateDeviceList) {
+        List<SysDeviceHeatScene> ary = new ArrayList<>();
+
+        alternateDeviceList.forEach((device) -> {
+            if (device.getDevSubType().equals(args)) {
+                ary.add(device);
+            }
+        });
+        return ary;
+    }
+}

dntd-common/src/main/java/com/dky/utils/entity/SysDeviceHeatScene.java

@@ -13,6 +13,10 @@ public class SysDeviceHeatScene {
     private Double heatEfficiency;
     //设备功率
     private Double devPower;
+    /** 最少推荐使用人数 */
+    private Integer recomMinPeopleNum ;
+    /** 最多推荐使用人数 */
+    private Integer recomMaxPeopleNum ;
     //设备单价
     private Double devPrice;
     // 电替代设备年人工费用
@@ -28,6 +32,22 @@ public class SysDeviceHeatScene {
     //备注
     private String remark;
 
+    public Integer getRecomMinPeopleNum() {
+        return recomMinPeopleNum;
+    }
+
+    public void setRecomMinPeopleNum(Integer recomMinPeopleNum) {
+        this.recomMinPeopleNum = recomMinPeopleNum;
+    }
+
+    public Integer getRecomMaxPeopleNum() {
+        return recomMaxPeopleNum;
+    }
+
+    public void setRecomMaxPeopleNum(Integer recomMaxPeopleNum) {
+        this.recomMaxPeopleNum = recomMaxPeopleNum;
+    }
+
     public SysDeviceHeatScene(Integer id, String devType, String devSubType, String devTechType, Double heatEfficiency, Double devPower, Double devPrice, Double devSubstituteLaborCost, Double laborCost, Double devReferenceArea, Integer devServiceLife, Integer devAnnualOperationTime, String remark) {
         this.id = String.valueOf(id);
         this.devType = devType;
@@ -66,6 +86,7 @@ public class SysDeviceHeatScene {
                 "，原设备的人工费用：" + laborCost +
                 "，单台设备可参考供暖面积 = " + devReferenceArea +
                 "，设备使用年限 = " + devServiceLife +
+                "，设备年运行时长 = " + devAnnualOperationTime +
                 '}';
     }
 

dntd-common/src/main/java/com/dky/utils/enums/Code.java

@@ -7,7 +7,8 @@ public enum Code {
     SUCCESS(1001, "成功"),
     KEY_EXPIRATION(1002, "密钥已过期"),
     KEY_UNAUTHORIZED(1003, "密钥未在本机授权"),
-    KEY_CONTEXT_ERROR(1004, "密钥错误");
+    KEY_CONTEXT_ERROR(1004, "密钥错误"),
+    KEY_PRIVATE_ERROR(1005, "私钥异常");
 
 
     /**

dntd-common/src/main/java/com/dky/utils/enums/DeviceSubType.java

@@ -0,0 +1,33 @@
+package com.dky.utils.enums;
+
+
+public enum DeviceSubType {
+
+    Boiler_Heating(0101, "工业供热电锅炉"),
+    Cooling_Heating(0201, "供冷/暖"),
+    Cooling_Heating_Electric_Boiler(0202, "供冷/暖电锅炉");
+
+
+    /**
+     * 编码
+     */
+    private final Integer code;
+    /**
+     * 中文描述
+     */
+    private final String desc;
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+    DeviceSubType(Integer code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+}

dntd-model-buildheating/src/main/java/com/dky/calculate/BuildHeatingModel.java

@@ -24,7 +24,7 @@ public class BuildHeatingModel {
     }
 
     /**
-     * 年运行费用（万元）
+     * 年运行费用（元）
      * @param deviceNum 电锅炉设备台数
      * @param devicePower 单台电锅炉的功率
      * @param days 年采暖（供冷）时间(天)
@@ -35,11 +35,11 @@ public class BuildHeatingModel {
                              Double devicePower,
                              Integer days,
                              Double laborCost){
-        return (deviceNum * devicePower * days * 24 * 0.5) + (laborCost );
+        return (deviceNum * devicePower * days * 24 * 0.5) + (laborCost * deviceNum);
     }
 
     /**
-     * 年总费用（万元）
+     * 年总费用（元）
      * @param deviceNum 电锅炉设备台数
      * @param devicePrice 单台电设备价格 非表中参数
      * @param useYears 使用年限 非表中参数
@@ -54,7 +54,7 @@ public class BuildHeatingModel {
                               Double devicePower,
                               Integer days,
                               Double laborCost){
-        double run = (deviceNum * devicePower * days * 24 * 0.5) + (laborCost );
+        double run = (deviceNum * devicePower * days * 24 * 0.5) + (laborCost * deviceNum);
         return ((deviceNum * devicePrice) / useYears) + run;
     }
 

dntd-model-buildheating/src/main/java/com/dky/calculate/Scheme.java

@@ -16,7 +16,6 @@ public class Scheme {
      *
      * @param buildArea              建筑面积
      * @param sysDeviceHeatSceneList 替代设备列表
-     * @return
      */
     public static List<List<MatchedDevice>> calScheme(Double buildArea, List<SysDeviceHeatScene> sysDeviceHeatSceneList) {
         // 根据设备细类筛选出一个以设备细类为键，该细类下设备列表为值的Map

dntd-model-buildheating/src/main/java/com/dky/calculate/SchemeRating.java

@@ -35,6 +35,13 @@ public class SchemeRating {
 
             // 3、（1-（选择对应设备细类的效率最大的效率值（效率最大值）-当前设备的效率值值）/效率最大值）*100*系数  +（1-（当前成本值-对应设备细类的成本最小值）/对应设备细类的成本最小值）*100*0.2。取最高得分。
             rating.set(((1 - v1) * 100 * effRatio) + ((1 - v) * 100 * costRatio));
+
+            System.out.println("当前方案成本 = " + cost + "，方案详情 = ");
+            for (MatchedDevice matchedDevice : plan){
+                System.out.println(matchedDevice);
+            }
+            System.out.println("当前方案评分: " + rating.get() + "\n");
+
             // 方案评分结果
             SchemeRatingRes schemeRatingRes = new SchemeRatingRes(plan, rating.get(), devTechType);
             optimalMap.put(devTechType, schemeRatingRes);
@@ -67,7 +74,7 @@ public class SchemeRating {
      * @param alternateDeviceList  可替代设备列表
      * @return 不同设备细类下的效率最大值map
      */
-    public static Map<String,Double> getMaxEfficiencyGroupByDevSubType( List<SysDeviceHeatScene> alternateDeviceList){
+    public static Map<String,Double> getMaxEfficiencyGroupByDevSubType(List<SysDeviceHeatScene> alternateDeviceList){
         Map<String,Double> map = new HashMap<>();
         alternateDeviceList.forEach(alternateDevice ->{
             String devSubType = alternateDevice.getDevSubType();

dntd-model-heatboiler/pom.xml

@@ -34,6 +34,12 @@
             <artifactId>dntd-common</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
+        <dependency>
+            <groupId>com.dky</groupId>
+            <artifactId>dntd-common</artifactId>
+            <version>1.1-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
 

dntd-model-heatboiler/src/main/java/com/dky/calculate/Advantage.java

@@ -1,15 +1,30 @@
 package com.dky.calculate;
+
+import java.text.DecimalFormat;
+
 //方案优势
 public class Advantage {
-//安全性
+
+    static DecimalFormat decimalFormat = new DecimalFormat("#.00");
+
+    //安全性
     public String safety(){
         return "无";
     }
-    //经济性
+
-    public static String economy(Double firstInvestFee,Double yearTotalFee,Double yearRunFee,Double lastYearFee){
+    /**
-        Double hsq = Math.round(firstInvestFee/yearTotalFee*100.0)/100.0;
+     * 经济性
-        double js = Math.round((lastYearFee - yearRunFee)*100.0)/100.0;
+     * @param firstInvestFee 初始投资金额
-        return "本次改造投资回收期为"+hsq+"年，本改造方案相比较原技术节省年运行费用成本"+js+"元。";
+     * @param yearRunFee 年运行费用
+     * @param lastYearFee 替代前上年运行费用
+     * @return
+     */
+    public static String economy(Double firstInvestFee ,Double yearRunFee, Double lastYearFee){
+        // 运行收益 = 年运行费用-上年运行费用（即原设备运行费用）
+        Double hsq = Math.round((yearRunFee - lastYearFee) * 100.0)/100.0;
+        // 投资回收期 = 初次投资费用/运行收益
+        Double js = Math.round((firstInvestFee / hsq) * 100.0)/100.0;
+        return "本次改造投资回收期为"+js+"年，本改造方案相比较原技术节省年运行费用成本"+decimalFormat.format(hsq)+"元。";
     }
     // 智能性
     public static String intelligence() {

dntd-model-heatboiler/src/main/java/com/dky/calculate/HeatBoilerModel.java

@@ -6,6 +6,12 @@ import com.dky.entity.OriginalDevice;
 
 public class HeatBoilerModel {
 
+    // 标准煤转换系数：千克标准煤/千克
+    private static final double coalConversionFactor = 0.7143;
+    // 电能转换到标准煤的系数：千克标准煤/千瓦时
+    private static final double electricityConversionFactor = 0.1229;
+    // 标准煤转换到二氧化碳的系数：千克二氧化碳/千克标准煤
+    private static final double carbonConversionFactor = 1.9003;
 
     /**
      * 计算初次投资费用
@@ -28,67 +34,68 @@ public class HeatBoilerModel {
 
     /**
      * 计算年运行费用
-     * @param heatboilerSpec 非表中参数
+     * @param devicePower 电替代设备功率
-     * @param heatboiler 基础入参
+     * @param deviceCount 电替代设备台数
-     * @param originalDevice 原设备参数
+     * @param deviceSubstituteLaborCost 电替代设备人工费用
-     * @param count 电替代设备台数 TODO
+     * @param deviceAnnualOperationTime 电替代设备年运行时间
      * @return 年运行费用
      */
-    public static double calculateAnnualOperatingCost(HeatboilerSpec heatboilerSpec, Heatboiler heatboiler , OriginalDevice originalDevice ,Integer count) {
+    public static double calculateAnnualOperatingCost(Double devicePower, Integer deviceCount, Double deviceSubstituteLaborCost, Integer deviceAnnualOperationTime) {
 
         // 电替代设备年耗电量=单台电替代设备的功率<A>*电替代设备台数*电设备年运行时间<B>
-        double annualElectricityConsumption = heatboilerSpec.getSubstitutePower() * count * heatboilerSpec.getAnnualOperationTime();
+        double annualElectricityConsumption = devicePower * deviceCount * deviceAnnualOperationTime;
-        // 年运行费用=电替代设备年耗电量*平均电价(0.5元/千瓦时)+电替代设备人工费用成本<A>
+        // 年运行费用=电替代设备年耗电量*平均电价(0.5元/千瓦时) + 单台电替代设备人工费用成本<A> * 台数
-        return annualElectricityConsumption * 0.5 + heatboilerSpec.getSubstituteLaborCost();
+        return annualElectricityConsumption * 0.5 + deviceSubstituteLaborCost * deviceCount;
 
     }
 
     /**
      * 计算年总费用
-     * @param heatboilerSpec 非表中参数
+     * @param devicePower 电替代设备功率
-     * @param heatboiler 基础入参
+     * @param deviceCount 电替代设备台数
-     * @param originalDevice 原设备参数
+     * @param deviceSubstituteLaborCost 电替代设备人工费用
-     * @param count 电替代设备台数 TODO
+     * @param deviceAnnualOperationTime 电替代设备年运行时间
-     * @return 年总费用
+     * @param devicePrice 设备价格
+     * @param deviceServiceLife 设备使用年限
+     * @return
      */
-    public static double calculateAnnualTotalCost(HeatboilerSpec heatboilerSpec, Heatboiler heatboiler , OriginalDevice originalDevice ,Integer count) {
+    public static double calculateAnnualTotalCost(Double devicePower, Integer deviceCount, Double deviceSubstituteLaborCost, Integer deviceAnnualOperationTime, Double devicePrice, Integer deviceServiceLife) {
-        //（电替代设备台数*单台电设备价格<A>）/电替代设备的使用年限<A>+年运行费用
+        //（电替代设备台数*单台电设备价格<A>）/电替代设备的使用年限<A>
-        return (count * 1) / heatboilerSpec.getServiceLife() + calculateAnnualOperatingCost( heatboilerSpec,  heatboiler ,  originalDevice,count);
+        double v = ((devicePrice * deviceCount) / deviceServiceLife);
+        // 年总费用=（电替代设备台数*单台电设备价格<A>）/电替代设备的使用年限<A> + 年运行费用
+        return v + calculateAnnualOperatingCost(devicePower, deviceCount, deviceSubstituteLaborCost, deviceAnnualOperationTime);
     }
 
     /**
      * 计算年减碳量
-     * @param heatboilerSpec 非表中参数
+     * @param previousYearEnergyUsage 替代前年能源用量
-     * @param heatboiler 基础入参
+     * @param deviceElectric 电替代耗电量
-     * @param originalDevice 原设备参数
      * @return 年减碳量
      */
-    public static double calculateAnnualCarbonReduction(HeatboilerSpec heatboilerSpec, Heatboiler heatboiler , OriginalDevice originalDevice) {
+    public static double calculateAnnualCarbonReduction(Double previousYearEnergyUsage, Double deviceElectric) {
 
-        //年减碳量=(替代前年能源用量*0.7143千克标准煤/千克-电替代设备年耗电量*0.1229千克标准煤/千瓦时)*1.9003千克二氧化碳/千克
+        // 计算替代前年能源用量对应的标准煤量
-        final double standardCoalCoefficient = 0.7143; // 千克标准煤/千克
+        double coalEquivalentFromEnergy = previousYearEnergyUsage * coalConversionFactor;
-        final double electricityConsumptionCoefficient = 0.1229; // 千克标准煤/千瓦时
+        // 计算电替代设备年耗电量对应的标准煤量
-        final double carbonDioxideCoefficient = 1.9003; // 千克二氧化碳/千克
+        double coalEquivalentFromElectricity = deviceElectric * electricityConversionFactor;
 
-        //单台电替代设备年耗电量 = 电替代设备年运行时间 * 电替代设备功率
+        // 计算净减少的标准煤量
-        double electricSubstitutionEquipmentYearlyElectricityConsumption = heatboilerSpec.getAnnualOperationTime() * heatboilerSpec.getSubstitutePower();
+        double netReductionInCoalEquivalent = coalEquivalentFromEnergy - coalEquivalentFromElectricity;
 
-        return (originalDevice.getSubstituteBeforeEnergyConsumption() * standardCoalCoefficient
+        // 计算年减碳量
-                - electricSubstitutionEquipmentYearlyElectricityConsumption * electricityConsumptionCoefficient)
+        return netReductionInCoalEquivalent * carbonConversionFactor;
-                * carbonDioxideCoefficient;
     }
 
     /**
-     * 计算替代电量
+     * 计算电替代设备年耗电量
-     * @param heatboilerSpec 非表中参数
+     * @param devicePower 设备功率
-     * @param heatboiler 基础入参
+     * @param deviceCount 设备台数
-     * @param originalDevice 原设备参数
+     * @param deviceAnnualOperationTime 单台电设备年运行时间
-     * @param count 电替代设备台数 TODO
+     * @return
-     * @return 替代电量
      */
-    public static double calculateSubstituteElectricity(HeatboilerSpec heatboilerSpec, Heatboiler heatboiler , OriginalDevice originalDevice,Integer count) {
+    public static double calculateSubstituteElectricity(Double devicePower, Integer deviceCount, Integer deviceAnnualOperationTime) {
-        // 电替代设备年耗电量=电替代设备的功率<A>*电替代设备台数*电设备年运行时间<B>
+        // 电替代设备年耗电量 = 电替代设备的功率<A> * 电替代设备台数 * 电设备年运行时间<B>
-        return heatboilerSpec.getSubstitutePower() * count * heatboilerSpec.getAnnualOperationTime();
+        return devicePower * deviceCount * deviceAnnualOperationTime;
 
     }
 

dntd-model-heatboiler/src/main/java/com/dky/calculate/HeatBoilerScheme.java

@@ -0,0 +1,59 @@
+package com.dky.calculate;
+
+
+import com.dky.utils.entity.SysDeviceHeatScene;
+import com.dky.utils.result.MatchedDevice;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class HeatBoilerScheme {
+
+    public static List<List<MatchedDevice>> calScheme(Double heatEfficiency, List<SysDeviceHeatScene> sysDeviceHeatSceneList) {
+        // 根据设备细类筛选出一个以设备细类为键，该细类下设备列表为值的Map
+        Map<String, List<SysDeviceHeatScene>> groupByDevSubTypeMap = sysDeviceHeatSceneList.stream()
+                .collect(Collectors.groupingBy(SysDeviceHeatScene::getDevSubType));
+
+        // 区分技术类型
+        List<List<MatchedDevice>> planList = new ArrayList<>();
+        groupByDevSubTypeMap.forEach((devSubType, v) -> {
+
+            // 该细类下的设备根据技术类型筛选出一个以技术类型为键，该技术类型下设备列表为值的Map
+            Map<String, List<SysDeviceHeatScene>> groupByDevTechTypeMap = v.stream().collect(Collectors.groupingBy(SysDeviceHeatScene::getDevTechType));
+
+            groupByDevTechTypeMap.forEach((devTechType, devList) -> {
+                List<MatchedDevice> matchedDevices = calSchemeByTechType(heatEfficiency, devList);
+                planList.add(matchedDevices);
+            });
+
+        });
+        return planList;
+    }
+
+    public static List<MatchedDevice> calSchemeByTechType(Double heatEfficiency, List<SysDeviceHeatScene> sysDeviceHeatSceneList) {
+        // 对技术类型下的设备list按照单台设备功率进行排序
+        sysDeviceHeatSceneList.sort((o1, o2) -> Double.compare(o2.getDevPower(), o1.getDevPower()));
+        Double remainArea = heatEfficiency;
+        // 遍历设备，根据建筑面积进行匹配设备数量
+        List<MatchedDevice> matchedDeviceList = new ArrayList<>();
+        for (SysDeviceHeatScene deviceHeatScene : sysDeviceHeatSceneList) {
+            double v = remainArea / deviceHeatScene.getDevPower();
+            int count = (int) (v);
+            if (v < 1) {
+                count = count + 1;
+            }
+            remainArea = remainArea - count * deviceHeatScene.getDevPower();
+            matchedDeviceList.add(new MatchedDevice(count, deviceHeatScene));
+            if (remainArea <= 0) {
+                // 当总供暖面积已经满足需求时，跳出循环，不再选择其他设备
+                break;
+            }
+        }
+        return matchedDeviceList;
+    }
+
+
+
+}

dntd-tool/pom.xml

@@ -49,6 +49,18 @@
             <version>1.0-SNAPSHOT</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>com.dky</groupId>
+            <artifactId>dntd-common</artifactId>
+            <version>1.1-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.dky</groupId>
+            <artifactId>dntd-model-heatboiler</artifactId>
+            <version>1.1-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
     <build>
         <resources>

dntd-tool/src/main/java/com/dky/generate/BuildHeatingScene.java

@@ -4,7 +4,9 @@ package com.dky.generate;
 import cn.hutool.json.JSONObject;
 import com.dky.calculate.*;
 import com.dky.modelI.DntdModelI;
+import com.dky.utils.GetTargetDeviceList;
 import com.dky.utils.entity.SysDeviceHeatScene;
+import com.dky.utils.enums.DeviceSubType;
 import com.dky.utils.result.MatchedDevice;
 
 import java.text.DecimalFormat;
@@ -22,7 +24,10 @@ public class BuildHeatingScene implements DntdModelI {
     static final Double COEFFICIENT_2 = 0.85;
 
     @Override
-    public JSONObject createReport(JSONObject jsonObject,List<SysDeviceHeatScene> alternateDeviceList) {
+    public JSONObject createReport(JSONObject jsonObject,List<SysDeviceHeatScene> sceneList) {
+        List<SysDeviceHeatScene> list = GetTargetDeviceList.main(DeviceSubType.Cooling_Heating.getDesc(), sceneList);
+        List<SysDeviceHeatScene> alternateDeviceList = GetTargetDeviceList.main(DeviceSubType.Cooling_Heating_Electric_Boiler.getDesc(), list);
+        System.out.println("建筑供暖场景: " + alternateDeviceList + "\n");
 
         JSONObject distInfo = new JSONObject();
         JSONObject buildInfo = new JSONObject();
@@ -118,7 +123,8 @@ public class BuildHeatingScene implements DntdModelI {
             List<List<MatchedDevice>> heatPumpDevList = new ArrayList<>();
             matchedDeviceGroupList.forEach((matchedDevices -> {
                 MatchedDevice matchedDevice = matchedDevices.get(0);
-                if (!"供冷/暖电锅炉".equals(matchedDevice.getDeviceHeatScene().getDevSubType())){
+                String s = DeviceSubType.Cooling_Heating_Electric_Boiler.getDesc();
+                if (!s.equals(matchedDevice.getDeviceHeatScene().getDevSubType())){
                     heatPumpDevList.add(matchedDevices);
                 }
             }));
@@ -187,9 +193,9 @@ public class BuildHeatingScene implements DntdModelI {
 
         //封装方案优势
         returnJsonObject.set("safety", BuildHeatingAdvantage.safety());
-        returnJsonObject.set("economy", BuildHeatingAdvantage.economy(startCost, allCost, runCost, lastYearFee));
+        returnJsonObject.set("economy", Advantage.economy(startCost, runCost, lastYearFee));
         returnJsonObject.set("intelligence", BuildHeatingAdvantage.intelligence());
-        returnJsonObject.set("environment", BuildHeatingAdvantage.environment(Double.valueOf(decimalFormat.format(calculateAnnualCarbon))));
+        returnJsonObject.set("environment", BuildHeatingAdvantage.environment(Double.valueOf(decimalFormat.format(calculateAnnualCarbon/1000))));
 
         //封装方案评分
         returnJsonObject.set("matchedDeviceList", maps);

dntd-tool/src/main/java/com/dky/generate/HeatBoilerScene.java

@@ -0,0 +1,169 @@
+package com.dky.generate;
+
+import cn.hutool.json.JSONObject;
+import com.dky.calculate.*;
+import com.dky.modelI.DntdModelI;
+import com.dky.utils.GetTargetDeviceList;
+import com.dky.utils.entity.SysDeviceHeatScene;
+import com.dky.utils.enums.DeviceSubType;
+import com.dky.utils.result.MatchedDevice;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class HeatBoilerScene implements DntdModelI {
+
+    DecimalFormat decimalFormat = new DecimalFormat("#.00");
+
+    // 首先A=由运行/合同容量折合成kW（x0.9）x85%,
+    static final Double COEFFICIENT_1 = 0.9;
+    static final Double COEFFICIENT_2 = 0.85;
+
+
+    @Override
+    public JSONObject createReport(JSONObject jsonObject, List<SysDeviceHeatScene> list) {
+
+        List<SysDeviceHeatScene> alternateDeviceList = GetTargetDeviceList.main(DeviceSubType.Boiler_Heating.getDesc(), list);
+        // System.out.println("工业锅炉供热: " + alternateDeviceList + "\n");
+
+        JSONObject distInfo = new JSONObject();
+        JSONObject heatUseNeedInfo = new JSONObject();
+        JSONObject originalDevInfo = new JSONObject();
+
+        try {
+            distInfo = (JSONObject) jsonObject.get("distInfo");
+            heatUseNeedInfo = (JSONObject) jsonObject.get("heatUseNeedInfo");
+            originalDevInfo = (JSONObject) jsonObject.get("originalDevInfo");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        // 运行容量
+        Double runCapacity = Double.parseDouble(distInfo.get("runCapacity").toString());
+        // 上年最大需量
+        Double lastYearNeed = Double.parseDouble(distInfo.get("lastYearNeed").toString());
+        // 供热需量设备功率(单位: kW)【 1蒸吨等于770KW 】
+        Double heatingNeedPower = Double.parseDouble(heatUseNeedInfo.get("heatingNeedPower").toString()) * 770;
+        // 出口温度（摄氏度）
+        Double thermometerValueOut = Double.parseDouble(heatUseNeedInfo.get("thermometerValueOut").toString());
+        // 替代前年能源用量
+        Double previousYearEnergyUsage = Double.parseDouble(originalDevInfo.get("previousYearEnergyUsage").toString());
+        // 上年运行费用（元）
+        Double lastYearFee = Double.parseDouble(originalDevInfo.get("lastYearFee").toString());
+
+        // 根据供热需量设备功率计算出不同技术类型下所需要不同功率设备数据
+        List<List<MatchedDevice>> matchedDeviceGroupList = HeatBoilerScheme.calScheme(heatingNeedPower, alternateDeviceList);
+
+        //  实际可承载容量A = 运行（或合同容量）x0.9 [将运行容量或合同容量折算成容量] x85%
+        double A = runCapacity * COEFFICIENT_1 * COEFFICIENT_2;
+        //  根据供热需量设备功率计算每个技术类型下需要的不同功率的设备的数量，然后将不同功率及对应的数量进行计算得出总功率C1，取最大
+        Double C1 = CalC.getC1(matchedDeviceGroupList);
+
+        // 改造后最大需量
+        double D1 = lastYearNeed + C1;
+
+        double costRatio = 0.2;
+        double effRatio = 0.8;
+        try {
+            double costRatio1 = Double.parseDouble(jsonObject.get("costRatio").toString());
+            double effRatio1 = Double.parseDouble(jsonObject.get("effRatio").toString());
+            if (costRatio1 < 1 && costRatio1 + costRatio1 == 1) {
+                costRatio = costRatio1;
+                effRatio = effRatio1;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+
+        List<MatchedDevice> matchedDeviceList;
+        Map<String, SchemeRatingRes> listMap;
+
+        //  根据具体容量与需量判断可使用的技术并计算评分
+        //  计算不同细类下成本最小值与效率最大值
+        Map<String, Double> maxEffMap = SchemeRating.getMaxEfficiencyGroupByDevSubType(alternateDeviceList);
+        Map<String, Double> minPrice = SchemeRating.getMinPriceGroupByDevSubType(matchedDeviceGroupList);
+        String remark = "";
+
+        // 同时考虑热泵和电锅炉
+        if (A < D1) {
+            remark = "本方案存在扩容投资需求，扩容投资不计入初次投资费用";
+        }
+        listMap = SchemeRating.getOptimalList(matchedDeviceGroupList, costRatio, effRatio, maxEffMap, minPrice);
+        matchedDeviceList = SchemeRating.getOptimalScheme(listMap);
+
+        List<Map<String, Object>> maps = new ArrayList<>();
+        listMap.forEach((k, v) -> {
+            Map<String, Object> map = new HashMap<>();
+            map.put("rating", decimalFormat.format(v.getSchemeRating()));
+            map.put("plan", v.getList());
+            map.put("planName", v.getPlanName());
+            maps.add(map);
+        });
+
+
+        /*
+            封装返回
+         */
+        JSONObject returnJsonObject = new JSONObject();
+        Double startCost = 0.0;
+        Double runCost = 0.0;
+        Double allCost = 0.0;
+        Double calculateAnnualCarbon = 0.0;
+        Double electric = 0.0;
+        List<HashMap<String, Object>> deviceList = new ArrayList<>();
+        for (MatchedDevice matchedDevice : matchedDeviceList) {
+            HashMap<String, Object> map = new HashMap<>();
+            map.put("devSubType", matchedDevice.getDeviceHeatScene().getDevSubType());
+            map.put("devTechType", matchedDevice.getDeviceHeatScene().getDevTechType());
+            map.put("devCount", matchedDevice.getCount());
+            map.put("devPrice", matchedDevice.getDeviceHeatScene().getDevPrice());
+            deviceList.add(map);
+
+            startCost = startCost + (matchedDevice.getCount() * matchedDevice.getDeviceHeatScene().getDevPrice());
+
+            runCost = runCost + (HeatBoilerModel.calculateAnnualOperatingCost(matchedDevice.getDeviceHeatScene().getDevPower(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevSubstituteLaborCost(), matchedDevice.getDeviceHeatScene().getDevAnnualOperationTime()));
+
+            allCost = allCost + (HeatBoilerModel.calculateAnnualTotalCost(matchedDevice.getDeviceHeatScene().getDevPower(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevSubstituteLaborCost(),
+                    matchedDevice.getDeviceHeatScene().getDevAnnualOperationTime(), matchedDevice.getDeviceHeatScene().getDevPrice(), matchedDevice.getDeviceHeatScene().getDevServiceLife()));
+
+            electric = electric + (HeatBoilerModel.calculateSubstituteElectricity(matchedDevice.getDeviceHeatScene().getDevPower(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevAnnualOperationTime()));
+
+            // calculateAnnualCarbon = calculateAnnualCarbon + (HeatBoilerModel.calculateAnnualCarbonReduction(previousYearEnergyUsage, matchedDevice.getDeviceHeatScene().getDevPower(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevAnnualOperationTime()));
+
+        }
+        //初次投资费用
+        returnJsonObject.set("startCost", decimalFormat.format(startCost));
+        // 设备总价
+        returnJsonObject.set("devCost", decimalFormat.format(startCost));
+        //年运行费用
+        returnJsonObject.set("yearRunCost", decimalFormat.format(runCost));
+        //年总费用
+        returnJsonObject.set("yearCost", decimalFormat.format(allCost));
+        //年减碳量
+        calculateAnnualCarbon = HeatBoilerModel.calculateAnnualCarbonReduction(previousYearEnergyUsage, electric);
+        returnJsonObject.set("calculate", decimalFormat.format(calculateAnnualCarbon / 1000));
+        //替代电量
+        returnJsonObject.set("electric", decimalFormat.format(electric));
+        //备注
+        returnJsonObject.set("remark", remark);
+        //封装需配置设备情况
+        returnJsonObject.set("deviceList", deviceList);
+
+        //封装方案优势
+        returnJsonObject.set("safety", BuildHeatingAdvantage.safety());
+        returnJsonObject.set("economy", Advantage.economy(startCost, runCost, lastYearFee));
+        returnJsonObject.set("intelligence", BuildHeatingAdvantage.intelligence());
+        returnJsonObject.set("environment", BuildHeatingAdvantage.environment(Double.valueOf(decimalFormat.format(calculateAnnualCarbon / 1000))));
+
+        //封装方案评分
+        returnJsonObject.set("matchedDeviceList", maps);
+
+        return returnJsonObject;
+    }
+
+
+}

dntd-tool/src/main/java/com/dky/generate/HeatBoilerSence.java

@@ -1,82 +0,0 @@
-package com.dky.generate;
-
-import cn.hutool.json.JSONObject;
-import com.dky.calculate.Advantage;
-import com.dky.calculate.Overall;
-import com.dky.entity.Heatboiler;
-import com.dky.modelI.DntdModelI;
-import com.dky.utils.entity.SysDeviceHeatScene;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-public class HeatBoilerSence implements DntdModelI {
-    @Override
-    public JSONObject createReport(JSONObject jsonObject, List<SysDeviceHeatScene> alternateDeviceList) {
-        JSONObject jsonReport = new JSONObject();
-        Heatboiler heatboiler = jsonObject.toBean(Heatboiler.class);
-        // 生成报告
-        // List<DevSpec> specList = ModelTool.specList;
-        // List<DevPrice> priceList = ModelTool.priceList;
-        // MatchedDeviceResult matchedDeviceResult = RequireDevice.matchDevices(heatboiler.getHotDevicePower(), specList, priceList);
-        Overall overall = new Overall();
-        //初次投资费用（万元）
-        // Double firstInvestFee = Math.round(matchedDeviceResult.getTotalPriceInTenThousand()*100.0)/100.0;
-        //年运行费用（万元）
-        Double yearRunFee = Math.round(overall.yearRunFee(heatboiler.getYearEnergy(), heatboiler.getElectricityPrice())*100.0)/100.0;
-        //年总费用（万元）
-        Double yearTotalFee = Math.round(overall.yearTotalFee(yearRunFee)*100.0)/100.0;
-        //年减碳（吨）
-        Double yearReduceCarbon = Math.round(overall.yearReduceCarbon(heatboiler.getYearEnergy())*100.0)/100.0;
-        //替代电量
-        Double replaceEnergy = Math.round(overall.replaceEnergy(heatboiler.getYearEnergy())*100.0)/100.0;
-        // List<MatchedDevice> devices = matchedDeviceResult.getMatchedDevices();
-        //需配置设备情况
-        //方案详情
-        String reportDetail = "用直热式电锅炉替代原设备";
-        /*//设备类型
-        String deviceType = "";
-        //设备规格
-        String deviceSpec = "";
-        //设备数量
-        String deviceNum = "";*/
-        //单位（元/台、元/套）
-        String unit = "";
-        Set<String> devTypeSet = new HashSet<>();
-       /* for (MatchedDevice : matchedDeviceResult.getMatchedDevices()) {
-            devTypeSet.add(matchedDevice.getDevSpec().getDevType());
-            deviceSpec = deviceSpec + matchedDevice.getDevSpec().getDevType() + ":"+matchedDevicematchedDevice.getDevSpec().getCapacity()+"蒸吨、";
-            deviceNum = deviceNum + matchedDevice.getCount() + "台/"+matchedDevice.getDevSpec().getDevType()+";";
-            int devId = matchedDevice.getDevSpec().getId();
-            for (DevPrice devPrice : priceList) {
-                if (devId == devPrice.getId()) {
-                    unit = unit+devPrice.getDevPrice()+"元/台；";
-                    break;
-                }
-            }
-        }*/
-       /* for (String s : devTypeSet) {
-            deviceType = deviceType + s + "、";
-        }*/
-        Advantage advantage = new Advantage();
-        //总价
-        // String totalPrice = matchedDeviceResult.getTotalPriceInTenThousand()+"万元";
-        // jsonReport.put("firstInvestFee", firstInvestFee);
-        jsonReport.put("yearRunFee", yearRunFee);
-        jsonReport.put("yearTotalFee", yearTotalFee);
-        jsonReport.put("yearReduceCarbon", yearReduceCarbon);
-        jsonReport.put("replaceEnergy", replaceEnergy);
-        jsonReport.put("reportDetail", reportDetail);
-        /*jsonReport.put("deviceType", deviceType);
-        jsonReport.put("deviceSpec", deviceSpec);*/
-        // jsonReport.put("devices", devices);
-        jsonReport.put("unit", unit);
-        // jsonReport.put("totalPrice", totalPrice);
-        jsonReport.put("safety", advantage.safety());
-        // jsonReport.put("economy", advantage.economy(firstInvestFee,yearTotalFee,yearRunFee,heatboiler.getOriginalDevice().getLastYearFee()));
-        jsonReport.put("intelligence", advantage.intelligence());
-        jsonReport.put("environment", advantage.environment(yearReduceCarbon));
-        return jsonReport;
-    }
-}

dntd-tool/src/main/java/com/dky/security/SM4Utils.java

@@ -73,7 +73,7 @@ public class SM4Utils {
 
     public static void main(String[] args) throws Exception {
         String s =
-                "GWnQ4RqqTc8n1Uj59xLoUtv975fmQsRWuvsk1zRmQu9TwIvlc6FTekndKMh+vMuRbI2bxdmuIxyZndYcg9u5xVa+HaiBZRP8OZFYIAo+66vDVlkBf47Nh2srjFyIXlLH";
+                "ELjXfd24Nl0LrqAIgE5pDAolhmR0ARb5qJpGuoQHMO4q8zq8F84zVFJC+WoUMgVUCUroZHemAUp06HUO2iYGBavkllg/tp1+dum7FSZilOkBJhFQqRsgHftdznSXX02l7iqX+vPZyNKyLubVgDoPjYj7GyhXZ/pOm6AthNcRV2E=";
         List<Map<String, String>> decryptList = decrypt(s);
         decryptList.forEach(System.out::println);
 

dntd-tool/src/main/java/com/dky/test/TestMain.java

@@ -10,62 +10,48 @@ package com.dky.test;
  */
 
 
+import cn.hutool.json.JSONObject;
+import com.dky.calculate.HeatBoilerScheme;
 import com.dky.calculate.Scheme;
 import com.dky.calculate.SchemeRating;
+import com.dky.tool.ModelTool;
 import com.dky.utils.entity.SysDeviceHeatScene;
 import com.dky.utils.result.MatchedDevice;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 
 public class TestMain {
 
     public static void main(String[] args) {
 
-        List<SysDeviceHeatScene> alternateDeviceList = createDevList();
+        JSONObject param = new JSONObject();
-
+        param.put("type", "0102");
-        // List<List<MatchedDevice>> alternateDeviceList = calSchemeMethodTest(14000.0, devList);
+        param.put("costRatio", 0.2);
-
+        param.put("effRatio", 0.8);
-        // getMaxEfficiencyGroupByDevSubTypeTest(alternateDeviceList);
+        param.put("distInfo", new JSONObject()
-        // getMinPriceGroupByDevSubTypeTest(alternateDeviceList);
+                .put("runCapacity", 2400.0)
-
+                .put("lastYearNeed", 1600.0));
-           /*
+        param.put("heatUseNeedInfo", new JSONObject()
-            根据建筑面积计算出不同技术类型下所需要不同功率设备数据
+                .put("heatingNeedPower", 33)
-         */
+                .put("thermometerValueOut", 112.45));
-        List<List<MatchedDevice>> matchedDeviceGroupList = Scheme.calScheme(44000.0, alternateDeviceList);
+        param.put("originalDevInfo", new JSONObject()
-
+                .put("previousYearEnergyUsage", 24090000)
-
+                .put("lastYearFee", 3000000));
-        /*
+        String key = "GWnQ4RqqTc8n1Uj59xLoUtv975fmQsRWuvsk1zRmQu9TwIvlc6FTekndKMh+vMuRbI2bxdmuIxyZndYcg9u5xVa+HaiBZRP8OZFYIAo+66vDVlkBf47Nh2srjFyIXlLH";
-            判断计算占比，默认效率0.8，成本0.2
+
-         */
+        // 构建JSONObject对象
-        double costRatio = 0.2;
+        JSONObject list = new JSONObject();
-        double effRatio = 0.8;
+        // 将设备列表放入JSONObject对象当中并且键为“devSpecList”（键名必须为“devSpecList”）
-
+        list.put("devSpecList", createDevList());
-
+        // 将这个JSONObject对象list作为入参调用ModelTool的create方法实现产品库初始化。
-        List<MatchedDevice> matchedDeviceList ;
+        ModelTool modelTool = ModelTool.create(list);
-        Map<Double, List<MatchedDevice>> listMap ;
+        // 调用ModelTool的唯一入口函数exeModel2Report，将场景参数param和密钥key作为入参传进去，得到输出结果电能替代报告。
-        /*
+        System.out.println(modelTool.exeModel2Report(param, key));
-            根据具体容量与需量判断可使用的技术并计算评分
-         */
-        //计算不同细类下成本最小值与效率最大值
-        Map<String, Double> maxEffMap = SchemeRating.getMaxEfficiencyGroupByDevSubType(alternateDeviceList);
-        //Map<String, Double> minPriceMap = SchemeRating.getMinPriceGroupByDevSubType(alternateDeviceList);
-        //listMap = SchemeRating.getOptimalList(matchedDeviceGroupList,costRatio,effRatio,maxEffMap,minPriceMap);
-        //matchedDeviceList = SchemeRating.getOptimalScheme(listMap);
 
     }
 
 
-    public static List<List<MatchedDevice>> calSchemeMethodTest(Double buildArea, List<SysDeviceHeatScene> SysDeviceHeatSceneList) {
-        return Scheme.calScheme(buildArea, SysDeviceHeatSceneList);
-
-    }
-
-    public static void getMaxEfficiencyGroupByDevSubTypeTest(List<SysDeviceHeatScene> sysDeviceHeatSceneList){
-        SchemeRating.getMaxEfficiencyGroupByDevSubType(sysDeviceHeatSceneList);
-    }
-
 
 
     public static List<SysDeviceHeatScene>createDevList(){
@@ -74,6 +60,24 @@ public class TestMain {
         // 模拟从数据库中检索数据
         Object[][] data =
                 {
+                        {1, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电阻类）", 0.95, 360.00, 80000.00, 60000.00, 180000.00, 3000.00, 15, 4500, null},
+                        {2, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电阻类）", 0.95, 720.00, 100000.00, 60000.00, 180000.00, 6000.00, 15, 4500, null},
+                        {3, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电阻类）", 0.95, 1440.00, 160000.00, 60000.00, 180000.00, 12000.00, 15, 4500, null},
+                        {4, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电极类）", 0.97, 360.00, 280000.00, 60000.00, 180000.00, 3000.00, 15, 4500, null},
+                        {5, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电极类）", 0.97, 720.00, 460000.00, 60000.00, 180000.00, 6000.00, 15, 4500, null},
+                        {6, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电极类）", 0.97, 1440.00, 900000.00, 60000.00, 180000.00, 12000.00, 15, 4500, null},
+                        {7, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电磁涡流类）", 0.98, 360.00, 150000.00, 60000.00, 180000.00, 3000.00, 15, 4500, null},
+                        {8, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电磁涡流类）", 0.98, 720.00, 180000.00, 60000.00, 180000.00, 6000.00, 15, 4500, null},
+                        {9, "电锅炉", "工业供热电锅炉", "直热式电锅炉（电磁涡流类）", 0.98, 1440.00, 300000.00, 60000.00, 180000.00, 12000.00, 15, 4500, null},
+                        {10, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（固体蓄热）", 0.95, 360.00, 360000.00, 60000.00, 180000.00, 3000.00, 15, 4500, null},
+                        {11, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（固体蓄热）", 0.95, 720.00, 720000.00, 60000.00, 180000.00, 6000.00, 15, 4500, null},
+                        {12, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（固体蓄热）", 0.95, 1440.00, 1440000.00, 60000.00, 180000.00, 12000.00, 15, 4500, null},
+                        {13, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（相变蓄热）", 0.98, 360.00, 120000.00, 60000.00, 180000.00, 3000.00, 15, 4500, null},
+                        {14, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（相变蓄热）", 0.98, 720.00, 160000.00, 60000.00, 180000.00, 6000.00, 15, 4500, null},
+                        {15, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（相变蓄热）", 0.98, 1440.00, 280000.00, 60000.00, 180000.00, 12000.00, 15, 4500, null},
+                        {16, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（水蓄）", 0.97, 360.00, 110000.00, 60000.00, 180000.00, 3000.00, 15, 4500, null},
+                        {17, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（水蓄）", 0.97, 720.00, 150000.00, 60000.00, 180000.00, 6000.00, 15, 4500, null},
+                        {18, "电锅炉", "工业供热电锅炉", "蓄热式电锅炉（水蓄）", 0.97, 1440.00, 260000.00, 60000.00, 180000.00, 12000.00, 15, 4500, null},
                         {19, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电阻类）", 0.95, 360.00, 80000.00, 60000.00, 180000.00, 3000.00, 15, null, null},
                         {20, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电阻类）", 0.95, 720.00, 100000.00, 60000.00, 180000.00, 6000.00, 15, null, null},
                         {21, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电阻类）", 0.95, 1440.00, 160000.00, 60000.00, 180000.00, 12000.00, 15, null, null},
@@ -124,12 +128,14 @@ public class TestMain {
 
             SysDeviceHeatScene device = new SysDeviceHeatScene(
                     id, devType, devSubType, devTechType, heatEfficiency, devPower, devPrice,
-                    devSubstituteLaborCost, laborCost, devReferenceArea, devServiceLife, null, null);
+                    devSubstituteLaborCost, laborCost, devReferenceArea, devServiceLife, 4500, null);
 
             deviceList.add(device);
         }
         return deviceList;
     }
 
+
+
 }
 

dntd-tool/src/main/resources/modelCode.properties

@@ -1,2 +1,2 @@
 0101=generate.BuildHeatingScene
-0102=generate.HeatBoilerSence
+0102=generate.HeatBoilerScene