Skip to content

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

feat(零碳): 长庆 

1.修改极短期间开预测定时任务逻辑,解决优化后部分优化结果时间段过短问题;
2.修改心知天气气象数据获取及接收定时任务,解决天气数据通过邮件下载后,部分数据精度丢失问题;

BREAKING CHANGE: 无

Closes 无

[skip ci]
parent 2d669ebf
Hide whitespace changes
Inline Side-by-side
Showing with 221 additions and 202 deletions
C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceOptimizeShortPeriodService.java
View file @ 88a5ca78
...@@ -258,70 +258,7 @@ public class SpaceOptimizeShortPeriodService extends SpaceOptimizeBaseService { ...@@ -258,70 +258,7 @@ public class SpaceOptimizeShortPeriodService extends SpaceOptimizeBaseService {
firstOpenWellTime = this.timePeriodOptimization(optimizeDurationDTOList, weightDurationList, firstOpenWellTime, i, firstOpenWellTime = this.timePeriodOptimization(optimizeDurationDTOList, weightDurationList, firstOpenWellTime, i,
startInterval, minOpenMinute, wellhead, weightList); startInterval, minOpenMinute, wellhead, weightList);
//创建优化后的间开区间 //创建优化后的间开区间
if (CollUtil.isNotEmpty(optimizeDurationDTOList)) { this.addOptimizeDuration(optimizeDurationDTOList, durationDTOList, tundraStrategyList, periodId, recordId, wellheadId, startDate);
//重新按开井时间排序
optimizeDurationDTOList.sort(Comparator.comparing(SpaceOptimizeDurationDTO::getOpenTime));
SpaceOptimizeDurationDTO durationDTO;
for (int i1 = 0; i1 < optimizeDurationDTOList.size(); i1++) {
durationDTO = optimizeDurationDTOList.get(i1);
DateTime startOffset = DateUtil.date(durationDTO.getOpenTime());
DateTime endOffset = DateUtil.date(durationDTO.getCloseTime());
if (startOffset.compareTo(BusinessConstant.DATE_FLAG) < 0 && endOffset.compareTo(BusinessConstant.DATE_FLAG) > 0) {
//如果时间超过当天,舍弃
this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
startOffset.toString(BusinessConstant.MINUTES_FORMAT),
BusinessConstant.END_OF_DAY_TIME,
BusinessConstant.ONE, startDate
);
this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
BusinessConstant.START_OF_DAY_TIME,
endOffset.toString(BusinessConstant.MINUTES_FORMAT),
BusinessConstant.ONE, startDate
);
tundraStrategyList.add(
SpaceOptimizeDurationDTO.builder()
.wellheadId(wellheadId)
.openTime(startOffset)
.closeTime(BusinessConstant.DATE_FLAG)
.build()
);
tundraStrategyList.add(
SpaceOptimizeDurationDTO.builder()
.wellheadId(wellheadId)
.openTime(BusinessConstant.DATE_FLAG_BEGIN)
.closeTime(endOffset)
.build()
);
} else if (endOffset.compareTo(BusinessConstant.DATE_FLAG) == 0) {
this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
startOffset.toString(BusinessConstant.MINUTES_FORMAT),
BusinessConstant.END_OF_DAY_TIME,
BusinessConstant.ONE, startDate
);
tundraStrategyList.add(
SpaceOptimizeDurationDTO.builder()
.wellheadId(wellheadId)
.openTime(startOffset)
.closeTime(BusinessConstant.DATE_FLAG)
.build()
);
} else {
//计算偏移
this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
startOffset.toString(BusinessConstant.MINUTES_FORMAT),
endOffset.toString(BusinessConstant.MINUTES_FORMAT),
BusinessConstant.ONE, startDate
);
tundraStrategyList.add(
SpaceOptimizeDurationDTO.builder()
.wellheadId(wellheadId)
.openTime(startOffset)
.closeTime(endOffset)
.build()
);
}
}
}
} }
//防冻井 //防冻井
if (ObjectUtil.isNotNull(tundraStrategyWellhead) && CollUtil.isNotEmpty(tundraStrategyList)) { if (ObjectUtil.isNotNull(tundraStrategyWellhead) && CollUtil.isNotEmpty(tundraStrategyList)) {
...@@ -419,17 +356,21 @@ public class SpaceOptimizeShortPeriodService extends SpaceOptimizeBaseService { ...@@ -419,17 +356,21 @@ public class SpaceOptimizeShortPeriodService extends SpaceOptimizeBaseService {
serviceRating = serviceRating.add(tundraStrategyWellhead.getServiceRating()); serviceRating = serviceRating.add(tundraStrategyWellhead.getServiceRating());
List<SpaceOptimizeWeight> weightList = this.calculateWeightList(serviceRating, rangeToList, powerList, strategyList); List<SpaceOptimizeWeight> weightList = this.calculateWeightList(serviceRating, rangeToList, powerList, strategyList);
List<SpaceOptimizeWeightDuration> weightDurationList = this.weightListProcessing(ladder, weightList, minOpenMinute); List<SpaceOptimizeWeightDuration> weightDurationList = this.weightListProcessing(ladder, weightList, minOpenMinute);
//创建优化记录
String wellheadId = tundraStrategyWellhead.getWellheadId();
String recordId = this.createOptimizeWellhead(wellheadDTOList, periodId, wellheadId, tundraStrategyWellhead.getWellNumber(), tundraStrategyWellhead.getStartSeq(), startDate);
//关井时间优化 //关井时间优化
if (CollUtil.isNotEmpty(closeList)) { if (CollUtil.isNotEmpty(closeList)) {
//补时间 //补时间
} else { } else {
//todo 不需要补时间,需要优化计算 //不需要补时间,需要优化计算
List<SpaceOptimizeDurationDTO> optimizeDurationDTOList = new ArrayList<>(12); List<SpaceOptimizeDurationDTO> optimizeDurationDTOList = new ArrayList<>(12);
this.timePeriodOptimization(optimizeDurationDTOList, weightDurationList, firstOpenWellTime, wellheadList.size(), this.timePeriodOptimization(optimizeDurationDTOList, weightDurationList, firstOpenWellTime, wellheadList.size(),
startInterval, minOpenMinute, tundraStrategyWellhead, weightList); startInterval, minOpenMinute, tundraStrategyWellhead, weightList);
//创建优化后的间开区间
this.addOptimizeDuration(optimizeDurationDTOList, durationDTOList, tundraStrategyList, periodId, recordId, wellheadId, startDate);
} }
System.out.println();
} }
} }
} }
...@@ -477,6 +418,149 @@ public class SpaceOptimizeShortPeriodService extends SpaceOptimizeBaseService { ...@@ -477,6 +418,149 @@ public class SpaceOptimizeShortPeriodService extends SpaceOptimizeBaseService {
}); });
} }
/**
* 计算权重列表
*
* @param serviceRating 服务等级
* @param rangeToList 要列出范围
* @param powerList 电源列表
* @param strategyList 策略列表
* @return {@link List}<{@link SpaceOptimizeWeight}>
*/
private List<SpaceOptimizeWeight> calculateWeightList(BigDecimal serviceRating, List<DateTime> rangeToList, List<DynamicQueryPlantPredictedPowerOutput> powerList, List<GetBasePriceStrategyDetailOutput> strategyList) {
int rangeListSize = rangeToList.size();
int powerListSize = powerList.size();
int strategyListSize = strategyList.size();
int rangeIndex = 0;
int powerIndex = 0;
int strategyIndex = 0;
List<SpaceOptimizeWeight> weightList = new ArrayList<>(rangeListSize);
DynamicQueryPlantPredictedPowerOutput firstPower;
DynamicQueryPlantPredictedPowerOutput lastPower;
GetBasePriceStrategyDetailOutput firstStrategy;
GetBasePriceStrategyDetailOutput lastStrategy;
while (rangeListSize > 0 && rangeListSize > rangeIndex && powerListSize > powerIndex) {
boolean powerFlag = false;
SpaceOptimizeWeight firstWeight = new SpaceOptimizeWeight();
DateTime firstTime = rangeToList.get(rangeIndex);
firstWeight.setTimestamp(firstTime);
firstWeight.setSort(rangeIndex);
firstPower = powerList.get(powerIndex);
if (0 == firstTime.compareTo(firstPower.getCreateTime())) {
firstWeight.setPower(firstPower.getPower());
//判断发电量是否满足运行功率
powerFlag = firstPower.getPower().compareTo(serviceRating) >= 0;
if (powerFlag) {
firstWeight.setWeight(10);
}
powerIndex++;
}
firstStrategy = strategyList.get(strategyIndex);
Date closeTime = ObjectUtil.isEmpty(firstStrategy.getCloseTime()) && CharSequenceUtil.equals(BusinessConstant.END_OF_DAY_TIME, firstStrategy.getStartTime()) ? BusinessConstant.DATE_FLAG : firstStrategy.getCloseTime();
//在市电峰谷时段内,且未满足运行功率,设置权重
if (DateUtil.isIn(firstTime, firstStrategy.getOpenTime(), closeTime)) {
if (CharSequenceUtil.equals(firstStrategy.getPeriodTypeKey(), "RUSH")) {
//尖峰时段要停井
firstWeight.setWeight(0);
} else if (!powerFlag) {
firstWeight.setWeight(this.getWeightByPeriodTypeKey(firstStrategy.getPeriodTypeKey()));
}
}
if (firstTime.compareTo(firstStrategy.getCloseTime()) >= 0) {
strategyIndex++;
}
weightList.add(firstWeight);
rangeIndex++;
rangeListSize--;
//防止重复插入
if (rangeIndex >= rangeListSize) {
continue;
}
/*----------------------------------------------------*/
powerFlag = false;
SpaceOptimizeWeight lastWeight = new SpaceOptimizeWeight();
DateTime lastTime = rangeToList.get(rangeListSize);
lastWeight.setTimestamp(lastTime);
lastWeight.setSort(rangeListSize);
lastPower = powerList.get(powerListSize - 1);
if (0 == lastTime.compareTo(lastPower.getCreateTime())) {
lastWeight.setPower(lastPower.getPower());
//判断发电量是否满足运行功率
powerFlag = lastPower.getPower().compareTo(serviceRating) >= 0;
if (powerFlag) {
lastWeight.setWeight(10);
}
powerListSize--;
}
lastStrategy = strategyList.get(strategyListSize - 1);
closeTime = ObjectUtil.isEmpty(lastStrategy.getCloseTime()) && CharSequenceUtil.equals(BusinessConstant.END_OF_DAY_TIME, lastStrategy.getEndTime()) ? BusinessConstant.DATE_FLAG : lastStrategy.getCloseTime();
//在市电峰谷时段内,且未满足运行功率,设置权重
if (DateUtil.isIn(lastTime, lastStrategy.getOpenTime(), closeTime)) {
if (CharSequenceUtil.equals(lastStrategy.getPeriodTypeKey(), "RUSH")) {
//尖峰时段要停井
lastWeight.setWeight(0);
} else if (!powerFlag) {
lastWeight.setWeight(this.getWeightByPeriodTypeKey(lastStrategy.getPeriodTypeKey()));
}
}
if (lastTime.compareTo(lastStrategy.getOpenTime()) <= 0) {
strategyListSize--;
}
weightList.add(lastWeight);
}
//排序
weightList.sort(Comparator.comparing(SpaceOptimizeWeight::getSort));
return weightList;
}
/**
* 权重时间处理
*
* @param ladder 梯子
* @param weightList 重量清单
* @param minOpenMinute 最小开放分钟
* @return {@link List}<{@link SpaceOptimizeWeightDuration}>
*/
private List<SpaceOptimizeWeightDuration> weightListProcessing(int[] ladder, List<SpaceOptimizeWeight> weightList, int minOpenMinute) {
SpaceOptimizeWeight weight;
//分级取时间段
List<SpaceOptimizeWeightDuration> weightDurationList = new ArrayList<>(32);
long between;
for (int i1 = 0; i1 < ladder.length; i1++) {
int begin = -1;
//取每级时间
for (int i2 = 0; i2 < weightList.size(); i2++) {
weight = weightList.get(i2);
//过滤条件:权重相同
if (ladder[i1] == weight.getWeight()) {
//确定开始时间位置
if (begin == -1) {
begin = i2;
}
} else if (begin != -1) {
//如果开井时间不满足最小开井时间则舍弃
between = DateUtil.between(weightList.get(begin).getTimestamp(), weightList.get(i2).getTimestamp(), DateUnit.MINUTE);
if (minOpenMinute <= between) {
//创建区间
weightDurationList.add(
SpaceOptimizeWeightDuration.builder()
.openTime(weightList.get(begin).getTimestamp())
.closeTime(weightList.get(i2).getTimestamp())
.openIndex(begin)
.closeIndex(i2)
.duration(between)
.weight(ladder[i1])
.build()
);
}
begin = -1;
}
}
}
//时间处理并排序(处理后第一次开井时间的索引位置为0)
weightDurationList.sort((o1, o2) -> o2.getWeight() - o1.getWeight());
return weightDurationList;
}
/** /**
* 时间段优化 * 时间段优化
...@@ -877,147 +961,82 @@ public class SpaceOptimizeShortPeriodService extends SpaceOptimizeBaseService { ...@@ -877,147 +961,82 @@ public class SpaceOptimizeShortPeriodService extends SpaceOptimizeBaseService {
} }
/** /**
* 计算权重列表 * 添加优化结果
* *
* @param serviceRating 服务等级 * @param optimizeDurationDTOList 优化工期dtolist
* @param rangeToList 要列出范围 * @param durationDTOList 持续时间dtolist
* @param powerList 电源列表 * @param tundraStrategyList 苔原战略清单
* @param strategyList 策略列表 * @param periodId 期间id
* @return {@link List}<{@link SpaceOptimizeWeight}> * @param recordId 记录id
*/ * @param wellheadId 井口id
private List<SpaceOptimizeWeight> calculateWeightList(BigDecimal serviceRating, List<DateTime> rangeToList, List<DynamicQueryPlantPredictedPowerOutput> powerList, List<GetBasePriceStrategyDetailOutput> strategyList) { * @param startDate 开始日期
int rangeListSize = rangeToList.size();
int powerListSize = powerList.size();
int strategyListSize = strategyList.size();
int rangeIndex = 0;
int powerIndex = 0;
int strategyIndex = 0;
List<SpaceOptimizeWeight> weightList = new ArrayList<>(rangeListSize);
DynamicQueryPlantPredictedPowerOutput firstPower;
DynamicQueryPlantPredictedPowerOutput lastPower;
GetBasePriceStrategyDetailOutput firstStrategy;
GetBasePriceStrategyDetailOutput lastStrategy;
while (rangeListSize > 0 && rangeListSize > rangeIndex && powerListSize > powerIndex) {
boolean powerFlag = false;
SpaceOptimizeWeight firstWeight = new SpaceOptimizeWeight();
DateTime firstTime = rangeToList.get(rangeIndex);
firstWeight.setTimestamp(firstTime);
firstWeight.setSort(rangeIndex);
firstPower = powerList.get(powerIndex);
if (0 == firstTime.compareTo(firstPower.getCreateTime())) {
firstWeight.setPower(firstPower.getPower());
//判断发电量是否满足运行功率
powerFlag = firstPower.getPower().compareTo(serviceRating) >= 0;
if (powerFlag) {
firstWeight.setWeight(10);
}
powerIndex++;
}
firstStrategy = strategyList.get(strategyIndex);
Date closeTime = ObjectUtil.isEmpty(firstStrategy.getCloseTime()) && CharSequenceUtil.equals(BusinessConstant.END_OF_DAY_TIME, firstStrategy.getStartTime()) ? BusinessConstant.DATE_FLAG : firstStrategy.getCloseTime();
//在市电峰谷时段内,且未满足运行功率,设置权重
if (DateUtil.isIn(firstTime, firstStrategy.getOpenTime(), closeTime)) {
if (CharSequenceUtil.equals(firstStrategy.getPeriodTypeKey(), "RUSH")) {
//尖峰时段要停井
firstWeight.setWeight(0);
} else if (!powerFlag) {
firstWeight.setWeight(this.getWeightByPeriodTypeKey(firstStrategy.getPeriodTypeKey()));
}
}
if (firstTime.compareTo(firstStrategy.getCloseTime()) >= 0) {
strategyIndex++;
}
weightList.add(firstWeight);
rangeIndex++;
rangeListSize--;
//防止重复插入
if (rangeIndex >= rangeListSize) {
continue;
}
/*----------------------------------------------------*/
powerFlag = false;
SpaceOptimizeWeight lastWeight = new SpaceOptimizeWeight();
DateTime lastTime = rangeToList.get(rangeListSize);
lastWeight.setTimestamp(lastTime);
lastWeight.setSort(rangeListSize);
lastPower = powerList.get(powerListSize - 1);
if (0 == lastTime.compareTo(lastPower.getCreateTime())) {
lastWeight.setPower(lastPower.getPower());
//判断发电量是否满足运行功率
powerFlag = lastPower.getPower().compareTo(serviceRating) >= 0;
if (powerFlag) {
lastWeight.setWeight(10);
}
powerListSize--;
}
lastStrategy = strategyList.get(strategyListSize - 1);
closeTime = ObjectUtil.isEmpty(lastStrategy.getCloseTime()) && CharSequenceUtil.equals(BusinessConstant.END_OF_DAY_TIME, lastStrategy.getEndTime()) ? BusinessConstant.DATE_FLAG : lastStrategy.getCloseTime();
//在市电峰谷时段内,且未满足运行功率,设置权重
if (DateUtil.isIn(lastTime, lastStrategy.getOpenTime(), closeTime)) {
if (CharSequenceUtil.equals(lastStrategy.getPeriodTypeKey(), "RUSH")) {
//尖峰时段要停井
lastWeight.setWeight(0);
} else if (!powerFlag) {
lastWeight.setWeight(this.getWeightByPeriodTypeKey(lastStrategy.getPeriodTypeKey()));
}
}
if (lastTime.compareTo(lastStrategy.getOpenTime()) <= 0) {
strategyListSize--;
}
weightList.add(lastWeight);
}
//排序
weightList.sort(Comparator.comparing(SpaceOptimizeWeight::getSort));
return weightList;
}
/**
* 权重时间处理
*
* @param ladder 梯子
* @param weightList 重量清单
* @param minOpenMinute 最小开放分钟
* @return {@link List}<{@link SpaceOptimizeWeightDuration}>
*/ */
private List<SpaceOptimizeWeightDuration> weightListProcessing(int[] ladder, List<SpaceOptimizeWeight> weightList, int minOpenMinute) { private void addOptimizeDuration(List<SpaceOptimizeDurationDTO> optimizeDurationDTOList, List<SpaceOptimizeDurationDTO> durationDTOList, List<SpaceOptimizeDurationDTO> tundraStrategyList,
SpaceOptimizeWeight weight; String periodId, String recordId, String wellheadId, DateTime startDate) {
//分级取时间段 if (CollUtil.isNotEmpty(optimizeDurationDTOList)) {
List<SpaceOptimizeWeightDuration> weightDurationList = new ArrayList<>(32); //重新按开井时间排序
long between; optimizeDurationDTOList.sort(Comparator.comparing(SpaceOptimizeDurationDTO::getOpenTime));
for (int i1 = 0; i1 < ladder.length; i1++) { SpaceOptimizeDurationDTO durationDTO;
int begin = -1; for (int i1 = 0; i1 < optimizeDurationDTOList.size(); i1++) {
//取每级时间 durationDTO = optimizeDurationDTOList.get(i1);
for (int i2 = 0; i2 < weightList.size(); i2++) { DateTime startOffset = DateUtil.date(durationDTO.getOpenTime());
weight = weightList.get(i2); DateTime endOffset = DateUtil.date(durationDTO.getCloseTime());
//过滤条件:权重相同 if (startOffset.compareTo(BusinessConstant.DATE_FLAG) < 0 && endOffset.compareTo(BusinessConstant.DATE_FLAG) > 0) {
if (ladder[i1] == weight.getWeight()) { //如果时间超过当天,舍弃
//确定开始时间位置 this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
if (begin == -1) { startOffset.toString(BusinessConstant.MINUTES_FORMAT),
begin = i2; BusinessConstant.END_OF_DAY_TIME,
} BusinessConstant.ONE, startDate
} else if (begin != -1) { );
//如果开井时间不满足最小开井时间则舍弃 this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
between = DateUtil.between(weightList.get(begin).getTimestamp(), weightList.get(i2).getTimestamp(), DateUnit.MINUTE); BusinessConstant.START_OF_DAY_TIME,
if (minOpenMinute <= between) { endOffset.toString(BusinessConstant.MINUTES_FORMAT),
//创建区间 BusinessConstant.ONE, startDate
weightDurationList.add( );
SpaceOptimizeWeightDuration.builder() tundraStrategyList.add(
.openTime(weightList.get(begin).getTimestamp()) SpaceOptimizeDurationDTO.builder()
.closeTime(weightList.get(i2).getTimestamp()) .wellheadId(wellheadId)
.openIndex(begin) .openTime(startOffset)
.closeIndex(i2) .closeTime(BusinessConstant.DATE_FLAG)
.duration(between) .build()
.weight(ladder[i1]) );
.build() tundraStrategyList.add(
); SpaceOptimizeDurationDTO.builder()
} .wellheadId(wellheadId)
begin = -1; .openTime(BusinessConstant.DATE_FLAG_BEGIN)
.closeTime(endOffset)
.build()
);
} else if (endOffset.compareTo(BusinessConstant.DATE_FLAG) == 0) {
this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
startOffset.toString(BusinessConstant.MINUTES_FORMAT),
BusinessConstant.END_OF_DAY_TIME,
BusinessConstant.ONE, startDate
);
tundraStrategyList.add(
SpaceOptimizeDurationDTO.builder()
.wellheadId(wellheadId)
.openTime(startOffset)
.closeTime(BusinessConstant.DATE_FLAG)
.build()
);
} else {
//计算偏移
this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
startOffset.toString(BusinessConstant.MINUTES_FORMAT),
endOffset.toString(BusinessConstant.MINUTES_FORMAT),
BusinessConstant.ONE, startDate
);
tundraStrategyList.add(
SpaceOptimizeDurationDTO.builder()
.wellheadId(wellheadId)
.openTime(startOffset)
.closeTime(endOffset)
.build()
);
} }
} }
} }
//时间处理并排序(处理后第一次开井时间的索引位置为0)
weightDurationList.sort((o1, o2) -> o2.getWeight() - o1.getWeight());
return weightDurationList;
} }
/** /**
......
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