From 8c81724b9eb677ce9ef8ce725099646f1e408653 Mon Sep 17 00:00:00 2001 From: XMnhwj_BackTechnologyDevelopment <3512363680@qq.com> Date: Tue, 19 Mar 2024 13:16:12 +0800 Subject: [PATCH] =?UTF-8?q?2024-03-19=2013:16:00=20=E9=94=85=E7=82=89?= =?UTF-8?q?=E4=BE=9B=E7=83=AD=E6=A8=A1=E5=9E=8B=E6=8E=A5=E5=8F=A3=E5=BC=80?= =?UTF-8?q?=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../com/dky/utils/GetTargetDeviceList.java | 21 +++ .../dky/utils/entity/SysDeviceHeatScene.java | 21 +++ .../main/java/com/dky/utils/enums/Code.java | 3 +- .../com/dky/utils/enums/DeviceSubType.java | 33 ++++ .../com/dky/calculate/BuildHeatingModel.java | 8 +- .../main/java/com/dky/calculate/Scheme.java | 1 - .../java/com/dky/calculate/SchemeRating.java | 9 +- dntd-model-heatboiler/pom.xml | 6 + .../java/com/dky/calculate/Advantage.java | 27 ++- .../com/dky/calculate/HeatBoilerModel.java | 83 +++++---- .../com/dky/calculate/HeatBoilerScheme.java | 59 ++++++ dntd-tool/pom.xml | 12 ++ .../com/dky/generate/BuildHeatingScene.java | 14 +- .../com/dky/generate/HeatBoilerScene.java | 169 ++++++++++++++++++ .../com/dky/generate/HeatBoilerSence.java | 82 --------- .../main/java/com/dky/security/SM4Utils.java | 2 +- .../src/main/java/com/dky/test/TestMain.java | 88 ++++----- .../src/main/resources/modelCode.properties | 2 +- 18 files changed, 460 insertions(+), 180 deletions(-) create mode 100644 dntd-common/src/main/java/com/dky/utils/GetTargetDeviceList.java create mode 100644 dntd-common/src/main/java/com/dky/utils/enums/DeviceSubType.java create mode 100644 dntd-model-heatboiler/src/main/java/com/dky/calculate/HeatBoilerScheme.java create mode 100644 dntd-tool/src/main/java/com/dky/generate/HeatBoilerScene.java delete mode 100644 dntd-tool/src/main/java/com/dky/generate/HeatBoilerSence.java diff --git a/dntd-common/src/main/java/com/dky/utils/GetTargetDeviceList.java b/dntd-common/src/main/java/com/dky/utils/GetTargetDeviceList.java new file mode 100644 index 0000000..ceafca4 --- /dev/null +++ b/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 main(String args, List alternateDeviceList) { + List ary = new ArrayList<>(); + + alternateDeviceList.forEach((device) -> { + if (device.getDevSubType().equals(args)) { + ary.add(device); + } + }); + return ary; + } +} diff --git a/dntd-common/src/main/java/com/dky/utils/entity/SysDeviceHeatScene.java b/dntd-common/src/main/java/com/dky/utils/entity/SysDeviceHeatScene.java index 7832410..b88c9ee 100644 --- a/dntd-common/src/main/java/com/dky/utils/entity/SysDeviceHeatScene.java +++ b/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 + '}'; } diff --git a/dntd-common/src/main/java/com/dky/utils/enums/Code.java b/dntd-common/src/main/java/com/dky/utils/enums/Code.java index a631268..4a94910 100644 --- a/dntd-common/src/main/java/com/dky/utils/enums/Code.java +++ b/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, "私钥异常"); /** diff --git a/dntd-common/src/main/java/com/dky/utils/enums/DeviceSubType.java b/dntd-common/src/main/java/com/dky/utils/enums/DeviceSubType.java new file mode 100644 index 0000000..07ae6b4 --- /dev/null +++ b/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; + } + +} diff --git a/dntd-model-buildheating/src/main/java/com/dky/calculate/BuildHeatingModel.java b/dntd-model-buildheating/src/main/java/com/dky/calculate/BuildHeatingModel.java index 80e6e4f..a138f6b 100644 --- a/dntd-model-buildheating/src/main/java/com/dky/calculate/BuildHeatingModel.java +++ b/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; } diff --git a/dntd-model-buildheating/src/main/java/com/dky/calculate/Scheme.java b/dntd-model-buildheating/src/main/java/com/dky/calculate/Scheme.java index 5456780..b14d7e4 100644 --- a/dntd-model-buildheating/src/main/java/com/dky/calculate/Scheme.java +++ b/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> calScheme(Double buildArea, List sysDeviceHeatSceneList) { // 根据设备细类筛选出一个以设备细类为键，该细类下设备列表为值的Map diff --git a/dntd-model-buildheating/src/main/java/com/dky/calculate/SchemeRating.java b/dntd-model-buildheating/src/main/java/com/dky/calculate/SchemeRating.java index 484ae14..7ef6e7e 100644 --- a/dntd-model-buildheating/src/main/java/com/dky/calculate/SchemeRating.java +++ b/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 getMaxEfficiencyGroupByDevSubType( List alternateDeviceList){ + public static Map getMaxEfficiencyGroupByDevSubType(List alternateDeviceList){ Map map = new HashMap<>(); alternateDeviceList.forEach(alternateDevice ->{ String devSubType = alternateDevice.getDevSubType(); diff --git a/dntd-model-heatboiler/pom.xml b/dntd-model-heatboiler/pom.xml index 8ac61dd..844a501 100644 --- a/dntd-model-heatboiler/pom.xml +++ b/dntd-model-heatboiler/pom.xml @@ -34,6 +34,12 @@ dntd-common 1.0-SNAPSHOT + + com.dky + dntd-common + 1.1-SNAPSHOT + compile + diff --git a/dntd-model-heatboiler/src/main/java/com/dky/calculate/Advantage.java b/dntd-model-heatboiler/src/main/java/com/dky/calculate/Advantage.java index 8f5021f..d927284 100644 --- a/dntd-model-heatboiler/src/main/java/com/dky/calculate/Advantage.java +++ b/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; - return "本次改造投资回收期为"+hsq+"年，本改造方案相比较原技术节省年运行费用成本"+js+"元。"; + + /** + * 经济性 + * @param firstInvestFee 初始投资金额 + * @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() { diff --git a/dntd-model-heatboiler/src/main/java/com/dky/calculate/HeatBoilerModel.java b/dntd-model-heatboiler/src/main/java/com/dky/calculate/HeatBoilerModel.java index f29617b..807f1d9 100644 --- a/dntd-model-heatboiler/src/main/java/com/dky/calculate/HeatBoilerModel.java +++ b/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 heatboiler 基础入参 - * @param originalDevice 原设备参数 - * @param count 电替代设备台数 TODO + * @param devicePower 电替代设备功率 + * @param deviceCount 电替代设备台数 + * @param deviceSubstituteLaborCost 电替代设备人工费用 + * @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) { // 电替代设备年耗电量=单台电替代设备的功率*电替代设备台数*电设备年运行时间 - double annualElectricityConsumption = heatboilerSpec.getSubstitutePower() * count * heatboilerSpec.getAnnualOperationTime(); - // 年运行费用=电替代设备年耗电量*平均电价(0.5元/千瓦时)+电替代设备人工费用成本 - return annualElectricityConsumption * 0.5 + heatboilerSpec.getSubstituteLaborCost(); + double annualElectricityConsumption = devicePower * deviceCount * deviceAnnualOperationTime; + // 年运行费用=电替代设备年耗电量*平均电价(0.5元/千瓦时) + 单台电替代设备人工费用成本 * 台数 + return annualElectricityConsumption * 0.5 + deviceSubstituteLaborCost * deviceCount; } /** * 计算年总费用 - * @param heatboilerSpec 非表中参数 - * @param heatboiler 基础入参 - * @param originalDevice 原设备参数 - * @param count 电替代设备台数 TODO - * @return 年总费用 + * @param devicePower 电替代设备功率 + * @param deviceCount 电替代设备台数 + * @param deviceSubstituteLaborCost 电替代设备人工费用 + * @param deviceAnnualOperationTime 电替代设备年运行时间 + * @param devicePrice 设备价格 + * @param deviceServiceLife 设备使用年限 + * @return */ - public static double calculateAnnualTotalCost(HeatboilerSpec heatboilerSpec, Heatboiler heatboiler , OriginalDevice originalDevice ,Integer count) { - //（电替代设备台数*单台电设备价格）/电替代设备的使用年限+年运行费用 - return (count * 1) / heatboilerSpec.getServiceLife() + calculateAnnualOperatingCost( heatboilerSpec, heatboiler , originalDevice,count); + public static double calculateAnnualTotalCost(Double devicePower, Integer deviceCount, Double deviceSubstituteLaborCost, Integer deviceAnnualOperationTime, Double devicePrice, Integer deviceServiceLife) { + //（电替代设备台数*单台电设备价格）/电替代设备的使用年限 + double v = ((devicePrice * deviceCount) / deviceServiceLife); + // 年总费用=（电替代设备台数*单台电设备价格）/电替代设备的使用年限 + 年运行费用 + return v + calculateAnnualOperatingCost(devicePower, deviceCount, deviceSubstituteLaborCost, deviceAnnualOperationTime); } /** * 计算年减碳量 - * @param heatboilerSpec 非表中参数 - * @param heatboiler 基础入参 - * @param originalDevice 原设备参数 + * @param previousYearEnergyUsage 替代前年能源用量 + * @param deviceElectric 电替代耗电量 * @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; // 千克标准煤/千克 - final double electricityConsumptionCoefficient = 0.1229; // 千克标准煤/千瓦时 - final double carbonDioxideCoefficient = 1.9003; // 千克二氧化碳/千克 + // 计算替代前年能源用量对应的标准煤量 + double coalEquivalentFromEnergy = previousYearEnergyUsage * coalConversionFactor; + // 计算电替代设备年耗电量对应的标准煤量 + double coalEquivalentFromElectricity = deviceElectric * electricityConversionFactor; - //单台电替代设备年耗电量 = 电替代设备年运行时间 * 电替代设备功率 - double electricSubstitutionEquipmentYearlyElectricityConsumption = heatboilerSpec.getAnnualOperationTime() * heatboilerSpec.getSubstitutePower(); + // 计算净减少的标准煤量 + double netReductionInCoalEquivalent = coalEquivalentFromEnergy - coalEquivalentFromElectricity; - return (originalDevice.getSubstituteBeforeEnergyConsumption() * standardCoalCoefficient - - electricSubstitutionEquipmentYearlyElectricityConsumption * electricityConsumptionCoefficient) - * carbonDioxideCoefficient; + // 计算年减碳量 + return netReductionInCoalEquivalent * carbonConversionFactor; } /** - * 计算替代电量 - * @param heatboilerSpec 非表中参数 - * @param heatboiler 基础入参 - * @param originalDevice 原设备参数 - * @param count 电替代设备台数 TODO - * @return 替代电量 + * 计算电替代设备年耗电量 + * @param devicePower 设备功率 + * @param deviceCount 设备台数 + * @param deviceAnnualOperationTime 单台电设备年运行时间 + * @return */ - public static double calculateSubstituteElectricity(HeatboilerSpec heatboilerSpec, Heatboiler heatboiler , OriginalDevice originalDevice,Integer count) { - // 电替代设备年耗电量=电替代设备的功率*电替代设备台数*电设备年运行时间 - return heatboilerSpec.getSubstitutePower() * count * heatboilerSpec.getAnnualOperationTime(); + public static double calculateSubstituteElectricity(Double devicePower, Integer deviceCount, Integer deviceAnnualOperationTime) { + // 电替代设备年耗电量 = 电替代设备的功率 * 电替代设备台数 * 电设备年运行时间 + return devicePower * deviceCount * deviceAnnualOperationTime; } diff --git a/dntd-model-heatboiler/src/main/java/com/dky/calculate/HeatBoilerScheme.java b/dntd-model-heatboiler/src/main/java/com/dky/calculate/HeatBoilerScheme.java new file mode 100644 index 0000000..7e936c1 --- /dev/null +++ b/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> calScheme(Double heatEfficiency, List sysDeviceHeatSceneList) { + // 根据设备细类筛选出一个以设备细类为键，该细类下设备列表为值的Map + Map> groupByDevSubTypeMap = sysDeviceHeatSceneList.stream() + .collect(Collectors.groupingBy(SysDeviceHeatScene::getDevSubType)); + + // 区分技术类型 + List> planList = new ArrayList<>(); + groupByDevSubTypeMap.forEach((devSubType, v) -> { + + // 该细类下的设备根据技术类型筛选出一个以技术类型为键，该技术类型下设备列表为值的Map + Map> groupByDevTechTypeMap = v.stream().collect(Collectors.groupingBy(SysDeviceHeatScene::getDevTechType)); + + groupByDevTechTypeMap.forEach((devTechType, devList) -> { + List matchedDevices = calSchemeByTechType(heatEfficiency, devList); + planList.add(matchedDevices); + }); + + }); + return planList; + } + + public static List calSchemeByTechType(Double heatEfficiency, List sysDeviceHeatSceneList) { + // 对技术类型下的设备list按照单台设备功率进行排序 + sysDeviceHeatSceneList.sort((o1, o2) -> Double.compare(o2.getDevPower(), o1.getDevPower())); + Double remainArea = heatEfficiency; + // 遍历设备，根据建筑面积进行匹配设备数量 + List 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; + } + + + +} diff --git a/dntd-tool/pom.xml b/dntd-tool/pom.xml index fe2bd98..2ebe441 100644 --- a/dntd-tool/pom.xml +++ b/dntd-tool/pom.xml @@ -49,6 +49,18 @@ 1.0-SNAPSHOT compile + + com.dky + dntd-common + 1.1-SNAPSHOT + compile + + + com.dky + dntd-model-heatboiler + 1.1-SNAPSHOT + compile + diff --git a/dntd-tool/src/main/java/com/dky/generate/BuildHeatingScene.java b/dntd-tool/src/main/java/com/dky/generate/BuildHeatingScene.java index c093d5d..d0431a1 100644 --- a/dntd-tool/src/main/java/com/dky/generate/BuildHeatingScene.java +++ b/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 alternateDeviceList) { + public JSONObject createReport(JSONObject jsonObject,List sceneList) { + List list = GetTargetDeviceList.main(DeviceSubType.Cooling_Heating.getDesc(), sceneList); + List 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> 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); diff --git a/dntd-tool/src/main/java/com/dky/generate/HeatBoilerScene.java b/dntd-tool/src/main/java/com/dky/generate/HeatBoilerScene.java new file mode 100644 index 0000000..f657d6e --- /dev/null +++ b/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 list) { + + List 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> 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 matchedDeviceList; + Map listMap; + + // 根据具体容量与需量判断可使用的技术并计算评分 + // 计算不同细类下成本最小值与效率最大值 + Map maxEffMap = SchemeRating.getMaxEfficiencyGroupByDevSubType(alternateDeviceList); + Map minPrice = SchemeRating.getMinPriceGroupByDevSubType(matchedDeviceGroupList); + String remark = ""; + + // 同时考虑热泵和电锅炉 + if (A < D1) { + remark = "本方案存在扩容投资需求，扩容投资不计入初次投资费用"; + } + listMap = SchemeRating.getOptimalList(matchedDeviceGroupList, costRatio, effRatio, maxEffMap, minPrice); + matchedDeviceList = SchemeRating.getOptimalScheme(listMap); + + List> maps = new ArrayList<>(); + listMap.forEach((k, v) -> { + Map 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> deviceList = new ArrayList<>(); + for (MatchedDevice matchedDevice : matchedDeviceList) { + HashMap 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; + } + + +} diff --git a/dntd-tool/src/main/java/com/dky/generate/HeatBoilerSence.java b/dntd-tool/src/main/java/com/dky/generate/HeatBoilerSence.java deleted file mode 100644 index ce1fefe..0000000 --- a/dntd-tool/src/main/java/com/dky/generate/HeatBoilerSence.java +++ /dev/null @@ -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 alternateDeviceList) { - JSONObject jsonReport = new JSONObject(); - Heatboiler heatboiler = jsonObject.toBean(Heatboiler.class); - // 生成报告 - // List specList = ModelTool.specList; - // List 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 devices = matchedDeviceResult.getMatchedDevices(); - //需配置设备情况 - //方案详情 - String reportDetail = "用直热式电锅炉替代原设备"; - /*//设备类型 - String deviceType = ""; - //设备规格 - String deviceSpec = ""; - //设备数量 - String deviceNum = "";*/ - //单位（元/台、元/套） - String unit = ""; - Set 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; - } -} diff --git a/dntd-tool/src/main/java/com/dky/security/SM4Utils.java b/dntd-tool/src/main/java/com/dky/security/SM4Utils.java index 72f9d69..6408188 100644 --- a/dntd-tool/src/main/java/com/dky/security/SM4Utils.java +++ b/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> decryptList = decrypt(s); decryptList.forEach(System.out::println); diff --git a/dntd-tool/src/main/java/com/dky/test/TestMain.java b/dntd-tool/src/main/java/com/dky/test/TestMain.java index 7ebd77b..a5eb27c 100644 --- a/dntd-tool/src/main/java/com/dky/test/TestMain.java +++ b/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 alternateDeviceList = createDevList(); - - // List> alternateDeviceList = calSchemeMethodTest(14000.0, devList); - - // getMaxEfficiencyGroupByDevSubTypeTest(alternateDeviceList); - // getMinPriceGroupByDevSubTypeTest(alternateDeviceList); - - /* - 根据建筑面积计算出不同技术类型下所需要不同功率设备数据 - */ - List> matchedDeviceGroupList = Scheme.calScheme(44000.0, alternateDeviceList); - - - /* - 判断计算占比，默认效率0.8，成本0.2 - */ - double costRatio = 0.2; - double effRatio = 0.8; - - - List matchedDeviceList ; - Map> listMap ; - /* - 根据具体容量与需量判断可使用的技术并计算评分 - */ - //计算不同细类下成本最小值与效率最大值 - Map maxEffMap = SchemeRating.getMaxEfficiencyGroupByDevSubType(alternateDeviceList); - //Map minPriceMap = SchemeRating.getMinPriceGroupByDevSubType(alternateDeviceList); - //listMap = SchemeRating.getOptimalList(matchedDeviceGroupList,costRatio,effRatio,maxEffMap,minPriceMap); - //matchedDeviceList = SchemeRating.getOptimalScheme(listMap); + JSONObject param = new JSONObject(); + param.put("type", "0102"); + param.put("costRatio", 0.2); + param.put("effRatio", 0.8); + param.put("distInfo", new JSONObject() + .put("runCapacity", 2400.0) + .put("lastYearNeed", 1600.0)); + param.put("heatUseNeedInfo", new JSONObject() + .put("heatingNeedPower", 33) + .put("thermometerValueOut", 112.45)); + param.put("originalDevInfo", new JSONObject() + .put("previousYearEnergyUsage", 24090000) + .put("lastYearFee", 3000000)); + String key = "GWnQ4RqqTc8n1Uj59xLoUtv975fmQsRWuvsk1zRmQu9TwIvlc6FTekndKMh+vMuRbI2bxdmuIxyZndYcg9u5xVa+HaiBZRP8OZFYIAo+66vDVlkBf47Nh2srjFyIXlLH"; + + // 构建JSONObject对象 + JSONObject list = new JSONObject(); + // 将设备列表放入JSONObject对象当中并且键为“devSpecList”（键名必须为“devSpecList”） + list.put("devSpecList", createDevList()); + // 将这个JSONObject对象list作为入参调用ModelTool的create方法实现产品库初始化。 + ModelTool modelTool = ModelTool.create(list); + // 调用ModelTool的唯一入口函数exeModel2Report，将场景参数param和密钥key作为入参传进去，得到输出结果电能替代报告。 + System.out.println(modelTool.exeModel2Report(param, key)); } - public static List> calSchemeMethodTest(Double buildArea, List SysDeviceHeatSceneList) { - return Scheme.calScheme(buildArea, SysDeviceHeatSceneList); - - } - - public static void getMaxEfficiencyGroupByDevSubTypeTest(List sysDeviceHeatSceneList){ - SchemeRating.getMaxEfficiencyGroupByDevSubType(sysDeviceHeatSceneList); - } - public static ListcreateDevList(){ @@ -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; } + + } diff --git a/dntd-tool/src/main/resources/modelCode.properties b/dntd-tool/src/main/resources/modelCode.properties index ab28cb6..0341473 100644 --- a/dntd-tool/src/main/resources/modelCode.properties +++ b/dntd-tool/src/main/resources/modelCode.properties @@ -1,2 +1,2 @@ 0101=generate.BuildHeatingScene -0102=generate.HeatBoilerSence \ No newline at end of file +0102=generate.HeatBoilerScene \ No newline at end of file