Skip to content

G
gf_back
Commit 64208192 authored by ZWT's avatar ZWT
Browse files
Options

feat(能源管理系统): 间开优化定时任务 

1.开发间开优化定期校准定时任务,配置表达式修改定时任务配置文件,创建cloud模块方法;
2.开发间开优化定期校准定时任务,完成业务逻辑开发;
3.修改间开制度管理模块定期校准新增功能,增加初始化校准历史业务逻辑;
4.开发间开优化短期间开优化定时任务,配置表达式修改定时任务配置文件,创建cloud模块方法;
5.修改长期间开优化定时任务,添加离网型线路数据处理逻辑;
6.创建储能预测电量数据(模拟数据测试用)表,生成对应代码,添加条件查询各时段储能预测数据Cloud模块接口;
7.修改长期间开优化定时任务,增加离网型算法计算储能可用时长逻辑;
8.修改长期间开优化定时任务,优化部分sql查询语句查询逻辑,优化代码结构;
9.光伏预测Cloud模块查询预测发电量接口修改,增加查询长期发电量逻辑;

BREAKING CHANGE: 无

Closes 无

[skip ci]
parent 51c09709
Hide whitespace changes
Inline Side-by-side
Showing with 268 additions and 247 deletions
C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceOptimizeBaseService.java
View file @ 64208192
......@@ -39,6 +39,7 @@ import xstartup.base.exception.XServiceException;
import xstartup.data.XListResult;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;
......@@ -706,4 +707,263 @@ public class SpaceOptimizeBaseService {
}
}
}
/**
* 离网优化
*
* @param context 上下文
* @param wellheadDTOList 井口dtolist
* @param durationDTOList 持续时间dtolist
* @param unOptimizeDurationList 取消优化工期列表
* @param spaceWellheadList 空间井口清单
* @param avgPowerList 平均功率列表
* @param storageAvgMap 存储平均值映射
* @param plantIdsByLineIdMap 按线id图植物id
* @param detail 细节
* @param periodId 期间id
* @param lastYear 去年
* @param lastMonth 上个月
*/
public void offGridOptimization(XContext context, List<SpaceOptimizeWellheadDTO> wellheadDTOList, List<SpaceOptimizeDurationDTO> durationDTOList,
List<SpaceOptimizeDurationDTO> unOptimizeDurationList, List<SpaceInstitutionWellheadView> spaceWellheadList,
List<DynamicQueryPlantPredictedPowerOutput> avgPowerList, Map<String, List<DynamicQueryBasePowerLineStorageViewOutput>> storageAvgMap,
Map<String, List<String>> plantIdsByLineIdMap, SpaceInstitutionDetailEnt detail,
String periodId, int lastYear, String lastMonth) {
String detailId = detail.getId();
String lineId = detail.getLineId();
//根据类型过滤井口:大间开,连抽井不优化
List<SpaceInstitutionWellheadView> wellheadViewList = this.getWellheadViewList(spaceWellheadList, detailId);
if (CollUtil.isEmpty(wellheadViewList)) {
return;
}
//获取井口间开时间段
SpaceInstitutionDurationMapper durationMapper = context.getBean(SpaceInstitutionDurationMapper.class);
Map<String, List<SpaceInstitutionDurationEnt>> durationMap = this.getDurationMap(durationMapper, detailId);
if (CollUtil.isEmpty(durationMap)) {
//没有设置时间段,无法优化
return;
}
//时间差
int between = 0;
//启动间隔累积
int startInterval = 0;
//判断是否第一口井
boolean isFirstWellhead;
//第一口井启动时间
DateTime firstStartTime = null;
//第一口井开井时间
int firstIndex = 0;
//井口累积运行总功率
BigDecimal totalOperatingPower = BigDecimal.ZERO;
//离网时间段
List<SpaceOptimizeDurationDTO> offGridPeriodList = new ArrayList<>(32);
for (int w = 0, wellheadSize = wellheadViewList.size(); w < wellheadSize; w++) {
SpaceInstitutionWellheadView wellhead = wellheadViewList.get(w);
String wellheadId = wellhead.getWellheadId();
String recordId = this.createOptimizeWellhead(wellheadDTOList, periodId, wellheadId, wellhead.getWellNumber());
//取当前井口最大发电量
BigDecimal serviceRating = wellhead.getServiceRating();
List<SpaceInstitutionDurationEnt> durationConfigList = durationMap.get(wellhead);
if (CollUtil.isEmpty(durationConfigList)) {
//没有设置时间段,无法优化
continue;
}
//保存原始记录
for (SpaceInstitutionDurationEnt durationEnt : durationConfigList) {
this.createUnOptimizeDuration(unOptimizeDurationList, durationEnt, periodId, recordId, wellheadId);
}
totalOperatingPower = totalOperatingPower.add(serviceRating);
if (w == 0) {
//第一个井口
isFirstWellhead = true;
} else {
//累加
startInterval = startInterval + detail.getStartInterval();
isFirstWellhead = false;
}
for (int d = 0, durationSize = durationConfigList.size(); d < durationSize; d++) {
SpaceInstitutionDurationEnt duration = durationConfigList.get(d);
DateTime startTime = DateUtil.date(duration.getOpenTime());
DateTime endTime = DateUtil.date(duration.getCloseTime());
//第一次启动
if (d == 0) {
//第一口井的启动时间
if (isFirstWellhead) {
firstStartTime = startTime;
//计算开井时间
for (int a = 0, avgPowerSize = avgPowerList.size(); a < avgPowerSize; a++) {
DynamicQueryPlantPredictedPowerOutput predictedPower = avgPowerList.get(a);
//当日时间段平均光伏出力>=第一口井运行负荷时,该时间为第一口井运行时间
if (predictedPower.getPower().compareTo(serviceRating) >= BusinessConstant.ZERO) {
firstIndex = a;
break;
}
}
DynamicQueryPlantPredictedPowerOutput start = avgPowerList.get(firstIndex);
DateTime startTimeOptimize = DateUtil.date(start.getCreateTime());
//计算第一次关井时间,按照间开时间段顺延
int startDuration = (int) startTime.between(endTime, DateUnit.MINUTE);
DateTime endTimeOptimize = startTime.offset(DateField.MINUTE, startDuration);
this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, startTimeOptimize, endTimeOptimize);
//计算时间偏移,取时间间隔(分钟)
between = BaseUtils.getTimeDifferenceMinute(startTimeOptimize, startTime);
}
//其它井口的第一次启动时间
else {
DateTime startTimeOffset = firstStartTime.offset(DateField.MINUTE, startInterval);
int startIndex = -1;
for (int a = 0, avgPowerSize = avgPowerList.size(); a < avgPowerSize; a++) {
DynamicQueryPlantPredictedPowerOutput predictedPower = avgPowerList.get(a);
if (DateUtil.date(predictedPower.getCreateTime()).compareTo(startTimeOffset) >= 0) {
//判断第一口井启动时间+启动间隔时日平均光伏出力-前两口井的运行功率是否为正数
if (predictedPower.getPower().compareTo(totalOperatingPower) >= 0) {
//确定第二口井第一次开井时间为第一口井启动时间+启动间隔
startIndex = a;
break;
}
}
}
if (startIndex > -1) {
DynamicQueryPlantPredictedPowerOutput start = avgPowerList.get(startIndex);
DateTime startTimeOptimize = DateUtil.date(start.getCreateTime());
//计算未优化启动间隔
int openDuration = (int) startTime.between(endTime, DateUnit.MINUTE);
DateTime endTimeOptimize = startTimeOptimize.offset(DateField.MINUTE, openDuration);
this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, startTimeOptimize, endTimeOptimize);
//取时间间隔(分钟)
between = BaseUtils.getTimeDifferenceMinute(endTimeOptimize, endTime);
} else {
//无法优化
}
}
} else {
DateTime offset = startTime.offset(DateField.MINUTE, between);
if (offset.compareTo(BusinessConstant.DATE_FLAG) > 0) {
//如果时间超过当天,舍弃
continue;
}
//计算偏移
this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, offset,
DateUtil.date(duration.getCloseTime()).offset(DateField.MINUTE, between)
);
}
}
}
//离网优化
if (CollUtil.isNotEmpty(offGridPeriodList)) {
if (!storageAvgMap.containsKey(lineId)) {
//没有储能设备,无法计算
return;
}
//截取从第一次开井时间往后的时间段
List<DynamicQueryPlantPredictedPowerOutput> subAvgPowerList = CollUtil.sub(avgPowerList, firstIndex + 1, avgPowerList.size());
if (CollUtil.isEmpty(subAvgPowerList)) {
//没有时间段,无法计算
return;
}
//查获取前一个月该时间点储能剩余电量，求平均数
List<DynamicQueryStoragePredictedPowerOutput> averageEnergyStorageList = this.getAverageEnergyStorageListByParam(context,
DynamicQueryStoragePredictedPowerInput.builder()
.storageIds(plantIdsByLineIdMap.get(lineId))
.yearTime(String.valueOf(lastYear))
.monthTime(lastMonth)
.build()
);
if (CollUtil.isEmpty(averageEnergyStorageList)) {
//没有储能发电量,无法计算
return;
}
//取储能计算参数
List<DynamicQueryBasePowerLineStorageViewOutput> avgStorageViewList = storageAvgMap.get(lineId);
DynamicQueryBasePowerLineStorageViewOutput avgStorageView = avgStorageViewList.get(0);
//平均额定放电效率(%)
BigDecimal avgRatedDischargeEfficiency = avgStorageView.getRatedDischargeEfficiency();
//平均额定放电深度(%)
BigDecimal avgRatedDischargeDepth = avgStorageView.getRatedDischargeDepth();
//平均额定放电功率(KW)
BigDecimal avgRatedDischargePower = avgStorageView.getRatedDischargePower();
//逐15分钟计算光伏出力-井场运行功率之和，获得光伏出力不足时间段,并计算储能可用时长
Iterator<DynamicQueryStoragePredictedPowerOutput> iterator = averageEnergyStorageList.iterator();
for (DynamicQueryPlantPredictedPowerOutput avg : subAvgPowerList) {
if (avg.getPower().compareTo(totalOperatingPower) >= 0) {
//电量不足,计算储能可用时长
avg.setBatteryLowFlag(false);
String hourTime = avg.getHourTime();
String minTime = avg.getMinTime();
while (iterator.hasNext()) {
DynamicQueryStoragePredictedPowerOutput storagePredicted = iterator.next();
if (StringUtils.equals(hourTime, storagePredicted.getHourTime()) && StringUtils.equals(minTime, storagePredicted.getMinTime())) {
//计算储能可供电时长:（储能剩余容量*放电深度*放电效率）/额定放电功率
avg.setPowerDuration(
storagePredicted.getPower()
.multiply(avgRatedDischargeDepth)
.multiply(avgRatedDischargeEfficiency)
.divide(avgRatedDischargePower)
.setScale(BusinessConstant.ZERO, RoundingMode.DOWN)
.intValueExact()
);
break;
}
//删除计算过的时间段
iterator.remove();
}
} else {
avg.setBatteryLowFlag(true);
}
}
//拆分时间段
for (SpaceOptimizeDurationDTO durationDTO : offGridPeriodList) {
Date openTime = durationDTO.getOpenTime();
Date closeTime = durationDTO.getCloseTime();
if (closeTime.compareTo(BusinessConstant.DATE_FLAG) > 0) {
closeTime = DateUtil.endOfDay(DateUtil.date());
}
//匹配时间
for (int i = 0, size = subAvgPowerList.size(); i < size; i++) {
DynamicQueryPlantPredictedPowerOutput avg = subAvgPowerList.get(i);
DateTime createTime = DateUtil.date(avg.getCreateTime());
//计算时间范围:大于等于开始时间,小于等于结束时间
if (openTime.compareTo(createTime) >= 0 && closeTime.compareTo(createTime) <= 0) {
String endString = createTime.offset(DateField.MINUTE, 15).toString(BusinessConstant.MINUTES_FORMAT);
String startString = createTime.toString(BusinessConstant.MINUTES_FORMAT);
//电量满足跳过
if (avg.getBatteryLowFlag()) {
//创建光伏
this.createOptimizeDuration(durationDTOList, periodId, durationDTO.getRecordId(), durationDTO.getWellheadId(), BusinessConstant.PHOTOVOLTAIC,
startString, endString
);
} else {
int powerDuration = avg.getPowerDuration();
String offset = createTime.offset(DateField.MINUTE, powerDuration).toString(BusinessConstant.MINUTES_FORMAT);
//储能发电时长
this.createOptimizeDuration(durationDTOList, periodId, durationDTO.getRecordId(), durationDTO.getWellheadId(), BusinessConstant.STORED_ENERGY,
startString, offset
);
//柴发发电时长
this.createOptimizeDuration(durationDTOList, periodId, durationDTO.getRecordId(), durationDTO.getWellheadId(), BusinessConstant.DIESEL_POWER,
offset, endString
);
}
}
}
}
}
}
/**
* 离网型间开记录
*
* @param offGridPeriodList 离网时段列表
* @param wellheadId 井口id
* @param openTime 断开时间
* @param closeTime 关闭时间
*/
private void createDurationOffGridPeriod(List<SpaceOptimizeDurationDTO> offGridPeriodList, String wellheadId,
Date openTime, Date closeTime) {
SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
durationDTO.setWellheadId(wellheadId);
durationDTO.setOpenTime(openTime);
durationDTO.setCloseTime(closeTime);
offGridPeriodList.add(durationDTO);
}
}
\ No newline at end of file
C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceOptimizeLongCloudServiceImpl.java
View file @ 64208192
package pps.core.space.service;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import org.apache.commons.lang3.StringUtils;
import pps.cloud.base.service.data.base_power_line_storage.DynamicQueryBasePowerLineStorageViewOutput;
import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerInput;
import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerOutput;
import pps.cloud.prediction.service.data.storage_predicted_power_data.DynamicQueryStoragePredictedPowerInput;
import pps.cloud.prediction.service.data.storage_predicted_power_data.DynamicQueryStoragePredictedPowerOutput;
import pps.cloud.space.service.ISpaceOptimizeLongCloudService;
import pps.core.common.constant.BusinessConstant;
import pps.core.common.utils.BaseUtils;
......@@ -23,9 +18,9 @@ import xstartup.base.XContext;
import xstartup.data.XServiceResult;
import xstartup.helper.XTransactionHelper;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 长期间开优化Cloud模块
......@@ -75,14 +70,12 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
List<DynamicQueryPlantPredictedPowerOutput> avgPowerList;
//优化
for (SpaceInstitutionDetailEnt detail : detailEntList) {
String detailId = detail.getId();
String lineId = detail.getLineId();
//创建记录
String periodId = super.createOptimizePeriod(periodDTOList, detailId, lineId, executionCycleForMonth, optimizeDeadline);
String periodId = super.createOptimizePeriod(periodDTOList, detail.getId(), detail.getLineId(), executionCycleForMonth, optimizeDeadline);
//获取当前制度对应的光伏预测数据列表
avgPowerList = super.getAveragePowerGenerationListByPlantIds(context,
DynamicQueryPlantPredictedPowerInput.builder()
.plantIds(plantIdsByLineIdMap.get(lineId))
.plantIds(plantIdsByLineIdMap.get(detail.getLineId()))
.yearTime(String.valueOf(year))
.monthTime(month)
.dateType(BusinessConstant.ZERO)
......@@ -92,226 +85,12 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
//并网型优化
case "1":
super.gridConnectedOptimization(context, durationMapper, wellheadDTOList, durationDTOList, unOptimizeDurationList,
spaceWellheadList, avgPowerList, detail, monthNum, detailId, periodId, lineId);
spaceWellheadList, avgPowerList, detail, monthNum, detail.getId(), periodId, detail.getLineId());
break;
//离网型优化
case "0":
//根据类型过滤井口:大间开,连抽井不优化
List<SpaceInstitutionWellheadView> wellheadViewList = this.getWellheadViewList(spaceWellheadList, detailId);
if (CollUtil.isEmpty(wellheadViewList)) {
continue;
}
//获取井口间开时间段
Map<String, List<SpaceInstitutionDurationEnt>> durationMap = this.getDurationMap(durationMapper, detailId);
if (CollUtil.isEmpty(durationMap)) {
//没有设置时间段,无法优化
continue;
}
//时间差
int between = 0;
//启动间隔累积
int startInterval = 0;
//判断是否第一口井
boolean isFirstWellhead;
//第一口井启动时间
DateTime firstStartTime = null;
//第一口井开井时间
int firstIndex = 0;
//井口累积运行总功率
BigDecimal totalOperatingPower = BigDecimal.ZERO;
//离网时间段
List<SpaceOptimizeDurationDTO> offGridPeriodList = new ArrayList<>(32);
for (int w = 0, wellheadSize = wellheadViewList.size(); w < wellheadSize; w++) {
SpaceInstitutionWellheadView wellhead = wellheadViewList.get(w);
String wellheadId = wellhead.getWellheadId();
String recordId = this.createOptimizeWellhead(wellheadDTOList, periodId, wellheadId, wellhead.getWellNumber());
//取当前井口最大发电量
BigDecimal serviceRating = wellhead.getServiceRating();
List<SpaceInstitutionDurationEnt> durationConfigList = durationMap.get(wellhead);
if (CollUtil.isEmpty(durationConfigList)) {
//没有设置时间段,无法优化
continue;
}
//保存原始记录
for (SpaceInstitutionDurationEnt durationEnt : durationConfigList) {
this.createUnOptimizeDuration(unOptimizeDurationList, durationEnt, periodId, recordId, wellheadId);
}
totalOperatingPower = totalOperatingPower.add(serviceRating);
if (w == 0) {
//第一个井口
isFirstWellhead = true;
} else {
//累加
startInterval = startInterval + detail.getStartInterval();
isFirstWellhead = false;
}
for (int d = 0, durationSize = durationConfigList.size(); d < durationSize; d++) {
SpaceInstitutionDurationEnt duration = durationConfigList.get(d);
DateTime startTime = DateUtil.date(duration.getOpenTime());
DateTime endTime = DateUtil.date(duration.getCloseTime());
//第一次启动
if (d == 0) {
//第一口井的启动时间
if (isFirstWellhead) {
firstStartTime = startTime;
//计算开井时间
for (int a = 0, avgPowerSize = avgPowerList.size(); a < avgPowerSize; a++) {
DynamicQueryPlantPredictedPowerOutput predictedPower = avgPowerList.get(a);
//当日时间段平均光伏出力>=第一口井运行负荷时,该时间为第一口井运行时间
if (predictedPower.getPower().compareTo(serviceRating) >= BusinessConstant.ZERO) {
firstIndex = a;
break;
}
}
DynamicQueryPlantPredictedPowerOutput start = avgPowerList.get(firstIndex);
DateTime startTimeOptimize = DateUtil.date(start.getCreateTime());
//计算第一次关井时间,按照间开时间段顺延
int startDuration = (int) startTime.between(endTime, DateUnit.MINUTE);
DateTime endTimeOptimize = startTime.offset(DateField.MINUTE, startDuration);
this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, startTimeOptimize, endTimeOptimize);
//计算时间偏移,取时间间隔(分钟)
between = BaseUtils.getTimeDifferenceMinute(startTimeOptimize, startTime);
}
//其它井口的第一次启动时间
else {
DateTime startTimeOffset = firstStartTime.offset(DateField.MINUTE, startInterval);
int startIndex = -1;
for (int a = 0, avgPowerSize = avgPowerList.size(); a < avgPowerSize; a++) {
DynamicQueryPlantPredictedPowerOutput predictedPower = avgPowerList.get(a);
if (DateUtil.date(predictedPower.getCreateTime()).compareTo(startTimeOffset) >= 0) {
//判断第一口井启动时间+启动间隔时日平均光伏出力-前两口井的运行功率是否为正数
if (predictedPower.getPower().compareTo(totalOperatingPower) >= 0) {
//确定第二口井第一次开井时间为第一口井启动时间+启动间隔
startIndex = a;
break;
}
}
}
if (startIndex > -1) {
DynamicQueryPlantPredictedPowerOutput start = avgPowerList.get(startIndex);
DateTime startTimeOptimize = DateUtil.date(start.getCreateTime());
//计算未优化启动间隔
int openDuration = (int) startTime.between(endTime, DateUnit.MINUTE);
DateTime endTimeOptimize = startTimeOptimize.offset(DateField.MINUTE, openDuration);
this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, startTimeOptimize, endTimeOptimize);
//取时间间隔(分钟)
between = BaseUtils.getTimeDifferenceMinute(endTimeOptimize, endTime);
} else {
//无法优化
}
}
} else {
DateTime offset = startTime.offset(DateField.MINUTE, between);
if (offset.compareTo(BusinessConstant.DATE_FLAG) > 0) {
//如果时间超过当天,舍弃
continue;
}
//计算偏移
this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, offset,
DateUtil.date(duration.getCloseTime()).offset(DateField.MINUTE, between)
);
}
}
}
//离网优化
if (CollUtil.isNotEmpty(offGridPeriodList)) {
if (!storageAvgMap.containsKey(lineId)) {
//没有储能设备,无法计算
continue;
}
//截取从第一次开井时间往后的时间段
List<DynamicQueryPlantPredictedPowerOutput> subAvgPowerList = CollUtil.sub(avgPowerList, firstIndex + 1, avgPowerList.size());
if (CollUtil.isEmpty(subAvgPowerList)) {
//没有时间段,无法计算
continue;
}
//查获取前一个月该时间点储能剩余电量，求平均数
List<DynamicQueryStoragePredictedPowerOutput> averageEnergyStorageList = super.getAverageEnergyStorageListByParam(context,
DynamicQueryStoragePredictedPowerInput.builder()
.storageIds(plantIdsByLineIdMap.get(lineId))
.yearTime(String.valueOf(lastYear))
.monthTime(lastMonth)
.build()
);
if (CollUtil.isEmpty(averageEnergyStorageList)) {
//没有储能发电量,无法计算
continue;
}
//取储能计算参数
List<DynamicQueryBasePowerLineStorageViewOutput> avgStorageViewList = storageAvgMap.get(lineId);
DynamicQueryBasePowerLineStorageViewOutput avgStorageView = avgStorageViewList.get(0);
//平均额定放电效率(%)
BigDecimal avgRatedDischargeEfficiency = avgStorageView.getRatedDischargeEfficiency();
//平均额定放电深度(%)
BigDecimal avgRatedDischargeDepth = avgStorageView.getRatedDischargeDepth();
//平均额定放电功率(KW)
BigDecimal avgRatedDischargePower = avgStorageView.getRatedDischargePower();
//逐15分钟计算光伏出力-井场运行功率之和，获得光伏出力不足时间段,并计算储能可用时长
Iterator<DynamicQueryStoragePredictedPowerOutput> iterator = averageEnergyStorageList.iterator();
for (DynamicQueryPlantPredictedPowerOutput avg : subAvgPowerList) {
if (avg.getPower().compareTo(totalOperatingPower) >= 0) {
//电量不足,计算储能可用时长
avg.setBatteryLowFlag(false);
String hourTime = avg.getHourTime();
String minTime = avg.getMinTime();
while (iterator.hasNext()) {
DynamicQueryStoragePredictedPowerOutput storagePredicted = iterator.next();
if (StringUtils.equals(hourTime, storagePredicted.getHourTime()) && StringUtils.equals(minTime, storagePredicted.getMinTime())) {
//计算储能可供电时长:（储能剩余容量*放电深度*放电效率）/额定放电功率
avg.setPowerDuration(
storagePredicted.getPower()
.multiply(avgRatedDischargeDepth)
.multiply(avgRatedDischargeEfficiency)
.divide(avgRatedDischargePower)
.setScale(BusinessConstant.ZERO, RoundingMode.DOWN)
.intValueExact()
);
break;
}
//删除计算过的时间段
iterator.remove();
}
} else {
avg.setBatteryLowFlag(true);
}
}
//拆分时间段
for (SpaceOptimizeDurationDTO durationDTO : offGridPeriodList) {
Date openTime = durationDTO.getOpenTime();
Date closeTime = durationDTO.getCloseTime();
if (closeTime.compareTo(BusinessConstant.DATE_FLAG) > 0) {
closeTime = DateUtil.endOfDay(date);
}
//匹配时间
for (int i = 0, size = subAvgPowerList.size(); i < size; i++) {
DynamicQueryPlantPredictedPowerOutput avg = subAvgPowerList.get(i);
DateTime createTime = DateUtil.date(avg.getCreateTime());
//计算时间范围:大于等于开始时间,小于等于结束时间
if (openTime.compareTo(createTime) >= 0 && closeTime.compareTo(createTime) <= 0) {
String endString = createTime.offset(DateField.MINUTE, 15).toString(BusinessConstant.MINUTES_FORMAT);
String startString = createTime.toString(BusinessConstant.MINUTES_FORMAT);
//电量满足跳过
if (avg.getBatteryLowFlag()) {
//创建光伏
this.createOptimizeDuration(durationDTOList, periodId, durationDTO.getRecordId(), durationDTO.getWellheadId(), BusinessConstant.PHOTOVOLTAIC,
startString, endString
);
} else {
int powerDuration = avg.getPowerDuration();
String offset = createTime.offset(DateField.MINUTE, powerDuration).toString(BusinessConstant.MINUTES_FORMAT);
//储能发电时长
this.createOptimizeDuration(durationDTOList, periodId, durationDTO.getRecordId(), durationDTO.getWellheadId(), BusinessConstant.STORED_ENERGY,
startString, offset
);
//柴发发电时长
this.createOptimizeDuration(durationDTOList, periodId, durationDTO.getRecordId(), durationDTO.getWellheadId(), BusinessConstant.DIESEL_POWER,
offset, endString
);
}
}
}
}
}
super.offGridOptimization(context, wellheadDTOList, durationDTOList, unOptimizeDurationList, spaceWellheadList,
avgPowerList, storageAvgMap, plantIdsByLineIdMap, detail, periodId, lastYear, lastMonth);
break;
default:
//电网类型不存在
......@@ -362,22 +141,4 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
}
/*-----------------------------------private-----------------------------------*/
/**
* 离网型间开记录
*
* @param offGridPeriodList 离网时段列表
* @param wellheadId 井口id
* @param openTime 断开时间
* @param closeTime 关闭时间
*/
public void createDurationOffGridPeriod(List<SpaceOptimizeDurationDTO> offGridPeriodList, String wellheadId,
Date openTime, Date closeTime) {
SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
durationDTO.setWellheadId(wellheadId);
durationDTO.setOpenTime(openTime);
durationDTO.setCloseTime(closeTime);
offGridPeriodList.add(durationDTO);
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment