on.nemtina/DD.WellWorkover.Cloud
1
0
Fork 0
forked from ddrilling/AsbCloudServer
Code Pull Requests Activity

ProcessMapReportService implement all calculations (not tested)

Browse Source
This commit is contained in:
ngfrolov 2023-04-05 13:36:56 +05:00
parent 08e3e34162
commit 1f904a7434
Signed by: ng.frolov
GPG Key ID: E99907A0357B29A7
3 changed files with 280 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AsbCloudApp/Data/SAUB/TelemetryDataSaubStatDto.cs
View File

@ -100,7 +100,7 @@ namespace AsbCloudApp.Data.SAUB
/// <summary>
/// Режим САУБ
/// </summary>
public short Mode { get; set; }
public short IdMode { get; set; }
/// <summary>
/// Текущий критерий бурения

319
AsbCloudInfrastructure/Services/ProcessMap/ProcessMapReportService.cs
View File

@ -1,13 +1,8 @@
using AsbCloudApp.Data;
using AsbCloudApp.Data.ProcessMap;
using AsbCloudApp.Data.ProcessMap;
using AsbCloudApp.Data.SAUB;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudApp.Services.Subsystems;
using AsbCloudDb.Model;
using AsbCloudApp.Data.Subsystems;
using System;
using System.Collections.Generic;
using System.Linq;
@ -23,23 +18,17 @@ namespace AsbCloudInfrastructure.Services.ProcessMap
private readonly IWellOperationRepository wellOperationRepository;
private readonly IProcessMapPlanRepository processMapPlanRepository;
private readonly ITelemetryDataSaubService telemetryDataSaubService;
private readonly ILimitingParameterRepository limitingParameterRepository;
private readonly ISubsystemOperationTimeService subsystemOperationTimeService;
public ProcessMapReportService(
IWellService wellService,
IWellOperationRepository wellOperationService,
IWellOperationRepository wellOperationRepository,
IProcessMapPlanRepository processMapPlanRepository,
ITelemetryDataSaubService telemetryDataSaubService,
ILimitingParameterRepository limitingParameterRepository,
ISubsystemOperationTimeService subsystemOperationTimeService)
ITelemetryDataSaubService telemetryDataSaubService)
{
this.wellService = wellService;
this.wellOperationRepository = wellOperationService;
this.wellOperationRepository = wellOperationRepository;
this.processMapPlanRepository = processMapPlanRepository;
this.telemetryDataSaubService = telemetryDataSaubService;
this.limitingParameterRepository = limitingParameterRepository;
this.subsystemOperationTimeService = subsystemOperationTimeService;
}
/// <inheritdoc/>
@ -53,50 +42,298 @@ namespace AsbCloudInfrastructure.Services.ProcessMap
var processMapPlan = await processMapPlanRepository.GetByIdWellAsync(idWell, token);
if(!processMapPlan.Any())
if (!processMapPlan.Any())
return Enumerable.Empty<ProcessMapReportDto>();
var telemetryDataStat = await telemetryDataSaubService.GetTelemetryDataStatAsync(idTelemetry, token);
var telemetryDataStat = (await telemetryDataSaubService.GetTelemetryDataStatAsync(idTelemetry, token)).ToArray();
if (!telemetryDataStat.Any())
return Enumerable.Empty<ProcessMapReportDto>();
var result = CalcByIntervals(processMapPlan, telemetryDataStat);
return result;
}
private IEnumerable<ProcessMapReportDto> CalcByIntervals(IEnumerable<ProcessMapPlanDto> processMapPlan, IEnumerable<TelemetryDataSaubStatDto> telemetryDataStat)
private IEnumerable<ProcessMapReportDto> CalcByIntervals(IEnumerable<ProcessMapPlanDto> processMapPlan, TelemetryDataSaubStatDto[] telemetryDataStat)
{
var result = new List<ProcessMapReportDto>(processMapPlan.Count() * 4);
var intervals = GetProcessMapIntervals(processMapPlan);
var processMapIntervals = processMapPlan
.Select(p => (p.DepthStart, p.DepthEnd))
.Distinct()
.OrderBy(i => i.DepthStart);
var result = new List<ProcessMapReportDto>(processMapIntervals.Count() * 4);
var telemetryIndexStart = Array.FindIndex(telemetryDataStat, t => t.WellDepthMin >= processMapIntervals.First().DepthStart);
if (telemetryIndexStart < 0)
return Enumerable.Empty<ProcessMapReportDto>();
IDictionary<int, string> sectionTypes = wellOperationRepository.GetSectionTypes();
foreach (var interval in processMapIntervals)
{
var processMapPlanInterval = processMapPlan
.Where(p => p.DepthStart >= interval.DepthStart && p.DepthEnd <= interval.DepthEnd);
var telemetryIndexEnd = Array.FindIndex(telemetryDataStat, telemetryIndexStart, t => t.WellDepthMin >= interval.DepthEnd);
var telemetryDataInterval = telemetryDataStat.AsSpan(telemetryIndexStart, telemetryIndexEnd - telemetryIndexStart);
IEnumerable<ProcessMapReportDto> subIntervalsResult = CalcSubIntervals(interval, processMapPlanInterval, telemetryDataInterval, sectionTypes);
result.AddRange(subIntervalsResult);
telemetryIndexStart = telemetryIndexEnd;
}
return result;
}
private IEnumerable<(double, double)> GetProcessMapIntervals(IEnumerable<ProcessMapPlanDto> processMapPlan)
private IEnumerable<ProcessMapReportDto> CalcSubIntervals(
(double DepthStart, double DepthEnd) interval,
IEnumerable<ProcessMapPlanDto> processMapPlanInterval,
Span<TelemetryDataSaubStatDto> telemetryDataInterval,
IDictionary<int, string> sectionTypes)
{
return Enumerable.Empty<(double, double)>();
}
var telemetryDataIntervalLength = telemetryDataInterval.Length;
if (telemetryDataInterval.Length == 0)
return Enumerable.Empty<ProcessMapReportDto>();
private static DateTime GetInterpolatedDate(WellOperationDto operation, double depth)
{
var ratio = (depth - operation.DepthStart) / (operation.DepthEnd - operation.DepthStart);
var deltaHours = operation.DurationHours * ratio;
var interpolatedDate = operation.DateStart + TimeSpan.FromHours(deltaHours);
return interpolatedDate;
}
var result = new List<ProcessMapReportDto>();
var telemetryIndexStart = 0;
var subInterval = interval;
private static IEnumerable<(double min, double max)> SplitByIntervals(double min, double max)
{
const double step = 100;
var iMin = min;
var iMax = (1 + (int)(min / step)) * step;
for (; iMax < max; iMax += step)
for (var i = telemetryIndexStart; i < telemetryDataIntervalLength; i++)
{
yield return (iMin, iMax);
iMin = iMax;
if (!IsSimilar(telemetryDataInterval[telemetryIndexStart], telemetryDataInterval[i]))
{
subInterval.DepthEnd = telemetryDataInterval[i].WellDepthMax;
var intervalReportRow = CalcSubIntervalReportRow(subInterval, processMapPlanInterval, telemetryDataInterval[telemetryIndexStart..i], sectionTypes);
result.Add(intervalReportRow);
telemetryIndexStart = i;
subInterval.DepthStart = subInterval.DepthEnd;
}
}
yield return (iMin, max);
subInterval.DepthEnd = interval.DepthEnd;
var intervalReportRowLast = CalcSubIntervalReportRow(subInterval, processMapPlanInterval, telemetryDataInterval[telemetryIndexStart..telemetryDataIntervalLength], sectionTypes);
result.Add(intervalReportRowLast);
return result;
}
private ProcessMapReportDto CalcSubIntervalReportRow(
(double DepthStart, double DepthEnd) subInterval,
IEnumerable<ProcessMapPlanDto> processMap,
Span<TelemetryDataSaubStatDto> telemetryRowSpan,
IDictionary<int, string> sectionTypes)
{
var telemetryFirst = telemetryRowSpan[0];
var telemetryLast = telemetryRowSpan[^1];
var mode = GetIdMode(telemetryRowSpan);
var processMapByMode = processMap.FirstOrDefault(p => p.IdMode == mode.IdMode);
var processMapFirst = processMap.First();
var idWellSectionType = processMapByMode?.IdWellSectionType ?? processMapFirst.IdWellSectionType;
var telemetryStat = AnalyzeTelemetry(telemetryRowSpan);
var result = new ProcessMapReportDto
{
IdWell = processMapByMode?.IdWell ?? processMapFirst.IdWell,
IdWellSectionType = idWellSectionType,
WellSectionTypeName = sectionTypes[idWellSectionType],
DepthStart = subInterval.DepthStart,
DepthEnd = subInterval.DepthEnd,
DateStart = telemetryFirst.DateMin,
MechDrillingHours = (telemetryLast.DateMax - telemetryFirst.DateMin).TotalHours,
DrillingMode = mode.ModeName,
DeltaDepth = telemetryLast.WellDepthMax - telemetryFirst.WellDepthMin,
PressureDiff = telemetryStat.Pressure.MakeParams(processMapByMode?.Pressure.Plan),
AxialLoad = telemetryStat.AxialLoad.MakeParams(processMapByMode?.AxialLoad.Plan),
TopDriveTorque = telemetryStat.RotorTorque.MakeParams(processMapByMode?.TopDriveTorque.Plan),
SpeedL​imit = telemetryStat.BlockSpeed.MakeParams(processMapByMode?.RopPlan),
Rop = telemetryStat.Rop,
Usage = telemetryStat.UsageSaub,
};
return result;
}
private static TelemetryStat AnalyzeTelemetry(Span<TelemetryDataSaubStatDto> telemetry)
{
var stat = new TelemetryStat();
for (int i = 0; i < telemetry.Length; i++)
stat.UpdateStat(telemetry[i]);
return stat;
}
private static (int IdMode, string ModeName) GetIdMode(Span<TelemetryDataSaubStatDto> telemetryRowSpan)
{
/// Режим работы САУБ в телеметрии:
/// 0 - "РУЧНОЙ"
/// 1 - "БУРЕНИЕ В РОТОРЕ"
/// 3 - "БУРЕНИЕ В СЛАЙДЕ"
for (int i = 0; i < telemetryRowSpan.Length; i++)
{
var idMode = telemetryRowSpan[i].IdMode;
if (idMode == 0)
return (0, "Ручной");
if (idMode == 1)
return (1, "Ротор");
if (idMode == 3)
return (2, "Слайд");
}
return (0, "Ручной");
}
private static bool IsSimilar(TelemetryDataSaubStatDto telemetry1, TelemetryDataSaubStatDto telemetry2)
{
if (telemetry1.IdMode != telemetry2.IdMode)
return false;
if (Math.Abs(telemetry1.PressureSp - telemetry2.PressureSp) > 5d)
return false;
if (Math.Abs(telemetry1.AxialLoadSp - telemetry2.AxialLoadSp) > 1d)
return false;
if (Math.Abs(telemetry1.RotorTorqueSp - telemetry2.RotorTorqueSp) > 5d)
return false;
var blockSpeedSpDiff = Math.Abs(telemetry1.BlockSpeedSp - telemetry2.BlockSpeedSp);
if (blockSpeedSpDiff > 5d)
{
if (telemetry1.BlockSpeedSp < 30)
return false;
else if (telemetry1.BlockSpeedSp > 30 && blockSpeedSpDiff > 15d)
return false;
else if (telemetry1.BlockSpeedSp > 80 && blockSpeedSpDiff > 20d)
return false;
}
return true;
}
}
class ParamStat
{
private double spWSum;
private double pvWSum;
private double? limitMaxWSum;
private double spUsageDepth;
private double deltaDepthSum;
private readonly Func<TelemetryDataSaubStatDto, double> getterSp;
private readonly Func<TelemetryDataSaubStatDto, double> getterPv;
private readonly Func<TelemetryDataSaubStatDto, double>? getterLimitMax;
private readonly int idFeedRegulator;
private TelemetryDataSaubStatDto? previous;
public ParamStat(Func<TelemetryDataSaubStatDto, double> getterSp,
Func<TelemetryDataSaubStatDto, double> getterPv,
Func<TelemetryDataSaubStatDto, double>? getterLimitMax,
int idFeedRegulator)
{
this.getterSp = getterSp;
this.getterPv = getterPv;
this.getterLimitMax = getterLimitMax;
this.idFeedRegulator = idFeedRegulator;
}
public void UpdateStat(TelemetryDataSaubStatDto current)
{
if(previous is not null)
{
var deltaDepth = current.WellDepthMin - previous.WellDepthMin;
if (deltaDepth > 0)
{
var deltaDepthHalf = deltaDepth / 2;
double CalculateWeight(Func<TelemetryDataSaubStatDto, double> getter) => (getter(previous!) + getter(current)) * deltaDepthHalf;
spWSum = CalculateWeight(getterSp);
pvWSum = CalculateWeight(getterPv);
if(getterLimitMax is not null)
limitMaxWSum = CalculateWeight(getterLimitMax!);
if (current.IdFeedRegulator == idFeedRegulator)
spUsageDepth += deltaDepth;
deltaDepthSum += deltaDepth;
}
}
previous = current;
}
public ProcessMapReportParamsDto MakeParams(double? spPlan)
=> new ProcessMapReportParamsDto
{
SetpointPlan = spPlan,
SetpointFact = spWSum / deltaDepthSum,
Fact = pvWSum / deltaDepthSum,
Limit = limitMaxWSum / deltaDepthSum,
PercDrillingBySetpoint = spUsageDepth / deltaDepthSum,
};
}
class TelemetryStat {
public ParamStat Pressure { get; }
public ParamStat AxialLoad {get; }
public ParamStat RotorTorque {get; }
public ParamStat BlockSpeed {get; }
private TelemetryDataSaubStatDto? previous;
private double depthSum = 0d;
private double hoursSum = 0d;
public double Rop => depthSum / hoursSum;
private double depthWithSaub = 0d;
public double UsageSaub => depthWithSaub / depthSum;
public TelemetryStat()
{
BlockSpeed = new(t => t.BlockSpeedSp, t => t.BlockSpeed, null, 1);
Pressure = new(t => t.PressureSp, t => t.Pressure, t=>t.PressureDeltaLimitMax, 2);
RotorTorque = new(t => t.RotorTorqueSp, t => t.RotorTorque, t=>t.RotorTorqueLimitMax, 3);
AxialLoad = new(t => t.AxialLoadSp, t => t.AxialLoad, t=>t.AxialLoadLimitMax, 4);
}
public void UpdateStat(TelemetryDataSaubStatDto current)
{
if(previous is not null)
{
var deltaDepth = current.WellDepthMin - previous.WellDepthMin;
if(deltaDepth > 0)
{
var deltaHours = (current.DateMin - previous.DateMax).TotalHours;
depthSum += deltaDepth;
hoursSum += deltaHours;
if(current.IdMode == 1 || current.IdMode == 3)
depthWithSaub += deltaDepth;
}
}
previous = current;
Pressure.UpdateStat(current);
AxialLoad.UpdateStat(current);
RotorTorque.UpdateStat(current);
BlockSpeed.UpdateStat(current);
}
};
#nullable disable
}

2
AsbCloudInfrastructure/Services/SAUB/TelemetryDataSaubService.cs
View File

@ -42,9 +42,9 @@ namespace AsbCloudInfrastructure.Services.SAUB
.Where(t => t.IdTelemetry == idTelemetry)
.Where(t => t.BlockPosition > 0.0001)
.Where(t => t.WellDepth > 0.0001)
.Where(t => t.WellDepth - t.BitDepth < 0.01)
.Where(t => t.Mode != null)
.Where(t => modes.Contains(t.Mode.Value))
.Where(t => t.WellDepth - t.BitDepth < 0.01)
.GroupBy(t => new {
t.DateTime.Hour,
WellDepthX10 = Math.Truncate(t.WellDepth!.Value * 10),