hwj_system
/
dntd-model-tools
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

重构模型算法

Browse Source
master
林颖晨 1 year ago
parent 470756724a
commit d47245ab74
9 changed files with 477 additions and 245 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 64
      dntd-model-buildheating/src/main/java/com/dky/calculate/Scheme.java
  2. 138
      dntd-model-buildheating/src/main/java/com/dky/calculate/SchemeRating.java
  3. 6
      dntd-modelI/pom.xml
  4. 6
      dntd-modelI/src/main/java/com/dky/modelI/DntdModelI.java
  5. 197
      dntd-tool/src/main/java/com/dky/generate/BuildHeatingScene.java
  6. 154
      dntd-tool/src/main/java/com/dky/generate/BuildHeatingSence.java
  7. 4
      dntd-tool/src/main/java/com/dky/generate/HeatBoilerSence.java
  8. 126
      dntd-tool/src/main/java/com/dky/test/TestMain.java
  9. 27
      dntd-tool/src/main/java/com/dky/tool/ModelTool.java

64
dntd-model-buildheating/src/main/java/com/dky/calculate/Scheme.java
Unescape View File

@ -4,56 +4,68 @@ package com.dky.calculate;
import com.dky.utils.entity.SysDeviceHeatScene;
import com.dky.utils.result.MatchedDevice;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
public class Scheme {
public static List<Map<String, List<List<MatchedDevice>>>> calScheme(Double buildArea, List<SysDeviceHeatScene> list) {
// 区分电锅炉、热泵
Map<String, List<SysDeviceHeatScene>> grouped = list.stream()
/**
* 根据设备细类筛选出不同技术类型的不同功率设备需要的数量
* List<MatchedDevice> 同一个技术类型下的设备列表以及每个设备所需要的台数
* Map<String, List<List<MatchedDevice>>> 键为设备细类
*
* @param buildArea 建筑面积
* @param sysDeviceHeatSceneList 替代设备列表
* @return
*/
public static List<List<MatchedDevice>> calScheme(Double buildArea, List<SysDeviceHeatScene> sysDeviceHeatSceneList) {
// 根据设备细类筛选出一个以设备细类为键，该细类下设备列表为值的Map
Map<String, List<SysDeviceHeatScene>> groupByDevSubTypeMap = sysDeviceHeatSceneList.stream()
.collect(Collectors.groupingBy(SysDeviceHeatScene::getDevSubType));
List<Map<String, List<List<MatchedDevice>>>> maps = new ArrayList<>();
// 区分技术类型
grouped.forEach((k, v) -> {
Map<String, List<List<MatchedDevice>>> map = new HashMap<>();
List<List<MatchedDevice>> planList = new ArrayList<>();
Map<String, List<SysDeviceHeatScene>> collect = v.stream().collect(Collectors.groupingBy(SysDeviceHeatScene::getDevTechType));
collect.forEach((k2, v2) -> {
List<MatchedDevice> matchedDevices = calSchemeByTechType(buildArea, v2);
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(buildArea, devList);
planList.add(matchedDevices);
});
map.put(k, planList);
maps.add(map);
});
return maps;
return planList;
}
public static List<MatchedDevice> calSchemeByTechType(Double buildArea, List<SysDeviceHeatScene> list) {
// 对List按照单台设备可参考供暖面积进行排序
list.sort((o1, o2) -> Double.compare(o2.getDevReferenceArea(), o1.getDevReferenceArea()));
/**
* 根据建筑面积和其中一个设备细类-技术类型下的不同功率的设备，计算出该技术类型分别需要不同功率的设备的的数量
*
* @param buildArea 建筑面积
* @param sysDeviceHeatSceneList 不同设备细类-技术类型下的设备列表
* @return 不同功率的设备对应所需要的数量
*/
public static List<MatchedDevice> calSchemeByTechType(Double buildArea, List<SysDeviceHeatScene> sysDeviceHeatSceneList) {
// 对技术类型下的设备list按照单台设备可参考供暖面积进行排序
sysDeviceHeatSceneList.sort((o1, o2) -> Double.compare(o2.getDevReferenceArea(), o1.getDevReferenceArea()));
Double remainArea = buildArea;
// 遍历设备，根据建筑面积进行匹配设备数量
List<MatchedDevice> matchedDeviceList = new ArrayList<>();
for (SysDeviceHeatScene deviceHeatScene : list) {
for (SysDeviceHeatScene deviceHeatScene : sysDeviceHeatSceneList) {
double v = remainArea / deviceHeatScene.getDevReferenceArea();
int count = (int) (v);
if (v < 1){
if (v < 1) {
count = count + 1;
}
remainArea = remainArea - count * deviceHeatScene.getDevReferenceArea();
matchedDeviceList.add(new MatchedDevice(count, deviceHeatScene));
if (remainArea <= 0){
if (remainArea <= 0) {
// 当总供暖面积已经满足需求时，跳出循环，不再选择其他设备
break;
}
}
return matchedDeviceList;
}
}

138
dntd-model-buildheating/src/main/java/com/dky/calculate/SchemeRating.java
Unescape View File

@ -1,6 +1,7 @@
package com.dky.calculate;
import com.dky.utils.entity.SysDeviceHeatScene;
import com.dky.utils.result.MatchedDevice;
import java.util.*;
@ -9,38 +10,27 @@ import java.util.concurrent.atomic.AtomicReference;
public class SchemeRating {
/**
* 计算效率和成本评分
* 计算每一种方案的效率和成本评分
* @param list
* @return
*/
public static Map<Double, List<MatchedDevice>> getOptimalList(List<Map<String, List<List<MatchedDevice>>>> list,Double costRatio,Double effRatio) {
public static Map<Double, List<MatchedDevice>> getOptimalList(List<List<MatchedDevice>> list,Double costRatio,Double effRatio,Map<String,Double> maxEff,Map<String,Double> minPrice) {
Map<Double, List<MatchedDevice>> optimalMap = new HashMap<>();
list.parallelStream().forEach(stringListMap -> {
// 区分热泵、电锅炉
stringListMap.forEach((k,v)->{
// 循环遍历各个方案
v.parallelStream().forEach((plan)->{
AtomicReference<Double> rating = new AtomicReference<>(0.0);
List<Map<String, Double[]>> maps = getIndex(list);
for (Map<String, Double[]> map : maps) {
map.forEach((k1, v1) -> {
if (k1.equals(k)){
Double eff = 0.0;
Double cost = 0.0;
for (MatchedDevice device : plan) {
eff = device.getDeviceHeatScene().getHeatEfficiency();
}
for (MatchedDevice device : plan) {
cost = cost + ((device.getCount() * device.getDeviceHeatScene().getDevPrice()) + (device.getCount()) * device.getDeviceHeatScene().getDevSubstituteLaborCost() * device.getDeviceHeatScene().getDevServiceLife());
}
//3、效率成本公式：（1-（选择效率最大-当前值）/效率最大值）*100*0.8 +（1-（当前值-选择成本最小）/成本最小值）*100*0.2。
rating.set(((1 - ((v1[0] - eff) / v1[0])) * 100 * effRatio) + ((1 - ((cost - v1[1]) / v1[1])) * 100 * costRatio));
optimalMap.put(rating.get(), plan);
}
});
}
});
});
list.forEach(plan->{
AtomicReference<Double> rating = new AtomicReference<>(0.0);
String devSubType = plan.get(0).getDeviceHeatScene().getDevSubType();
Double eff = 0.0;
Double cost = 0.0;
for (MatchedDevice device : plan) {
eff = device.getDeviceHeatScene().getHeatEfficiency();
}
for (MatchedDevice device : plan) {
cost = cost + ((device.getCount() * device.getDeviceHeatScene().getDevPrice()) + (device.getCount()) * device.getDeviceHeatScene().getDevSubstituteLaborCost() * device.getDeviceHeatScene().getDevServiceLife());
}
//3、（1-（选择对应设备细类的效率最大的效率值（效率最大值）-当前设备的效率值值）/效率最大值）*100*系数 +（1-（当前成本值-对应设备细类的成本最小值）/对应设备细类的成本最小值）*100*0.2。取最高得分。
rating.set(((1 - ((maxEff.get(devSubType) - eff) / maxEff.get(devSubType))) * 100 * effRatio) + ((1 - ((cost - minPrice.get(devSubType)) / minPrice.get(devSubType))) * 100 * costRatio));
optimalMap.put(rating.get(), plan);
});
return optimalMap;
}
@ -62,36 +52,72 @@ public class SchemeRating {
return map.get(maxValue);
}
public static List<Map<String, Double[]>> getIndex(List<Map<String, List<List<MatchedDevice>>>> list) {
List<Map<String, Double[]>> maps = new ArrayList<>();
list.parallelStream().forEach(stringListMap -> {
// 区分热泵、电锅炉
stringListMap.forEach((k, v) -> {
// 循环遍历各个方案
// 热效率、成本
final Double[] index = {0.0, Double.MAX_VALUE};
v.parallelStream().forEach((plan) -> {
Double eff = 0.0;
Double cost = 0.0;
for (MatchedDevice device : plan) {
eff = device.getDeviceHeatScene().getHeatEfficiency();
}
for (MatchedDevice device : plan) {
cost = cost + ((device.getCount() * device.getDeviceHeatScene().getDevPrice()) + (device.getCount()) * device.getDeviceHeatScene().getDevSubstituteLaborCost() * device.getDeviceHeatScene().getDevServiceLife());
}
if (eff >= index[0]) {
index[0] = eff;
}
if (cost <= index[1]) {
index[1] = cost;
}
});
Map<String, Double[]> map = new HashMap<>();
map.put(k, index);
maps.add(map);
});
/**
* 获取不同设备细类下的效率最大值
* @param alternateDeviceList 可替代设备列表
* @return 不同设备细类下的效率最大值map
*/
public static Map<String,Double> getMaxEfficiencyGroupByDevSubType( List<SysDeviceHeatScene> alternateDeviceList){
Map<String,Double> map = new HashMap<>();
alternateDeviceList.forEach(alternateDevice ->{
String devSubType = alternateDevice.getDevSubType();
Double v = map.get(devSubType);
if ( v == null){
map.put(devSubType,alternateDevice.getHeatEfficiency());
} else {
if( alternateDevice.getHeatEfficiency() > v){
map.put(devSubType,alternateDevice.getHeatEfficiency());
}
}
});
return map;
}
/**
* 获取不同设备细类下的成本最小值
* @param alternateDeviceList 可替代设备列表
* @return 不同设备细类下的成本最小值map
*/
public static Map<String,Double> getMinPriceGroupByDevSubType( List<SysDeviceHeatScene> alternateDeviceList){
Map<String,Double> map = new HashMap<>();
alternateDeviceList.forEach(alternateDevice -> {
String devSubType = alternateDevice.getDevSubType();
Double v = map.get(devSubType);
if ( v == null){
map.put(devSubType,alternateDevice.getDevPrice()+ alternateDevice.getDevSubstituteLaborCost()*alternateDevice.getDevServiceLife());
} else {
if( alternateDevice.getDevPrice() < v){
map.put(devSubType,alternateDevice.getDevPrice() + alternateDevice.getDevSubstituteLaborCost()*alternateDevice.getDevServiceLife());
}
}
});
return map;
}
public static List<Map<String, Double[]>> getIndex(List<List<MatchedDevice>> list) {
List<Map<String, Double[]>> maps = new ArrayList<>();
final Double[] index = {0.0, Double.MAX_VALUE};
Map<String, Double[]> map = new HashMap<>();
list.parallelStream().forEach((plan) -> {
Double eff = 0.0;
Double cost = 0.0;
for (MatchedDevice device : plan) {
eff = device.getDeviceHeatScene().getHeatEfficiency();
}
for (MatchedDevice device : plan) {
cost = cost + ((device.getCount() * device.getDeviceHeatScene().getDevPrice()) + (device.getCount()) * device.getDeviceHeatScene().getDevSubstituteLaborCost() * device.getDeviceHeatScene().getDevServiceLife());
}
if (eff >= index[0]) {
index[0] = eff;
}
if (cost <= index[1]) {
index[1] = cost;
}
map.put(plan.get(0).getDeviceHeatScene().getDevSubType(), index);
maps.add(map);
});
return maps;
}

6
dntd-modelI/pom.xml
Unescape View File

@ -22,6 +22,12 @@
<artifactId>hutool-all</artifactId>
<version>5.4.5</version>
</dependency>
<dependency>
<groupId>com.dky</groupId>
<artifactId>dntd-common</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>

6
dntd-modelI/src/main/java/com/dky/modelI/DntdModelI.java
Unescape View File

@ -1,7 +1,11 @@
package com.dky.modelI;
import cn.hutool.json.JSONObject;
import com.dky.utils.entity.SysDeviceHeatScene;
import java.util.List;
public interface DntdModelI {
JSONObject createReport(JSONObject jsonObject);
JSONObject createReport(JSONObject jsonObject, List<SysDeviceHeatScene> alternateDeviceList);
}

197
dntd-tool/src/main/java/com/dky/generate/BuildHeatingScene.java
Unescape View File

@ -0,0 +1,197 @@
package com.dky.generate;
import cn.hutool.json.JSONObject;
import com.dky.calculate.BuildHeatingAdvantage;
import com.dky.calculate.BuildHeatingModel;
import com.dky.calculate.Scheme;
import com.dky.calculate.SchemeRating;
import com.dky.modelI.DntdModelI;
import com.dky.utils.entity.SysDeviceHeatScene;
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 BuildHeatingScene 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> alternateDeviceList) {
JSONObject distInfo = new JSONObject();
JSONObject buildInfo = new JSONObject();
JSONObject originalDevInfo = new JSONObject();
try{
distInfo = (JSONObject) jsonObject.get("distInfo");
buildInfo = (JSONObject) jsonObject.get("buildInfo");
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());
// 建筑面积
Double heatingArea = Double.parseDouble(buildInfo.get("heatingArea").toString());
// 年采暖时间(天)
Integer days = Integer.parseInt(buildInfo.get("days").toString());
// 上年运行费用（万元）
Double lastYearFee = Double.parseDouble(buildInfo.get("lastYearFee").toString());
/*
实际可承载容量A = 运行（或合同容量）x0.9[将运行容量或合同容量折算成容量]x85%
*/
double A = runCapacity * COEFFICIENT_1 * COEFFICIENT_2;
/*
替代前设备总功率C
*/
Double C = 0.0;
if (originalDevInfo != null) {
//若存在原设备信息，则获取原设备中设备总功率，累加得出C
} else {
// C=建筑面积（万平方米）x770
C = (heatingArea / 10000) * 770;
}
/*
根据建筑面积计算出不同技术类型下所需要不同功率设备数据
*/
List<List<MatchedDevice>> matchedDeviceGroupList = Scheme.calScheme(heatingArea, alternateDeviceList);
/*
替代后设备总功率C1
*/
double C1 = 0.0;
if (originalDevInfo != null){
//若存在原设备信息，则根据建筑面积计算每个技术类型下需要的不同功率的设备的数量，然后将不同功率及对应的数量进行计算得出总功率C1
} else {
C1 = C/2.5;
}
/*
改造前最大需量D
*/
double D = lastYearNeed + C;
/*
改造后最大需量D1
*/
double D1 = lastYearNeed + C1;
/*
判断计算占比，默认效率0.8，成本0.2
*/
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<Double, List<MatchedDevice>> listMap ;
/*
根据具体容量与需量判断可使用的技术并计算评分
*/
//计算不同细类下成本最小值与效率最大值
Map<String, Double> maxEffMap = SchemeRating.getMaxEfficiencyGroupByDevSubType(alternateDeviceList);
Map<String, Double> minPriceMap = SchemeRating.getMinPriceGroupByDevSubType(alternateDeviceList);
String remark = "";
if (D1 < A && A < D) {
// 判断只能用热泵
List<List<MatchedDevice>> heatPumpDevList = new ArrayList<>();
matchedDeviceGroupList.forEach((matchedDevices -> {
MatchedDevice matchedDevice = matchedDevices.get(0);
if (!"供冷/暖电锅炉".equals(matchedDevice.getDeviceHeatScene().getDevSubType())){
heatPumpDevList.add(matchedDevices);
}
}));
listMap = SchemeRating.getOptimalList(heatPumpDevList,costRatio,effRatio,maxEffMap,minPriceMap);
matchedDeviceList = SchemeRating.getOptimalScheme(listMap);
} else {
//同时考虑热泵和电锅炉
if ( A < D1){
remark = "本方案存在扩容投资需求，扩容投资不计入初次投资费用";
}
listMap = SchemeRating.getOptimalList(matchedDeviceGroupList,costRatio,effRatio,maxEffMap,minPriceMap);
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(k));
map.put("plan", v);
map.put("planName", v.get(0).getDeviceHeatScene().getDevTechType());
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 + (BuildHeatingModel.getRunCost(matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevPower(), days, matchedDevice.getDeviceHeatScene().getDevSubstituteLaborCost()));
allCost = allCost + (BuildHeatingModel.getYearCost(matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevPrice(), matchedDevice.getDeviceHeatScene().getDevServiceLife(), matchedDevice.getDeviceHeatScene().getDevPower(), days, matchedDevice.getDeviceHeatScene().getDevSubstituteLaborCost()));
calculateAnnualCarbon = calculateAnnualCarbon + (BuildHeatingModel.calculateAnnualCarbonReduction(lastYearFee, matchedDevice.getDeviceHeatScene().getLaborCost(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevPower(), days));
electric = electric + (BuildHeatingModel.getElectric(matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevPower(), days));
}
//初次投资费用
returnJsonObject.set("startCost", decimalFormat.format(startCost));
//年运行费用
returnJsonObject.set("yearRunCost", decimalFormat.format(runCost));
//年总费用
returnJsonObject.set("yearCost", decimalFormat.format(allCost));
//年减碳量
returnJsonObject.set("calculate", decimalFormat.format(calculateAnnualCarbon));
//替代电量
returnJsonObject.set("electric", decimalFormat.format(electric));
//备注
returnJsonObject.set("remark",remark);
//封装需配置设备情况
returnJsonObject.set("deviceList",deviceList);
//封装方案优势
returnJsonObject.set("safety", BuildHeatingAdvantage.safety());
returnJsonObject.set("economy", BuildHeatingAdvantage.economy(startCost, allCost, runCost, lastYearFee));
returnJsonObject.set("intelligence", BuildHeatingAdvantage.intelligence());
returnJsonObject.set("environment", BuildHeatingAdvantage.environment(Double.valueOf(decimalFormat.format(calculateAnnualCarbon))));
//封装方案评分
returnJsonObject.set("matchedDeviceList", maps);
return returnJsonObject;
}
}

154
dntd-tool/src/main/java/com/dky/generate/BuildHeatingSence.java
Unescape View File

@ -1,154 +0,0 @@
package com.dky.generate;
import cn.hutool.json.JSONObject;
import com.dky.calculate.*;
import com.dky.modelI.DntdModelI;
import com.dky.tool.ModelTool;
import com.dky.utils.entity.SysDeviceHeatScene;
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;
import java.util.concurrent.atomic.AtomicReference;
public class BuildHeatingSence 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 jsonObject2) {
List<SysDeviceHeatScene> list = ModelTool.specList;
JSONObject distInfo = (JSONObject) jsonObject2.get("distInfo");
JSONObject buildInfo = (JSONObject) jsonObject2.get("buildInfo");
System.out.println("时间: " + Integer.parseInt(buildInfo.get("days").toString()));
// 运行容量
Double runCapacity = Double.parseDouble(distInfo.get("runCapacity").toString());
// 上年最大需量
Double lastYearNeed = Double.parseDouble(distInfo.get("lastYearNeed").toString());
// 建筑面积
Double heatingArea = Double.parseDouble(buildInfo.get("heatingArea").toString());
// 年采暖时间(天)
Integer days = Integer.parseInt(buildInfo.get("days").toString());
// 上年运行费用（万元）
Double lastYearFee = Double.parseDouble(buildInfo.get("lastYearFee").toString());
// A=由运行/合同容量折合成kW（x0.9）x85%,
Double A = runCapacity * COEFFICIENT_1 * COEFFICIENT_2;
// 冗余容量
Double B = A - lastYearNeed;
//投入供热设备总功率C
AtomicReference<Double> C = new AtomicReference<>();
//投入供热设备总功率C1
AtomicReference<Double> C1 = new AtomicReference<>();
List<Map<String, List<List<MatchedDevice>>>> calScheme = Scheme.calScheme(heatingArea, list);
List<Map<String, Double>> mapsC = CalC.getC(calScheme);
for (Map<String, Double> map : mapsC) {
map.forEach((k, v) -> {
if (k.contains("电锅炉")) {
C.set(v);
System.out.println("C" + C.get());
} else {
C1.set(v);
System.out.println("C1" + C1.get());
}
});
}
Double D = lastYearNeed + C.get();
Double D1 = lastYearNeed + C1.get();
List<MatchedDevice> matchedDeviceList;
Map<Double, List<MatchedDevice>> listMap;
Double costRatio = 0.2;
Double effRatio = 0.8;
//获取计算占比
try{
Double costRatio1 = Double.parseDouble(jsonObject2.get("costRatio").toString());
Double effRatio1 = Double.parseDouble(jsonObject2.get("effRatio").toString());
if(costRatio1 < 1 && costRatio1 + costRatio1 == 1){
costRatio = costRatio1;
effRatio = effRatio1;
}
}catch (Exception e){
e.printStackTrace();
}
if (D1 < A && A < D) {
// 判断只能用热泵
List<SysDeviceHeatScene> deviceList = new ArrayList<>();
list.parallelStream().forEach((sysDeviceHeatScene -> {
if (!sysDeviceHeatScene.getDevTechType().contains("电锅炉")) {
deviceList.add(sysDeviceHeatScene);
}
}));
listMap = SchemeRating.getOptimalList(Scheme.calScheme(heatingArea, deviceList),costRatio,effRatio);
matchedDeviceList = SchemeRating.getOptimalScheme(listMap);
} else {
listMap = SchemeRating.getOptimalList(calScheme,costRatio,effRatio);
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(k));
map.put("plan", v);
map.put("planName", v.get(0).getDeviceHeatScene().getDevTechType());
maps.add(map);
});
JSONObject jsonObject = 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 + (BuildHeatingModel.getRunCost(matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevPower(), days, matchedDevice.getDeviceHeatScene().getDevSubstituteLaborCost()));
allCost = allCost + (BuildHeatingModel.getYearCost(matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevPrice(), matchedDevice.getDeviceHeatScene().getDevServiceLife(), matchedDevice.getDeviceHeatScene().getDevPower(), days, matchedDevice.getDeviceHeatScene().getDevSubstituteLaborCost()));
calculateAnnualCarbon = calculateAnnualCarbon + (BuildHeatingModel.calculateAnnualCarbonReduction(lastYearFee, matchedDevice.getDeviceHeatScene().getLaborCost(), matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevPower(), days));
electric = electric + (BuildHeatingModel.getElectric(matchedDevice.getCount(), matchedDevice.getDeviceHeatScene().getDevPower(), days));
}
//初次投资费用
jsonObject.put("startCost", decimalFormat.format(startCost));
//年运行费用
jsonObject.put("yearRunCost", decimalFormat.format(runCost));
//年总费用
jsonObject.put("yearCost", decimalFormat.format(allCost));
//年减碳量
jsonObject.put("calculate", decimalFormat.format(calculateAnnualCarbon));
//替代电量
jsonObject.put("electric", decimalFormat.format(electric));
//封装需配置设备情况
jsonObject.put("deviceList",deviceList);
//封装方案优势
jsonObject.put("safety", BuildHeatingAdvantage.safety());
jsonObject.put("economy", BuildHeatingAdvantage.economy(startCost, allCost, runCost, lastYearFee));
jsonObject.put("intelligence", BuildHeatingAdvantage.intelligence());
jsonObject.put("environment", BuildHeatingAdvantage.environment(Double.valueOf(decimalFormat.format(calculateAnnualCarbon))));
//封装方案评分
jsonObject.put("matchedDeviceList", maps);
return jsonObject;
}
}

4
dntd-tool/src/main/java/com/dky/generate/HeatBoilerSence.java
Unescape View File

@ -5,13 +5,15 @@ 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) {
public JSONObject createReport(JSONObject jsonObject, List<SysDeviceHeatScene> alternateDeviceList) {
JSONObject jsonReport = new JSONObject();
Heatboiler heatboiler = jsonObject.toBean(Heatboiler.class);
// 生成报告

126
dntd-tool/src/main/java/com/dky/test/TestMain.java
Unescape View File

@ -0,0 +1,126 @@
package com.dky.test;
import com.dky.calculate.Scheme;
import com.dky.calculate.SchemeRating;
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();
// List<List<MatchedDevice>> alternateDeviceList = calSchemeMethodTest(14000.0, devList);
// getMaxEfficiencyGroupByDevSubTypeTest(alternateDeviceList);
// getMinPriceGroupByDevSubTypeTest(alternateDeviceList);
/*
根据建筑面积计算出不同技术类型下所需要不同功率设备数据
*/
List<List<MatchedDevice>> matchedDeviceGroupList = Scheme.calScheme(44000.0, alternateDeviceList);
/*
判断计算占比，默认效率0.8，成本0.2
*/
double costRatio = 0.2;
double effRatio = 0.8;
List<MatchedDevice> matchedDeviceList ;
Map<Double, List<MatchedDevice>> listMap ;
/*
根据具体容量与需量判断可使用的技术并计算评分
*/
//计算不同细类下成本最小值与效率最大值
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 void getMinPriceGroupByDevSubTypeTest(List<SysDeviceHeatScene> sysDeviceHeatSceneList){
SchemeRating.getMinPriceGroupByDevSubType(sysDeviceHeatSceneList);
}
public static List<SysDeviceHeatScene>createDevList(){
List<SysDeviceHeatScene> deviceList = new ArrayList<>();
// 模拟从数据库中检索数据
Object[][] data =
{
{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},
{22, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电极类）", 0.97, 360.00, 280000.00, 60000.00, 180000.00, 3000.00, 15, null, null},
{23, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电极类）", 0.97, 720.00, 460000.00, 60000.00, 180000.00, 6000.00, 15, null, null},
{24, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电极类）", 0.97, 1440.00, 900000.00, 60000.00, 180000.00, 12000.00, 15, null, null},
{25, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电磁涡流类）", 0.98, 360.00, 150000.00, 60000.00, 180000.00, 3000.00, 15, null, null},
{26, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电磁涡流类）", 0.98, 720.00, 180000.00, 60000.00, 180000.00, 6000.00, 15, null, null},
{27, "电锅炉", "供冷/暖电锅炉", "直热式电锅炉（电磁涡流类）", 0.98, 1440.00, 300000.00, 60000.00, 180000.00, 12000.00, 15, null, null},
{28, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（固体蓄热）", 0.95, 360.00, 360000.00, 60000.00, 180000.00, 3000.00, 15, null, null},
{29, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（固体蓄热）", 0.95, 720.00, 720000.00, 60000.00, 180000.00, 6000.00, 15, null, null},
{30, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（固体蓄热）", 0.95, 1440.00, 1440000.00, 60000.00, 180000.00, 12000.00, 15, null, null},
{31, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（相变蓄热）", 0.98, 360.00, 120000.00, 60000.00, 180000.00, 3000.00, 15, null, null},
{32, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（相变蓄热）", 0.98, 720.00, 160000.00, 60000.00, 180000.00, 6000.00, 15, null, null},
{33, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（相变蓄热）", 0.98, 1440.00, 280000.00, 60000.00, 180000.00, 12000.00, 15, null, null},
{34, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（水蓄）", 0.97, 360.00, 110000.00, 60000.00, 180000.00, 3000.00, 15, null, null},
{35, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（水蓄）", 0.97, 720.00, 150000.00, 60000.00, 180000.00, 6000.00, 15, null, null},
{36, "电锅炉", "供冷/暖电锅炉", "蓄热式电锅炉（水蓄）", 0.97, 1440.00, 260000.00, 60000.00, 180000.00, 12000.00, 15, null, null},
{37, "热泵", "供冷/暖", "水源热泵", 4.00, 25.00, 45000.00, 60000.00, 180000.00, 500.00, 15, null, null},
{38, "热泵", "供冷/暖", "水源热泵", 4.00, 45.00, 75000.00, 60000.00, 180000.00, 1000.00, 15, null, null},
{39, "热泵", "供冷/暖", "水源热泵", 4.00, 90.00, 140000.00, 60000.00, 180000.00, 2000.00, 15, null, null},
{40, "热泵", "供冷/暖", "土壤源热泵", 4.00, 25.00, 45000.00, 60000.00, 180000.00, 500.00, 15, null, null},
{41, "热泵", "供冷/暖", "土壤源热泵", 4.00, 45.00, 75000.00, 60000.00, 180000.00, 1000.00, 15, null, null},
{42, "热泵", "供冷/暖", "土壤源热泵", 4.00, 90.00, 140000.00, 60000.00, 180000.00, 2000.00, 15, null, null},
{43, "热泵", "供冷/暖", "空气源热泵", 4.00, 25.00, 45000.00, 60000.00, 180000.00, 500.00, 15, null, null},
{44, "热泵", "供冷/暖", "空气源热泵", 4.00, 45.00, 75000.00, 60000.00, 180000.00, 1000.00, 15, null, null},
{45, "热泵", "供冷/暖", "空气源热泵", 4.00, 90.00, 140000.00, 60000.00, 180000.00, 2000.00, 15, null, null},
{46, "热泵", "供冷/暖", "低品位余热源（如电厂低温循环水）热泵", 4.00, 25.00, 45000.00, 60000.00, 180000.00, 500.00, 15, null, null},
{47, "热泵", "供冷/暖", "低品位余热源（如电厂低温循环水）热泵", 4.00, 45.00, 75000.00, 60000.00, 180000.00, 1000.00, 15, null, null},
{48, "热泵", "供冷/暖", "低品位余热源（如电厂低温循环水）热泵", 4.00, 90.00, 140000.00, 60000.00, 180000.00, 2000.00, 15, null, null},
{49, "热泵", "供冷/暖", "高温蒸汽热泵", 3.00, 45.00, 380000.00, 60000.00, 180000.00, 1000.00, 15, null, null},
{50, "热泵", "供冷/暖", "高温蒸汽热泵", 3.00, 120.00, 550000.00, 60000.00, 180000.00, 2000.00, 15, null, null},
};
// 创建对象并添加到列表
for (Object[] row : data) {
int id = (int) row[0];
String devType = (String) row[1];
String devSubType = (String) row[2];
String devTechType = (String) row[3];
double heatEfficiency = (double) row[4];
double devPower = (double) row[5];
double devPrice = (double) row[6];
double devSubstituteLaborCost = (double) row[7];
double laborCost = (double) row[8];
double devReferenceArea = (double) row[9];
int devServiceLife = (int) row[10];
SysDeviceHeatScene device = new SysDeviceHeatScene(
id, devType, devSubType, devTechType, heatEfficiency, devPower, devPrice,
devSubstituteLaborCost, laborCost, devReferenceArea, devServiceLife, null, null);
deviceList.add(device);
}
return deviceList;
}
}

27
dntd-tool/src/main/java/com/dky/tool/ModelTool.java
Unescape View File

@ -8,6 +8,7 @@ import com.dky.utils.ConfigReader;
import com.dky.utils.entity.SysDeviceHeatScene;
import com.dky.utils.enums.Code;
import com.dky.utils.result.ResponseUtil;
import org.bouncycastle.math.raw.Mod;
import java.lang.reflect.InvocationTargetException;
import java.text.SimpleDateFormat;
@ -18,17 +19,29 @@ import java.util.Map;
public class ModelTool {
public static List<SysDeviceHeatScene> specList = new ArrayList<>();
// 制热锅炉，单功率单价，单位。建缓冲区。List实体。
public ModelTool(JSONObject list) {
public List<SysDeviceHeatScene> specList;
// 私有化构造方法，避免外部实例化
private ModelTool() {
}
public ModelTool(List<SysDeviceHeatScene> specList) {
this.specList = specList;
}
// 创建工具类的静态工厂方法
public static ModelTool create(JSONObject list) {
List<SysDeviceHeatScene> specList = new ArrayList<>();
JSONArray specArray = list.getJSONArray("devSpecList");
for (int i = 0; i < specArray.size(); i++) {
SysDeviceHeatScene devSpec = specArray.getJSONObject(i).toBean(SysDeviceHeatScene.class);
specList.add(devSpec);
}
return new ModelTool(specList);
}
public static JSONObject exeModel2Report(JSONObject jsonObject, String key) {
public JSONObject exeModel2Report(JSONObject jsonObject, String key) {
JSONObject jsonObjectResult = new JSONObject();
try {
// 根据给定的类名初始化类 加密不需要反实例化new
@ -48,11 +61,11 @@ public class ModelTool {
if (new Date().before(date)){
// 判断模型使用权限
// 根据给定的类名初始化类 加密不需要反实例化new
Class modelI = Class.forName("com.dky"+"."+ ConfigReader.getProperty(jsonObject.getStr("type")));
Class buildHeatingScene = Class.forName("com.dky"+"."+ ConfigReader.getProperty(jsonObject.getStr("type")));
// 实例化这个类
DntdModelI modelI1 = (DntdModelI)modelI.newInstance();
DntdModelI buildHeatingSceneModel = (DntdModelI)buildHeatingScene.newInstance();
// 调用指定方法
jsonObjectResult = modelI1.createReport(jsonObject);
jsonObjectResult = buildHeatingSceneModel.createReport(jsonObject,this.specList);
}else {
jsonObjectResult = ResponseUtil.createResponse(Code.KEY_EXPIRATION.getCode(), Code.KEY_EXPIRATION.getDesc(), null);
}

Write Preview
Loading…
Cancel
Save