From 611a4ae50de0600cc60dd34fc7e52665e02b5be0 Mon Sep 17 00:00:00 2001 From: XMnhwj_BackTechnologyDevelopment <3512363680@qq.com> Date: Fri, 22 Mar 2024 18:00:11 +0800 Subject: [PATCH] =?UTF-8?q?2024-03-20=2017:00:00=20=E5=BB=BA=E6=9D=90?= =?UTF-8?q?=E7=94=B5=E7=AA=91=E7=82=89=E6=A8=A1=E5=9E=8B=E6=8E=A5=E5=8F=A3?= =?UTF-8?q?=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/dky/utils/CalculateUtils.java | 124 +++++++++++++++ .../com/dky/utils/enums/MetalKinTemps.java | 34 ++++ .../main/java/calculate/MetalKilnScheme.java | 32 +++- .../src/main/resources/modelCode.properties | 2 +- dntd-tool/pom.xml | 7 + .../com/dky/generate/KitchenCookScene.java | 7 +- .../java/com/dky/generate/MetalKilnScene.java | 139 +++++++++++++++++ .../dky/stirtpar/StirparModelCalculate.java | 146 ++++++++++++++++++ .../src/main/java/com/dky/test/TestMain.java | 33 +++- .../electricConsumeStirpatCoefficient.json | 46 ++++++ .../energyConsumeStirpatCoefficient.json | 42 +++++ .../src/main/resources/modelCode.properties | 4 +- 12 files changed, 603 insertions(+), 13 deletions(-) create mode 100644 dntd-common/src/main/java/com/dky/utils/CalculateUtils.java create mode 100644 dntd-common/src/main/java/com/dky/utils/enums/MetalKinTemps.java create mode 100644 dntd-tool/src/main/java/com/dky/generate/MetalKilnScene.java create mode 100644 dntd-tool/src/main/java/com/dky/stirtpar/StirparModelCalculate.java create mode 100644 dntd-tool/src/main/resources/electricConsumeStirpatCoefficient.json create mode 100644 dntd-tool/src/main/resources/energyConsumeStirpatCoefficient.json diff --git a/dntd-common/src/main/java/com/dky/utils/CalculateUtils.java b/dntd-common/src/main/java/com/dky/utils/CalculateUtils.java new file mode 100644 index 0000000..cd336af --- /dev/null +++ b/dntd-common/src/main/java/com/dky/utils/CalculateUtils.java @@ -0,0 +1,124 @@ +package com.dky.utils; + +import java.math.BigDecimal; +import java.math.RoundingMode; + +/** + * double的计算不精确，会有类似0.0000000000000002的误差，正确的方法是使用BigDecimal或者用整型 + * 整型地方法适合于货币精度已知的情况，比如12.11+1.10转成1211+110计算，最后再/100即可 + * 以下是摘抄的BigDecimal方法: + * @author Stone + */ +public class CalculateUtils { + + private static final long serialVersionUID = -3345205828566485102L; + // 默认除法运算精度 + private static final Integer DEF_DIV_SCALE = 2; + + /** + * 提供精确的加法运算。 + * + * @param value1 被加数 + * @param value2 加数 + * @return 两个参数的和 + */ + public static Double add(Double value1, Double value2) { + if (null == value1){ + value1 = 0.0; + } + if (null == value2){ + value2 = 0.0; + } + BigDecimal b1 = new BigDecimal(Double.toString(value1)); + BigDecimal b2 = new BigDecimal(Double.toString(value2)); + return b1.add(b2).doubleValue(); + } + + /** + * 提供精确的减法运算。 + * + * @param value1 被减数 + * @param value2 减数 + * @return 两个参数的差 + */ + public static double sub(Double value1, Double value2) { + if (null == value1){ + value1 = 0.0; + } + if (null == value2){ + value2 = 0.0; + } + BigDecimal b1 = new BigDecimal(Double.toString(value1)); + BigDecimal b2 = new BigDecimal(Double.toString(value2)); + return b1.subtract(b2).doubleValue(); + } + + /** + * 提供精确的乘法运算。 + * + * @param value1 被乘数 + * @param value2 乘数 + * @return 两个参数的积 + */ + public static Double mul(Double value1, Double value2) { + if (null == value1){ + value1 = 0.0; + } + if (null == value2){ + value2 = 0.0; + } + BigDecimal b1 = new BigDecimal(Double.toString(value1)); + BigDecimal b2 = new BigDecimal(Double.toString(value2)); + return b1.multiply(b2).doubleValue(); + } + + /** + * 提供（相对）精确的除法运算，当发生除不尽的情况时， 精确到小数点以后10位，以后的数字四舍五入。 + * + * @param dividend 被除数 + * @param divisor 除数 + * @return 两个参数的商 + */ + public static Double divide(Double dividend, Double divisor) { + if (null == dividend){ + dividend = 0.0; + } + if (null == divisor){ + divisor = 1.0; + } + return divide(dividend, divisor, DEF_DIV_SCALE); + } + + /** + * 提供（相对）精确的除法运算。 当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。 + * + * @param dividend 被除数 + * @param divisor 除数 + * @param scale 表示表示需要精确到小数点以后几位。 + * @return 两个参数的商 + */ + public static Double divide(Double dividend, Double divisor, Integer scale) { + if (scale < 0) { + throw new IllegalArgumentException("The scale must be a positive integer or zero"); + } + BigDecimal b1 = new BigDecimal(Double.toString(dividend)); + BigDecimal b2 = new BigDecimal(Double.toString(divisor)); + return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue(); + } + + /** + * 提供指定数值的（精确）小数位四舍五入处理。 + * + * @param value 需要四舍五入的数字 + * @param scale 小数点后保留几位 + * @return 四舍五入后的结果 + */ + public static double round(double value, int scale) { + if (scale < 0) { + throw new IllegalArgumentException("The scale must be a positive integer or zero"); + } + BigDecimal b = new BigDecimal(Double.toString(value)); + BigDecimal one = new BigDecimal("1"); + return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue(); + } +} diff --git a/dntd-common/src/main/java/com/dky/utils/enums/MetalKinTemps.java b/dntd-common/src/main/java/com/dky/utils/enums/MetalKinTemps.java new file mode 100644 index 0000000..73f8d6a --- /dev/null +++ b/dntd-common/src/main/java/com/dky/utils/enums/MetalKinTemps.java @@ -0,0 +1,34 @@ +package com.dky.utils.enums; + + +public enum MetalKinTemps { + + Metal_Kiln_Direct_Heat_Min_Temp(648.0, "直接加热电阻炉"), + Metal_Kiln_Direct_Heat_Max_Temp(857.9, "直接加热电阻炉"), + Metal_Kiln_Interstitial_Heat_Min_Temp(858.0, "间接加热电阻炉（钟罩式光亮退火炉)"), + Metal_Kiln_Interstitial_Heat_Max_Temp(996.9, "间接加热电阻炉（钟罩式光亮退火炉)"), + Metal_Kiln_Induction_Min_Temp(997.0, "中/高频感应电炉"), + Metal_Kiln_Induction_Max_Temp(1285.7, "中/高频感应电炉"); + + /** + * 温度 + */ + private final Double temp; + /** + * 描述 + */ + private final String desc; + + public Double getTemp() { + return temp; + } + + public String getDesc() { + return desc; + } + + MetalKinTemps(Double temp, String desc) { + this.temp = temp; + this.desc = desc; + } +} diff --git a/dntd-model-metalkiln/src/main/java/calculate/MetalKilnScheme.java b/dntd-model-metalkiln/src/main/java/calculate/MetalKilnScheme.java index ac8ef69..20bee46 100644 --- a/dntd-model-metalkiln/src/main/java/calculate/MetalKilnScheme.java +++ b/dntd-model-metalkiln/src/main/java/calculate/MetalKilnScheme.java @@ -3,6 +3,8 @@ package calculate; import com.dky.utils.ConfigReader; import com.dky.utils.entity.SysDeviceHeatScene; +import com.dky.utils.enums.DeviceSubType; +import com.dky.utils.enums.MetalKinTemps; import com.dky.utils.result.MatchedDevice; import java.util.*; @@ -41,31 +43,55 @@ public class MetalKilnScheme { return matchedDeviceList; } - public static void getSchemeList(List sysDeviceHeatSceneList) { + public static List getSchemeList(String userIndustry, Double needTemp, List sysDeviceHeatSceneList) { // 黑色金属矿采选业 行业编码 String property = ConfigReader.getProperty("industry_code"); Map map = new HashMap<>(); + List sceneDevicesList = new ArrayList<>(); + // 将sysDeviceHeatSceneList流转换为排序后的ArrayList对象。 + // 排序依据是SysDeviceHeatScene对象的getDevTechType方法返回的值。 ArrayList ary = sysDeviceHeatSceneList.stream().collect( Collectors.collectingAndThen( + // 使用TreeSet收集元素，以保证收集后的集合是按照getDevTechType方法返回值排序的。 Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(SysDeviceHeatScene::getDevTechType))), + // 将TreeSet转换为ArrayList。 ArrayList::new ) ); + // 遍历ary数组中的每个元素 ary.forEach((item) -> { List list = new ArrayList<>(); + // 遍历sysDeviceHeatSceneList列表，筛选出与当前item的设备技术类型相同的设备 sysDeviceHeatSceneList.forEach((device) -> { if (device.getDevTechType().equals(item.getDevTechType())) { - list.add(device); + list.add(device); // 将符合条件的设备添加到list中 } }); + // 将按照设备技术类型分组后的设备列表，添加到map中 map.put(item.getDevTechType(), list); }); - } + if (userIndustry.equals(property)) { + sceneDevicesList = (List) map.get(DeviceSubType.Metal_Kiln_Electric_Arc.getDesc()); + } else { + if (needTemp >= MetalKinTemps.Metal_Kiln_Direct_Heat_Min_Temp.getTemp() && needTemp <= MetalKinTemps.Metal_Kiln_Direct_Heat_Max_Temp.getTemp()){ + sceneDevicesList = (List) map.get(DeviceSubType.Metal_Kiln_Direct_Heat.getDesc()); + } else if (needTemp >= MetalKinTemps.Metal_Kiln_Interstitial_Heat_Min_Temp.getTemp() && needTemp <= MetalKinTemps.Metal_Kiln_Interstitial_Heat_Max_Temp.getTemp()){ + sceneDevicesList = (List) map.get(DeviceSubType.Metal_Kiln_Interstitial_Heat.getDesc()); + } else if (needTemp >= MetalKinTemps.Metal_Kiln_Induction_Min_Temp.getTemp() && needTemp <= MetalKinTemps.Metal_Kiln_Induction_Max_Temp.getTemp()) { + sceneDevicesList = (List) map.get(DeviceSubType.Metal_Kiln_Induction.getDesc()); + } + } + return sceneDevicesList; + } + public static void main(String[] args) { + String property = ConfigReader.getProperty("industry_code"); + System.out.println(property); + } } diff --git a/dntd-model-metalkiln/src/main/resources/modelCode.properties b/dntd-model-metalkiln/src/main/resources/modelCode.properties index e9fc024..f374d6e 100644 --- a/dntd-model-metalkiln/src/main/resources/modelCode.properties +++ b/dntd-model-metalkiln/src/main/resources/modelCode.properties @@ -1 +1 @@ -industry_code=21 \ No newline at end of file +industry_code=3200 \ No newline at end of file diff --git a/dntd-tool/pom.xml b/dntd-tool/pom.xml index 59b6d78..58e3ac6 100644 --- a/dntd-tool/pom.xml +++ b/dntd-tool/pom.xml @@ -62,6 +62,12 @@ 1.0-SNAPSHOT compile + + com.dky + dntd-model-metalkiln + 1.0-SNAPSHOT + compile + @@ -70,6 +76,7 @@ true *.properties + **/*.json diff --git a/dntd-tool/src/main/java/com/dky/generate/KitchenCookScene.java b/dntd-tool/src/main/java/com/dky/generate/KitchenCookScene.java index efba660..0a7156b 100644 --- a/dntd-tool/src/main/java/com/dky/generate/KitchenCookScene.java +++ b/dntd-tool/src/main/java/com/dky/generate/KitchenCookScene.java @@ -1,7 +1,10 @@ package com.dky.generate; import cn.hutool.json.JSONObject; -import com.dky.calculate.*; +import com.dky.calculate.Advantage; +import com.dky.calculate.BuildHeatingAdvantage; +import com.dky.calculate.KitchenCookModel; +import com.dky.calculate.KitchenCookScheme; import com.dky.modelI.DntdModelI; import com.dky.utils.GetTargetDeviceList; import com.dky.utils.entity.SysDeviceHeatScene; @@ -12,7 +15,6 @@ import java.text.DecimalFormat; import java.util.ArrayList; import java.util.HashMap; import java.util.List; -import java.util.Map; public class KitchenCookScene implements DntdModelI { @@ -127,6 +129,7 @@ public class KitchenCookScene implements DntdModelI { returnJsonObject.set("intelligence", BuildHeatingAdvantage.intelligence()); returnJsonObject.set("environment", BuildHeatingAdvantage.environment(Double.valueOf(decimalFormat.format(calculateAnnualCarbon/1000)))); + return returnJsonObject; } diff --git a/dntd-tool/src/main/java/com/dky/generate/MetalKilnScene.java b/dntd-tool/src/main/java/com/dky/generate/MetalKilnScene.java new file mode 100644 index 0000000..8a3a691 --- /dev/null +++ b/dntd-tool/src/main/java/com/dky/generate/MetalKilnScene.java @@ -0,0 +1,139 @@ +package com.dky.generate; + +import calculate.MetalKilnScheme; +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.Collections; +import java.util.HashMap; +import java.util.List; + +public class MetalKilnScene 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.Metal_Kiln.getDesc(), list); + + 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()); + // 工作容积(单位: m³)【 1 立方米=1000 升 】 + Double workArea = Double.parseDouble(heatUseNeedInfo.get("workArea").toString()) / 1000; + // 预计年产量（吨） + Double yearOutPut = Double.parseDouble(heatUseNeedInfo.get("yearOutPut").toString()); + // 温度要求（摄氏度） + Double needTemp = Double.parseDouble(heatUseNeedInfo.get("needTemp").toString()); + // 用户所属行业编码 + String userIndustry = jsonObject.get("userIndustry").toString(); + // 上年运行费用（元） + Double lastYearFee = Double.parseDouble(originalDevInfo.get("lastYearFee").toString()); + + // 根据供热需量设备功率计算出不同技术类型下所需要不同功率设备数据 + List schemeList = MetalKilnScheme.getSchemeList(userIndustry, needTemp, alternateDeviceList); + List matchedDeviceGroupList = MetalKilnScheme.calSchemeByTechType(workArea, schemeList); + + // 实际可承载容量A = 运行（或合同容量）x0.9 [将运行容量或合同容量折算成容量] x85% + double A = runCapacity * COEFFICIENT_1 * COEFFICIENT_2; + // 根据供热需量设备功率计算每个技术类型下需要的不同功率的设备的数量，然后将不同功率及对应的数量进行计算得出总功率C1，取最大 + Double C1 = CalC.getC1(Collections.singletonList(matchedDeviceGroupList)); + + // 改造后最大需量 + double D1 = lastYearNeed + C1; + + String remark = ""; + + // 同时考虑热泵和电锅炉 + if (A < D1) { + remark = "本方案存在扩容投资需求，扩容投资不计入初次投资费用"; + } + + + /* + 封装返回 + */ + JSONObject returnJsonObject = new JSONObject(); + Double startCost = 0.0; + Double runCost = 0.0; + Double allCost = 0.0; + Double calculateAnnualCarbon = 0.0; + Double laborFee1 = 0.0; + Double electric = 0.0; + List> deviceList = new ArrayList<>(); + for (MatchedDevice matchedDevice : matchedDeviceGroupList) { + 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 + (MaterialKilnModel.calculateAnnualOperatingCost(matchedDevice.getDeviceHeatScene().getDevPower(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevSubstituteLaborCost(), matchedDevice.getDeviceHeatScene().getDevAnnualOperationTime())); + + allCost = allCost + (MaterialKilnModel.calculateAnnualTotalCost(matchedDevice.getDeviceHeatScene().getDevPower(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevSubstituteLaborCost(), + matchedDevice.getDeviceHeatScene().getDevAnnualOperationTime(), matchedDevice.getDeviceHeatScene().getDevPrice(), matchedDevice.getDeviceHeatScene().getDevServiceLife())); + + electric = electric + (MaterialKilnModel.calculateSubstituteElectricity(matchedDevice.getDeviceHeatScene().getDevPower(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevAnnualOperationTime())); + + laborFee1 = laborFee1 + (matchedDevice.getCount() * matchedDevice.getDeviceHeatScene().getLaborCost() / matchedDevice.getDeviceHeatScene().getDevServiceLife()); + + } + //初次投资费用 + 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 = MaterialKilnModel.calculateAnnualCarbonReduction(lastYearFee, laborFee1, 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)))); + + + return returnJsonObject; + } + + +} diff --git a/dntd-tool/src/main/java/com/dky/stirtpar/StirparModelCalculate.java b/dntd-tool/src/main/java/com/dky/stirtpar/StirparModelCalculate.java new file mode 100644 index 0000000..9f98c95 --- /dev/null +++ b/dntd-tool/src/main/java/com/dky/stirtpar/StirparModelCalculate.java @@ -0,0 +1,146 @@ +package com.dky.stirtpar; + + +import cn.hutool.json.JSONObject; +import com.dky.modelI.DntdModelI; +import com.dky.utils.CalculateUtils; +import com.dky.utils.entity.SysDeviceHeatScene; + +import java.io.BufferedReader; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.text.DecimalFormat; +import java.util.List; + +public class StirparModelCalculate implements DntdModelI { + + DecimalFormat df = new DecimalFormat("#.00"); + + /** + * 计算热源消耗总量 + * @param provinceCode 省份编码 + * @param peopleNum 人口 + * @param averageGdp 人均GDP + * @param U 城市化率 + * @param I 工业增加值 + * @param II 工业能源强度 + * @return + */ + public static Double energyConsumeStirCoefficient(String provinceCode, Integer peopleNum, Double averageGdp, Double U, Double I, Double II) { + JSONObject jo = (JSONObject) toJSON("energyConsumeStirpatCoefficient.json").get(provinceCode); + Double a = Double.parseDouble(jo.get("a").toString()); + Double b1 = Double.parseDouble(jo.get("b1").toString()); + Double b2 = Double.parseDouble(jo.get("b2").toString()); + Double b3 = Double.parseDouble(jo.get("b3").toString()); + Double b4 = Double.parseDouble(jo.get("b4").toString()); + Double b5 = Double.parseDouble(jo.get("b5").toString()); + Double b6 = Double.parseDouble(jo.get("b6").toString()); + Double e = Double.parseDouble(jo.get("e").toString()); + + Double add1 = CalculateUtils.add(a, b1 * Math.log(peopleNum)); + Double add2 = CalculateUtils.add(add1, b2 * Math.log(U)); + Double add3 = CalculateUtils.add(add2, b3 * Math.log(averageGdp)); + Double add4 = CalculateUtils.add(add3, b4 * Math.pow(Math.log(averageGdp), 2)); + Double add5 = CalculateUtils.add(add4, b5 * Math.log(I)); + Double add6 = CalculateUtils.add(add5, b6 * Math.log(II)); + Double add7 = CalculateUtils.add(add6, e); + + return Math.round(Math.exp(add7) * 100) / 100.0; + } + + /** + * 计算电耗消耗总量 + * @param provinceCode 省份编码 + * @param CT 能源消耗量 + * @param peopleNum 人口 + * @param averageGdp 人均GDP + * @param U 城市化率 + * @param PR 电力价格 + * @param T 年均温度 + * @return + */ + public static Double electricConsumeStirCoefficient(String provinceCode, Double CT, Integer peopleNum, Double averageGdp, Double U, Double PR, Double T) { + JSONObject jo = (JSONObject) toJSON("electricConsumeStirpatCoefficient.json").get(provinceCode); + Double a = Double.parseDouble(jo.get("a").toString()); + Double b1 = Double.parseDouble(jo.get("b1").toString()); + Double b2 = Double.parseDouble(jo.get("b2").toString()); + Double b3 = Double.parseDouble(jo.get("b3").toString()); + Double b4 = Double.parseDouble(jo.get("b4").toString()); + Double b5 = Double.parseDouble(jo.get("b5").toString()); + Double b6 = Double.parseDouble(jo.get("b6").toString()); + Double b7 = Double.parseDouble(jo.get("b7").toString()); + Double e = Double.parseDouble(jo.get("e").toString()); + + Double add1 = CalculateUtils.add(a, b1 * Math.log(CT)); + Double add2 = CalculateUtils.add(add1, b2 * Math.log(peopleNum)); + Double add3 = CalculateUtils.add(add2, b3 * Math.log(U)); + Double add4 = CalculateUtils.add(add3, b4 * Math.log(U)); + Double add5 = CalculateUtils.add(add4, b5 * Math.log(averageGdp)); + Double add6 = CalculateUtils.add(add5, b6 * Math.log(PR)); + Double add7 = CalculateUtils.add(add6, b7 * Math.log(T)); + Double add8 = CalculateUtils.add(add7, e); + + return Math.round(Math.exp(add8) * 100) / 100.0; + } + + + + public static JSONObject toJSON(String fileName) { + // 使用ClassLoader的getResourceAsStream方法读取资源文件 + InputStream inputStream = StirparModelCalculate.class.getClassLoader().getResourceAsStream(fileName); + if (inputStream == null) { + System.out.println("读取文件失败"); + } + // 使用BufferedReader读取InputStream中的内容 + BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)); + StringBuilder stringBuilder = new StringBuilder(); + String currentLine; + try { + while ((currentLine = reader.readLine()) != null) { + stringBuilder.append(currentLine); + } + } catch (Exception e) { + e.printStackTrace(); + } + // 关闭BufferedReader + try { + reader.close(); + } catch (Exception e) { + e.printStackTrace(); + } + + return new JSONObject(stringBuilder.toString()); + } + + + + @Override + public JSONObject createReport(JSONObject jsonObject, List alternateDeviceList) { + JSONObject electricInfo = new JSONObject(); + JSONObject energyInfo = new JSONObject(); + + try { + energyInfo = (JSONObject) jsonObject.get("energyInfo"); + electricInfo = (JSONObject) jsonObject.get("electricInfo"); + } catch (Exception e) { + e.printStackTrace(); + } + + String provinceCode = jsonObject.get("provinceCode").toString(); + Integer peopleNum = Integer.parseInt(new DecimalFormat("#").format(energyInfo.get("peopleNum"))); + Double averageGdp = Double.parseDouble(energyInfo.get("averageGdp").toString()); + Double U = Double.parseDouble(energyInfo.get("ut").toString()); + Double I = Double.parseDouble(energyInfo.get("i1").toString()); + Double II = Double.parseDouble(energyInfo.get("i2").toString()); + Double PR = Double.parseDouble(electricInfo.get("PR").toString()); + Double CT = Double.parseDouble(electricInfo.get("CT").toString()); + Double T = Double.parseDouble(electricInfo.get("T").toString()); + + JSONObject resultJsonObject = new JSONObject(); + resultJsonObject.put("CT", df.format(energyConsumeStirCoefficient(provinceCode, peopleNum, averageGdp, U, I, II))); + resultJsonObject.put("CE", df.format(electricConsumeStirCoefficient(provinceCode, CT, peopleNum, averageGdp, U, PR, T))); + + return resultJsonObject; + } +} 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 06b6185..0aaaa58 100644 --- a/dntd-tool/src/main/java/com/dky/test/TestMain.java +++ b/dntd-tool/src/main/java/com/dky/test/TestMain.java @@ -31,15 +31,17 @@ public class TestMain { mafwefaefwaefawfapList.add(fawdfweawerwgggawfg); JSONObject param = new JSONObject(); - param.put("type", "0102"); + param.put("type", "0105"); /*param.put("lastYearFee", 500000.2); param.put("peopleNum", 88);*/ + param.put("userIndustry", "3200"); param.put("distInfo", new JSONObject() .put("runCapacity", 2400.0) .put("lastYearNeed", 1600.0)); - /*param.put("heatUseNeedInfo", new JSONObject() + param.put("heatUseNeedInfo", new JSONObject() .put("workArea", 11800) - .put("yearOutPut", 1000000.0));*/ + .put("needTemp", 888.987) + .put("yearOutPut", 1000000.0)); /*param.put("heatUseNeedInfo", new JSONObject() .put("heatingNeedPower", 33) .put("thermometerValueOut", 100.8));*/ @@ -50,12 +52,19 @@ public class TestMain { .put("days", 185) .put("heatingArea", 47639) .put("lastYearFee", 3000000));*/ - param.put("heatUseNeedInfo", new JSONObject() - .put("heatingNeedPower", 33) - .put("thermometerValueOut", 112.45)); param.put("originalDevInfo", new JSONObject() .put("previousYearEnergyUsage", 24090000) .put("lastYearFee", 3000000)); + /*param.put("energyInfo", new JSONObject() + .put("ut", 1180.0) + .put("i1", 888.987) + .put("i2", 1000.0) + .put("peopleNum", 10000000.0) + .put("averageGdp", 10000.0)); + param.put("electricInfo", new JSONObject() + .put("PR", 11800) + .put("CT", 12444888.987) + .put("T", 1000000.0));*/ String key = "BPTfj7kSlu6fJHpn/t2IQ1R83MPuA3sjgySntyYRo8GEgUNnTYoxaOX2FTK+X/bPllVx8Ly4/1l2FUb9JwRRbzbMPIdIfal7qO4ftJKJTN1M555BUSyGUOEBHivrarFiliiwnZH5dD4YV+kRUUD70o/1zEysm5M6/FrzXebRcH9EsnLEGta9D+urvisjamjQmunV3razxlsd+SYvbSsYmDRp8QjbJLpkfrlJBL484cB5Nhj8XWx8IZb3lvINkkq+"; // 构建JSONObject对象 @@ -144,6 +153,18 @@ public class TestMain { {66, "电窑炉", "建材电窑炉", "建材电窑炉", null, 25, 26000.00, 60000.00, 180000.00, null, 15, 4500, null, null,0.20,2500.00,500.00,4.00}, {67, "电窑炉", "建材电窑炉", "建材电窑炉", null, 145, 140000.00, 60000.00, 180000.00, null, 15, 4500, null, null,1.50,2500.00,3750.00,4.00}, {68, "电窑炉", "建材电窑炉", "建材电窑炉", null, 300, 250000.00, 60000.00, 180000.00, null, 15, 4500, null, null,3.00,2500.00,7500.00,4.00}, + {69, "电窑炉", "冶金窑炉", "直接加热电阻炉", null, 25, 26000.00, 60000.00, 180000.00, null, 15, 4500, null, null,0.20,7800.00,1560.00,4.00}, + {70, "电窑炉", "冶金窑炉", "直接加热电阻炉", null, 145, 140000.00, 60000.00, 180000.00, null, 15, 4500, null, null,1.50,7800.00,11700.00,4.00}, + {71, "电窑炉", "冶金窑炉", "直接加热电阻炉", null, 300, 250000.00, 60000.00, 180000.00, null, 15, 4500, null, null,3.00,7800.00,23400.00,4.00}, + {72, "电窑炉", "冶金窑炉", "间接加热电阻炉（钟罩式光亮退火炉)", null, 25, 60000.00, 60000.00, 180000.00, null, 15, 4500, null, null,0.20,7800.00,1560.00,4.00}, + {73, "电窑炉", "冶金窑炉", "间接加热电阻炉（钟罩式光亮退火炉)", null, 145, 250000.00, 60000.00, 180000.00, null, 15, 4500, null, null,1.50,7800.00,11700.00,4.00}, + {74, "电窑炉", "冶金窑炉", "间接加热电阻炉（钟罩式光亮退火炉)", null, 300, 450000.00, 60000.00, 180000.00, null, 15, 4500, null, null,3.00,7800.00,23400.00,4.00}, + {75, "电窑炉", "冶金窑炉", "电弧炉（钢包精炼LF炉）", null, 25, 28000.00, 60000.00, 180000.00, null, 15, 4500, null, null,0.20,7800.00,1560.00,4.00}, + {76, "电窑炉", "冶金窑炉", "电弧炉（钢包精炼LF炉）", null, 145, 150000.00, 60000.00, 180000.00, null, 15, 4500, null, null,1.50,7800.00,11700.00,4.00}, + {77, "电窑炉", "冶金窑炉", "电弧炉（钢包精炼LF炉）", null, 300, 260000.00, 60000.00, 180000.00, null, 15, 4500, null, null,3.00,7800.00,23400.00,4.00}, + {78, "电窑炉", "冶金窑炉", "中/高频感应电炉", null, 25, 40000.00, 60000.00, 180000.00, null, 15, 4500, null, null,0.20,7800.00,1560.00,4.00}, + {79, "电窑炉", "冶金窑炉", "中/高频感应电炉", null, 145, 190000.00, 60000.00, 180000.00, null, 15, 4500, null, null,1.50,7800.00,11700.00,4.00}, + {80, "电窑炉", "冶金窑炉", "中/高频感应电炉", null, 300, 270000.00, 60000.00, 180000.00, null, 15, 4500, null, null,3.00,7800.00,23400.00,4.00}, }; // 创建对象并添加到列表 diff --git a/dntd-tool/src/main/resources/electricConsumeStirpatCoefficient.json b/dntd-tool/src/main/resources/electricConsumeStirpatCoefficient.json new file mode 100644 index 0000000..02fcefe --- /dev/null +++ b/dntd-tool/src/main/resources/electricConsumeStirpatCoefficient.json @@ -0,0 +1,46 @@ +{ + "110000": { + "a": 1, + "b1": 2, + "b2": 3, + "b3": 4, + "b4": 5, + "b5": 6, + "b6": 7, + "b7": 9, + "e": 8 + }, + "120000": { + "a": 1, + "b1": 2, + "b2": 3, + "b3": 4, + "b4": 5, + "b5": 6, + "b6": 7, + "b7": 9, + "e": 8 + }, + "310000": { + "a": 1, + "b1": 2, + "b2": 3, + "b3": 4, + "b4": 5, + "b5": 6, + "b6": 7, + "b7": 9, + "e": 8 + }, + "500000": { + "a": 1, + "b1": 2, + "b2": 3, + "b3": 4, + "b4": 5, + "b5": 6, + "b6": 7, + "b7": 9, + "e": 8 + } +} \ No newline at end of file diff --git a/dntd-tool/src/main/resources/energyConsumeStirpatCoefficient.json b/dntd-tool/src/main/resources/energyConsumeStirpatCoefficient.json new file mode 100644 index 0000000..a6b84f9 --- /dev/null +++ b/dntd-tool/src/main/resources/energyConsumeStirpatCoefficient.json @@ -0,0 +1,42 @@ +{ + "110000": { + "a": 1, + "b1": 2, + "b2": 3, + "b3": 4, + "b4": 5, + "b5": 6, + "b6": 7, + "e": 8 + }, + "120000": { + "a": 1, + "b1": 2, + "b2": 3, + "b3": 4, + "b4": 5, + "b5": 6, + "b6": 7, + "e": 8 + }, + "310000": { + "a": 1, + "b1": 2, + "b2": 3, + "b3": 4, + "b4": 5, + "b5": 6, + "b6": 7, + "e": 8 + }, + "500000": { + "a": 1, + "b1": 2, + "b2": 3, + "b3": 4, + "b4": 5, + "b5": 6, + "b6": 7, + "e": 8 + } +} \ No newline at end of file diff --git a/dntd-tool/src/main/resources/modelCode.properties b/dntd-tool/src/main/resources/modelCode.properties index e858cfb..dda7bc4 100644 --- a/dntd-tool/src/main/resources/modelCode.properties +++ b/dntd-tool/src/main/resources/modelCode.properties @@ -1,4 +1,6 @@ 0101=generate.BuildHeatingScene 0102=generate.HeatBoilerScene 0103=generate.KitchenCookScene -0104=generate.MaterialKilnScene \ No newline at end of file +0104=generate.MaterialKilnScene +0105=generate.MetalKilnScene +0106=stirtpar.StirparModelCalculate \ No newline at end of file