|
|
// <copyright file="WellDeflectionHelp.cs" company="jindongfang">
|
|
|
// Copyright (c) jindongfang. All rights reserved.
|
|
|
// </copyright>
|
|
|
|
|
|
|
|
|
//using MessagePack;
|
|
|
using SqlSugar;
|
|
|
using System;
|
|
|
using System.Collections.Concurrent;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Data;
|
|
|
using System.Diagnostics;
|
|
|
using System.IO;
|
|
|
using System.Linq;
|
|
|
using System.Threading.Tasks;
|
|
|
using WorkData;
|
|
|
using WorkData.Entity;
|
|
|
|
|
|
namespace WellWorkDataUI
|
|
|
{
|
|
|
public static class DataTableExtensions
|
|
|
{
|
|
|
/// <summary>
|
|
|
/// Indexes the specified row.
|
|
|
/// </summary>
|
|
|
/// <param name="row">The row.</param>
|
|
|
/// <returns>System.Int32.</returns>
|
|
|
public static int Index(this DataRow row)
|
|
|
{
|
|
|
if (row.Table != null)
|
|
|
{
|
|
|
return row.Table.Rows.IndexOf(row);
|
|
|
}
|
|
|
|
|
|
return -1;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// Converts the list to data table.
|
|
|
/// </summary>
|
|
|
/// <param name="list">The list.</param>
|
|
|
/// <returns>A DataTable.</returns>
|
|
|
public static DataTable ConvertListToDataTable<T>(this List<T> list)
|
|
|
{
|
|
|
DataTable table = new DataTable();
|
|
|
if (list.Count > 0)
|
|
|
{
|
|
|
var properties = typeof(T).GetProperties();
|
|
|
foreach (var prop in properties)
|
|
|
{
|
|
|
table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);
|
|
|
}
|
|
|
|
|
|
foreach (var item in list)
|
|
|
{
|
|
|
DataRow row = table.NewRow();
|
|
|
foreach (var prop in properties)
|
|
|
{
|
|
|
row[prop.Name] = prop.GetValue(item) ?? DBNull.Value;
|
|
|
}
|
|
|
table.Rows.Add(row);
|
|
|
}
|
|
|
}
|
|
|
return table;
|
|
|
}
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 井斜计算工具
|
|
|
/// </summary>
|
|
|
public class WellDeflectionHelp
|
|
|
{
|
|
|
private SimpleWell[] wells;
|
|
|
private SimpleDeflection[] sysDeflections;
|
|
|
|
|
|
// private List<string> OrderDictKey = new List<string>();
|
|
|
// private Dictionary<string, SimpleDeflection[]> sysDeflectionsDict = new Dictionary<string, SimpleDeflection[]>();
|
|
|
/// <summary>
|
|
|
/// Initializes a new instance of the <see cref="WellDeflectionHelp"/> class.
|
|
|
/// </summary>
|
|
|
public WellDeflectionHelp()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
private static void FunRadius(double i1, double a1, double p, double i2, double a2, double md, out double northSec, out double eastSec, out double tvdSec)
|
|
|
{
|
|
|
northSec = md * (Math.Cos(i1) - Math.Cos(i2)) * (Math.Sin(a2) - Math.Sin(a1))
|
|
|
/ ((i2 - i1) * (a2 - a1)) * (180 / Math.PI) * (180 / Math.PI);
|
|
|
eastSec = md * (Math.Cos(i1) - Math.Cos(a1 * p)) * (Math.Cos(a1) - Math.Cos(a2))
|
|
|
/ ((i2 - i1) * (a2 - a1)) * (180 / Math.PI) * (180 / Math.PI);
|
|
|
tvdSec = md / 2 * (Math.Sin(i2) - Math.Sin(i1)) / (i2 - i1) * (180 / Math.PI);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 井斜计算，最小曲率法
|
|
|
/// </summary>
|
|
|
/// <param name="wellName">井号</param>
|
|
|
/// <returns>是否成功</returns>
|
|
|
public static List<WellDeflection> ComputedTrackCurvature(string wellName)
|
|
|
{
|
|
|
// 先从数据库中获取到井斜文件数据
|
|
|
WellDeflection wd = DBHelp.NewDb.Queryable<WellDeflection>().Where(w => w.JH == wellName).First();
|
|
|
if (wd == null || string.IsNullOrWhiteSpace(wd.FileName))
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
string fileName = wd.FileName;
|
|
|
|
|
|
List<WellDeflection> deflections = EntityHelp.GetWellDeflections(fileName);
|
|
|
if (deflections == null || !deflections.Any())
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
//修复计算井斜有问题 bug禅道 421 井斜轨迹计算数据不从0开始计算出的数据是错误的
|
|
|
WellDeflection firstDeflection = deflections.FirstOrDefault();
|
|
|
//if (firstDeflection != null && firstDeflection.JS != 0 && firstDeflection.JXJ != 0 && firstDeflection.FWJ != 0)
|
|
|
if (firstDeflection != null)
|
|
|
{
|
|
|
WellDeflection deflectUppers = new WellDeflection()
|
|
|
{
|
|
|
JH = wellName,
|
|
|
JS = 0,
|
|
|
JXJ = 0,
|
|
|
FWJ = 0,
|
|
|
};
|
|
|
deflections.Insert(0, deflectUppers);
|
|
|
|
|
|
WellDeflection deflectUpper = new WellDeflection()
|
|
|
{
|
|
|
JH = wellName,
|
|
|
JS = 0,// -146.65,
|
|
|
JXJ = 0,
|
|
|
FWJ = 0,
|
|
|
BZB = 0,
|
|
|
DZB = 0,
|
|
|
CS = 0,
|
|
|
};
|
|
|
double md1 = deflectUpper.JS.Value; //deflectUpper.JS.Value; // 测深
|
|
|
double i1 = deflectUpper.JXJ.Value; //deflectUpper.JXJ.Value; // 井斜角
|
|
|
double a1 = deflectUpper.FWJ.Value; //deflectUpper.FWJ.Value; // 方位角
|
|
|
double north = deflectUpper.BZB.Value; // 北坐标
|
|
|
double east = deflectUpper.DZB.Value; // 东坐标
|
|
|
double tvd = deflectUpper.JS.Value; //; deflectUpper.CS.Value; // 垂深
|
|
|
|
|
|
double md2; // = deflections[0].JS.Value;
|
|
|
double i2; // = deflections[0].JXJ.Value;
|
|
|
double a2; // = deflections[0].FWJ.Value;
|
|
|
|
|
|
double northSec0 = 0, eastSec0 = 0, tvdSec0 = 0;
|
|
|
|
|
|
int nCount = deflections.Count;
|
|
|
for (int i = 0; i < nCount; i++)
|
|
|
{
|
|
|
if (!deflections[i].JXJ.HasValue || !deflections[i].FWJ.HasValue || !deflections[i].JS.HasValue)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
md2 = deflections[i].JS.Value;
|
|
|
i2 = deflections[i].JXJ.Value;
|
|
|
a2 = deflections[i].FWJ.Value;
|
|
|
double northSec, eastSec, tvdSec;
|
|
|
FunCurvature(md1, i1, a1, md2, i2, a2, out northSec, out eastSec, out tvdSec);
|
|
|
|
|
|
if (i == 0)
|
|
|
{
|
|
|
northSec0 = northSec;
|
|
|
eastSec0 = eastSec;
|
|
|
tvdSec0 = tvdSec - md2;
|
|
|
}
|
|
|
|
|
|
north += northSec;
|
|
|
east += eastSec;
|
|
|
tvd += tvdSec;
|
|
|
|
|
|
deflections[i].BZB = north - northSec0;
|
|
|
deflections[i].DZB = east - eastSec0;
|
|
|
deflections[i].CS = tvd - tvdSec0;
|
|
|
|
|
|
md1 = md2;
|
|
|
i1 = i2;
|
|
|
a1 = a2;
|
|
|
}
|
|
|
|
|
|
return deflections;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
}
|
|
|
private static double NEWARSET_TO_1 = 0.999995;
|
|
|
/// <summary>
|
|
|
/// Fun the curvature.
|
|
|
/// </summary>
|
|
|
/// <param name="md1">The md1.</param>
|
|
|
/// <param name="i1">The i1.</param>
|
|
|
/// <param name="a1">The a1.</param>
|
|
|
/// <param name="md2">The md2.</param>
|
|
|
/// <param name="i2">The i2.</param>
|
|
|
/// <param name="a2">The a2.</param>
|
|
|
/// <param name="northSec">The north sec.</param>
|
|
|
/// <param name="eastSec">The east sec.</param>
|
|
|
/// <param name="tvdSec">The tvd sec.</param>
|
|
|
private static void FunCurvature(double md1, double i1, double a1, double md2, double i2, double a2, out double northSec, out double eastSec, out double tvdSec)
|
|
|
{
|
|
|
double p = Math.PI / 180;
|
|
|
i1 = i1 * p;
|
|
|
a1 = a1 * p;
|
|
|
i2 = i2 * p;
|
|
|
a2 = a2 * p;
|
|
|
|
|
|
double dL = md2 - md1;
|
|
|
double dCosE = (Math.Cos(i1) * Math.Cos(i2)) + (Math.Sin(i1) * Math.Sin(i2) * Math.Cos(a2 - a1));
|
|
|
double dR = 0;
|
|
|
if (dCosE >= NEWARSET_TO_1 || dCosE <= NEWARSET_TO_1)
|
|
|
{
|
|
|
dR = 0.5;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
double dE = Math.Acos(dCosE);
|
|
|
dR = Math.Tan(dE / 2) / dE;
|
|
|
}
|
|
|
|
|
|
northSec = ((Math.Sin(i1) * Math.Cos(a1)) + (Math.Sin(i2) * Math.Cos(a2))) * dL * dR;
|
|
|
eastSec = ((Math.Sin(i1) * Math.Sin(a1)) + (Math.Sin(i2) * Math.Sin(a2))) * dL * dR;
|
|
|
tvdSec = (Math.Cos(i1) + Math.Cos(i2)) * dL * dR;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// Initializes the.
|
|
|
/// </summary>
|
|
|
/// <param name="wellName">The well name.</param>
|
|
|
/// <param name="simpleWells">The simple well name.</param>
|
|
|
/// <param name="simpleDeflections">SimpleDeflection</param>
|
|
|
/// <returns>A bool.</returns>
|
|
|
public bool Initialize(string wellName, SimpleWell[] simpleWells, SimpleDeflection[] simpleDeflections)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
this.wells = simpleWells.ToArray();
|
|
|
this.sysDeflections = simpleDeflections.ToArray();
|
|
|
//DBHelp.Db.Queryable<WellDeflection>().Select(it => new SimpleDeflection
|
|
|
//{
|
|
|
// JH = it.JH,
|
|
|
// BZB = it.BZB ?? 0,
|
|
|
// DZB = it.DZB ?? 0,
|
|
|
// JS = it.JS.Value,
|
|
|
// CS = it.CS ?? 0,
|
|
|
//}).Where(it => it.JH == wellName).ToArray();
|
|
|
return true;
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"~~~~~~~~~~~~~~执行 Initialize 异常：{ex.Message}~~~~~~~~~~~~~~");
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 数据准备
|
|
|
/// </summary>
|
|
|
/// <returns>是否成功</returns>
|
|
|
public bool Initialize()
|
|
|
{
|
|
|
Stopwatch stopwatch = new Stopwatch();
|
|
|
stopwatch.Start();
|
|
|
this.wells = DBHelp.NewDb.Queryable<WellBase>()
|
|
|
.Select(it => new SimpleWell() { JH = it.JH, X = it.X.Value, Y = it.Y.Value })
|
|
|
.Where(it => it.X > 0 && it.Y > 0).ToList()
|
|
|
.OrderBy(it => it.JH)
|
|
|
.ToArray();
|
|
|
Console.WriteLine($"初始化井基础,{stopwatch.Elapsed.TotalMilliseconds}");
|
|
|
ConcurrentBag<SimpleDeflection> sds = new ConcurrentBag<SimpleDeflection>();
|
|
|
// 查询所有井斜
|
|
|
var wds = DBHelp.NewDb.Queryable<WellDeflection>().ToList();
|
|
|
if (wds.Any())
|
|
|
{
|
|
|
Parallel.ForEach(wds, EntityHelp.Options, item =>
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
List<WellDeflection> itemDatas = EntityHelp.GetWellDeflections(item.FileName);
|
|
|
for (var i = 0; i < itemDatas.Count; i++)
|
|
|
{
|
|
|
var itemData = itemDatas[i];
|
|
|
sds.Add(new SimpleDeflection
|
|
|
{
|
|
|
JH = itemData.JH,
|
|
|
BZB = itemData.BZB ?? 0,
|
|
|
DZB = itemData.DZB ?? 0,
|
|
|
JS = itemData.JS.Value,
|
|
|
CS = itemData.CS ?? 0,
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"获取文件[{item.FileName}]数据异常：{ex.Message}");
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
if (sds.Any())
|
|
|
{
|
|
|
this.sysDeflections = sds.ToArray();
|
|
|
}
|
|
|
|
|
|
Console.WriteLine($"初始化井斜数据,{stopwatch.Elapsed.TotalMilliseconds}");
|
|
|
|
|
|
Console.WriteLine($"初始化井斜,{stopwatch.Elapsed.TotalMilliseconds}");
|
|
|
stopwatch.Stop();
|
|
|
Console.WriteLine($"初始化井斜字典,{stopwatch.Elapsed.TotalMilliseconds}");
|
|
|
return true;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 快速查找
|
|
|
/// </summary>
|
|
|
/// <param name="wells">正向排序的井几何</param>
|
|
|
/// <param name="wellName">要查找的井</param>
|
|
|
/// <returns>查找到的索引</returns>
|
|
|
private int FindWellIndex(SimpleWell[] wells, string wellName)
|
|
|
{
|
|
|
//利用二分法快速定位
|
|
|
int num = wells.Length;
|
|
|
if (num == 0)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
int start = 0;
|
|
|
int stop = num - 1;
|
|
|
|
|
|
if (wells[start].JH.Equals(wellName))
|
|
|
{
|
|
|
return start;
|
|
|
}
|
|
|
if (wells[stop].JH.Equals(wellName))
|
|
|
{
|
|
|
return stop;
|
|
|
}
|
|
|
|
|
|
//if (z < colset[0].z) return -10;
|
|
|
//if (z > colset[num - 1].z) return num + 10;
|
|
|
int midle;
|
|
|
while (stop - start > 1)
|
|
|
{
|
|
|
midle = (start + stop) / 2;
|
|
|
if (string.CompareOrdinal(wellName, wells[midle].JH) < 0)
|
|
|
{
|
|
|
stop = midle;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
start = midle;
|
|
|
}
|
|
|
}
|
|
|
if (wellName == wells[stop].JH)
|
|
|
{
|
|
|
return stop;
|
|
|
}
|
|
|
return start;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 查找井斜数据
|
|
|
/// </summary>
|
|
|
/// <param name="deflections">井斜数据</param>
|
|
|
/// <param name="wellName">井号</param>
|
|
|
/// <param name="js">目的井深</param>
|
|
|
/// <param name="opType">查找方式,0-查找上方，1查找下方</param>
|
|
|
/// <returns>查找结果</returns>
|
|
|
private SimpleDeflection FindDeflection(SimpleDeflection[] deflections, string wellName, double js, int opType)
|
|
|
{
|
|
|
int num = deflections.Length;
|
|
|
if (num == 0)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
int start = 0;
|
|
|
int stop = num - 1;
|
|
|
if (deflections[start].JH.Equals(wellName))
|
|
|
{
|
|
|
if (opType == 0)
|
|
|
{
|
|
|
return SearchUpperInWells(deflections, start, wellName, js);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return SearchDownerInWells(deflections, start, wellName, js);
|
|
|
}
|
|
|
}
|
|
|
if (deflections[stop].JH.Equals(wellName))
|
|
|
{
|
|
|
if (opType == 0)
|
|
|
{
|
|
|
return SearchUpperInWells(deflections, stop, wellName, js);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return SearchDownerInWells(deflections, stop, wellName, js);
|
|
|
}
|
|
|
}
|
|
|
int midle;
|
|
|
while (stop - start > 1)
|
|
|
{
|
|
|
midle = (start + stop) / 2;
|
|
|
if (string.CompareOrdinal(wellName, deflections[midle].JH) < 0)
|
|
|
{
|
|
|
stop = midle;
|
|
|
}
|
|
|
else if (wellName.CompareTo(deflections[midle].JH) == 0)
|
|
|
{
|
|
|
stop = midle;
|
|
|
break;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
start = midle;
|
|
|
}
|
|
|
}
|
|
|
if (wellName == deflections[stop].JH)
|
|
|
{
|
|
|
if (opType == 0)
|
|
|
{
|
|
|
return SearchUpperInWells(deflections, stop, wellName, js);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return SearchDownerInWells(deflections, stop, wellName, js);
|
|
|
}
|
|
|
}
|
|
|
// TODO：可以使用插值二分法
|
|
|
SimpleDeflection SearchUpperInWells(SimpleDeflection[] sourceDeflections, int middleIndex, string wellNameDes, double jsDes)
|
|
|
{
|
|
|
int numSource = sourceDeflections.Length;
|
|
|
double dJSCur = sourceDeflections[middleIndex].JS;
|
|
|
if (dJSCur > jsDes)
|
|
|
{ // 向上查找
|
|
|
for (int i = middleIndex; i >= 0; i--)
|
|
|
{
|
|
|
if (sourceDeflections[i].JH != wellNameDes)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
if (sourceDeflections[i].JS <= jsDes)
|
|
|
{
|
|
|
return sourceDeflections[i];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (dJSCur < jsDes)
|
|
|
{
|
|
|
for (int i = middleIndex; i < numSource; i++)
|
|
|
{
|
|
|
if (sourceDeflections[i].JH != wellNameDes)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
if (sourceDeflections[i].JS > jsDes)
|
|
|
{
|
|
|
return sourceDeflections[i - 1];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return sourceDeflections[middleIndex];
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
SimpleDeflection SearchDownerInWells(SimpleDeflection[] sourceDeflections, int middleIndex, string wellNameDes, double jsDes)
|
|
|
{
|
|
|
int numSource = sourceDeflections.Length;
|
|
|
double dJSCur = sourceDeflections[middleIndex].JS;
|
|
|
if (dJSCur > jsDes)
|
|
|
{ // 向上查找
|
|
|
for (int i = middleIndex; i >= 0; i--)
|
|
|
{
|
|
|
if (sourceDeflections[i].JH != wellNameDes)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
if (sourceDeflections[i].JS < jsDes)
|
|
|
{
|
|
|
return sourceDeflections[i + 1];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (dJSCur < jsDes)
|
|
|
{ // 向下查找
|
|
|
for (int i = middleIndex; i < numSource; i++)
|
|
|
{
|
|
|
if (sourceDeflections[i].JH != wellNameDes)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
if (sourceDeflections[i].JS >= jsDes)
|
|
|
{
|
|
|
return sourceDeflections[i];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return sourceDeflections[middleIndex];
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 根据测深计算井位坐标。TODO:是否与补芯有关
|
|
|
/// </summary>
|
|
|
/// <param name="wellName">井号</param>
|
|
|
/// <param name="detection">测深</param>
|
|
|
/// <param name="x">坐标X</param>
|
|
|
/// <param name="y">坐标Y</param>
|
|
|
/// <param name="vertical">垂深</param>
|
|
|
/// <returns>是否计算成功</returns>
|
|
|
public bool ComputedXY(string wellName, double detection, ref double x, ref double y, ref double vertical)
|
|
|
{
|
|
|
// 井基础数据
|
|
|
int nWellIndex = this.FindWellIndex(this.wells, wellName);
|
|
|
if (nWellIndex < 0)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
SimpleWell well = this.wells[nWellIndex];
|
|
|
SimpleDeflection deflectionDowner = this.FindDeflection(this.sysDeflections, wellName, detection, 1);
|
|
|
if (deflectionDowner != null && deflectionDowner.JS == detection)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionDowner.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionDowner.BZB;
|
|
|
return true;
|
|
|
}
|
|
|
SimpleDeflection deflectionUpper = this.FindDeflection(this.sysDeflections, wellName, detection, 0);
|
|
|
if (deflectionUpper != null && deflectionUpper.JS == detection)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionUpper.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionUpper.BZB;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
if (deflectionDowner != null || deflectionUpper != null)
|
|
|
{
|
|
|
if (deflectionDowner != null && deflectionUpper != null)
|
|
|
{
|
|
|
// 斜井，计算层位坐标
|
|
|
double dBefore = deflectionUpper.JS;
|
|
|
double dNext = deflectionDowner.JS;
|
|
|
double dFactor = (detection - dBefore) / (dNext - dBefore);
|
|
|
// 东坐标
|
|
|
double dOffsetX = (dFactor * (deflectionDowner.DZB - deflectionUpper.DZB))
|
|
|
+ deflectionUpper.DZB;
|
|
|
// 北坐标
|
|
|
double dOffsetY = (dFactor * (deflectionDowner.BZB - deflectionUpper.BZB))
|
|
|
+ deflectionUpper.BZB;
|
|
|
// 坐标X
|
|
|
x = well.X + dOffsetX;
|
|
|
// 坐标Y
|
|
|
y = well.Y + dOffsetY;
|
|
|
// 垂深
|
|
|
//double dLastCS = deflectionBefore.CS;
|
|
|
//double dNextCS = deflectionNext.CS;
|
|
|
//vertical = (dFactor * (dNextCS - dLastCS)) + dLastCS;
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner == null && deflectionUpper != null)
|
|
|
{ // 仅有上层数据时
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionUpper.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionUpper.BZB;
|
|
|
// 垂深
|
|
|
double dLastCS = deflectionUpper.CS;
|
|
|
vertical = dLastCS + (detection - deflectionUpper.JS);
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner != null && deflectionUpper == null)
|
|
|
{ // 仅有下层数据时
|
|
|
double dBefore = 0;
|
|
|
double dNext = deflectionDowner.JS;
|
|
|
double dFactor = (detection - dBefore) / (dNext - dBefore);
|
|
|
// 东坐标
|
|
|
double dOffsetX = dFactor * deflectionDowner.DZB;
|
|
|
// 北坐标
|
|
|
double dOffsetY = dFactor * deflectionDowner.BZB;
|
|
|
// 坐标X
|
|
|
x = well.X + dOffsetX;
|
|
|
// 坐标Y
|
|
|
y = well.Y + dOffsetY;
|
|
|
// 垂深
|
|
|
//double dLastCS = 0;
|
|
|
//double dNextCS = deflectionNext.CS;
|
|
|
//vertical = (dFactor * (dNextCS - dLastCS)) + dLastCS;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (well != null)
|
|
|
{
|
|
|
x = well.X;
|
|
|
y = well.Y;
|
|
|
//vertical = detection;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 查找井斜数据
|
|
|
/// </summary>
|
|
|
/// <param name="deflections">井斜数据</param>
|
|
|
/// <param name="wellName">井号</param>
|
|
|
/// <param name="vertical">垂深</param>
|
|
|
/// <param name="opType">查找方式,0-查找上方，1查找下方</param>
|
|
|
/// <returns>查找结果</returns>
|
|
|
private SimpleDeflection FindDeflectionByVertical(SimpleDeflection[] deflections, string wellName, double vertical, int opType)
|
|
|
{
|
|
|
int num = deflections.Length;
|
|
|
if (num == 0)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
int start = 0;
|
|
|
int stop = num - 1;
|
|
|
if (deflections[start].JH.Equals(wellName))
|
|
|
{
|
|
|
if (opType == 0)
|
|
|
{
|
|
|
return SearchUpperInWells(deflections, start, wellName, vertical);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return SearchDownerInWells(deflections, start, wellName, vertical);
|
|
|
}
|
|
|
}
|
|
|
if (deflections[stop].JH.Equals(wellName))
|
|
|
{
|
|
|
if (opType == 0)
|
|
|
{
|
|
|
return SearchUpperInWells(deflections, stop, wellName, vertical);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return SearchDownerInWells(deflections, stop, wellName, vertical);
|
|
|
}
|
|
|
}
|
|
|
int midle;
|
|
|
while (stop - start > 1)
|
|
|
{
|
|
|
midle = (start + stop) / 2;
|
|
|
if (string.CompareOrdinal(wellName, deflections[midle].JH) < 0)
|
|
|
{
|
|
|
stop = midle;
|
|
|
}
|
|
|
else if (wellName.CompareTo(deflections[midle].JH) == 0)
|
|
|
{
|
|
|
stop = midle;
|
|
|
break;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
start = midle;
|
|
|
}
|
|
|
}
|
|
|
if (wellName == deflections[stop].JH)
|
|
|
{
|
|
|
if (opType == 0)
|
|
|
{
|
|
|
return SearchUpperInWells(deflections, stop, wellName, vertical);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return SearchDownerInWells(deflections, stop, wellName, vertical);
|
|
|
}
|
|
|
}
|
|
|
// TODO：可以使用插值二分法
|
|
|
SimpleDeflection SearchUpperInWells(SimpleDeflection[] sourceDeflections, int middleIndex, string wellNameDes, double jsDes)
|
|
|
{
|
|
|
int numSource = sourceDeflections.Length;
|
|
|
double dJSCur = sourceDeflections[middleIndex].CS;
|
|
|
if (dJSCur > jsDes)
|
|
|
{ // 向上查找
|
|
|
for (int i = middleIndex; i >= 0; i--)
|
|
|
{
|
|
|
if (sourceDeflections[i].JH != wellNameDes)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
if (sourceDeflections[i].CS <= jsDes)
|
|
|
{
|
|
|
return sourceDeflections[i];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (dJSCur < jsDes)
|
|
|
{
|
|
|
for (int i = middleIndex; i < numSource; i++)
|
|
|
{
|
|
|
if (sourceDeflections[i].JH != wellNameDes)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
if (sourceDeflections[i].CS > jsDes)
|
|
|
{
|
|
|
return sourceDeflections[i - 1];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return sourceDeflections[middleIndex];
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
SimpleDeflection SearchDownerInWells(SimpleDeflection[] sourceDeflections, int middleIndex, string wellNameDes, double jsDes)
|
|
|
{
|
|
|
int numSource = sourceDeflections.Length;
|
|
|
double dJSCur = sourceDeflections[middleIndex].CS;
|
|
|
if (dJSCur > jsDes)
|
|
|
{ // 向上查找
|
|
|
for (int i = middleIndex; i >= 0; i--)
|
|
|
{
|
|
|
if (sourceDeflections[i].JH != wellNameDes)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
if (sourceDeflections[i].CS < jsDes)
|
|
|
{
|
|
|
return sourceDeflections[i + 1];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (dJSCur < jsDes)
|
|
|
{ // 向下查找
|
|
|
for (int i = middleIndex; i < numSource; i++)
|
|
|
{
|
|
|
if (sourceDeflections[i].JH != wellNameDes)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
if (sourceDeflections[i].CS >= jsDes)
|
|
|
{
|
|
|
return sourceDeflections[i];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return sourceDeflections[middleIndex];
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 由垂深计算坐标.
|
|
|
/// </summary>
|
|
|
/// <param name="wellName">Name of the well.</param>
|
|
|
/// <param name="vertical">The vertical.</param>
|
|
|
/// <param name="x">The x.</param>
|
|
|
/// <param name="y">The y.</param>
|
|
|
/// <returns>是否成功</returns>
|
|
|
public bool ComputedXYByVertical(string wellName, double? vertical, ref double x, ref double y)
|
|
|
{
|
|
|
if (this.wells == null)
|
|
|
{
|
|
|
this.Initialize();
|
|
|
}
|
|
|
// 井基础数据
|
|
|
int nWellIndex = this.FindWellIndex(this.wells, wellName);
|
|
|
if (nWellIndex < 0)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
SimpleWell well = this.wells[nWellIndex];
|
|
|
if (vertical == null)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X;
|
|
|
// 坐标Y
|
|
|
y = well.Y;
|
|
|
return true;
|
|
|
}
|
|
|
SimpleDeflection deflectionDowner = this.FindDeflectionByVertical(this.sysDeflections, wellName, vertical.Value, 1);
|
|
|
if (deflectionDowner != null && deflectionDowner.CS == vertical)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionDowner.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionDowner.BZB;
|
|
|
return true;
|
|
|
}
|
|
|
SimpleDeflection deflectionUpper = this.FindDeflectionByVertical(this.sysDeflections, wellName, vertical.Value, 0);
|
|
|
if (deflectionUpper != null && deflectionUpper.CS == vertical)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionUpper.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionUpper.BZB;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
if (deflectionDowner != null || deflectionUpper != null)
|
|
|
{
|
|
|
if (deflectionDowner != null && deflectionUpper != null)
|
|
|
{
|
|
|
// 斜井，计算层位坐标
|
|
|
double dBefore = deflectionUpper.CS;
|
|
|
double dNext = deflectionDowner.CS;
|
|
|
double dFactor = (vertical.Value - dBefore) / (dNext - dBefore);
|
|
|
// 东坐标
|
|
|
double dOffsetX = (dFactor * (deflectionDowner.DZB - deflectionUpper.DZB))
|
|
|
+ deflectionUpper.DZB;
|
|
|
// 北坐标
|
|
|
double dOffsetY = (dFactor * (deflectionDowner.BZB - deflectionUpper.BZB))
|
|
|
+ deflectionUpper.BZB;
|
|
|
// 坐标X
|
|
|
x = well.X + dOffsetX;
|
|
|
// 坐标Y
|
|
|
y = well.Y + dOffsetY;
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner == null && deflectionUpper != null)
|
|
|
{ // 仅有上层数据时
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionUpper.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionUpper.BZB;
|
|
|
// 垂深
|
|
|
double dLastCS = deflectionUpper.CS;
|
|
|
vertical = dLastCS + (vertical - deflectionUpper.CS);
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner != null && deflectionUpper == null)
|
|
|
{ // 仅有下层数据时
|
|
|
double dBefore = 0;
|
|
|
double dNext = deflectionDowner.CS;
|
|
|
double dFactor = (vertical.Value - dBefore) / (dNext - dBefore);
|
|
|
// 东坐标
|
|
|
double dOffsetX = dFactor * deflectionDowner.DZB;
|
|
|
// 北坐标
|
|
|
double dOffsetY = dFactor * deflectionDowner.BZB;
|
|
|
// 坐标X
|
|
|
x = well.X + dOffsetX;
|
|
|
// 坐标Y
|
|
|
y = well.Y + dOffsetY;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (well != null)
|
|
|
{
|
|
|
x = well.X;
|
|
|
y = well.Y;
|
|
|
//vertical = detection;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 由测深计算井斜XY坐标. （pnp重写）
|
|
|
/// </summary>
|
|
|
/// <param name="wellName">Name of the well.</param>
|
|
|
/// <param name="detection">The vertical.</param>
|
|
|
/// <param name="x">The x.</param>
|
|
|
/// <param name="y">The y.</param>
|
|
|
/// <returns>是否成功</returns>
|
|
|
public bool ComputedXYByDetection(string wellName, double? detection, ref double? x, ref double? y)
|
|
|
{
|
|
|
// 井基础数据
|
|
|
SimpleWell well = this.wells.FirstOrDefault(c => c.JH == wellName);
|
|
|
if (well == null)
|
|
|
{
|
|
|
x = null;
|
|
|
y = null;
|
|
|
return true;
|
|
|
}
|
|
|
if (detection == null)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X;
|
|
|
// 坐标Y
|
|
|
y = well.Y;
|
|
|
return true;
|
|
|
}
|
|
|
var currtDeflections = this.sysDeflections.Where(a => a.JH == wellName).ToArray();
|
|
|
if (currtDeflections == null)
|
|
|
{
|
|
|
x = well.X;
|
|
|
y = well.Y;
|
|
|
return true;
|
|
|
}
|
|
|
//查找是否存在
|
|
|
SimpleDeflection deflectionCurrt = currtDeflections.FirstOrDefault(a => a.JS == detection.Value);
|
|
|
if (deflectionCurrt != null && deflectionCurrt.CS == detection)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionCurrt.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionCurrt.BZB;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
//查找大于深度第一个
|
|
|
SimpleDeflection deflectionDowner = currtDeflections.Where(a => a.JS > detection.Value).OrderBy(a => a.JS).FirstOrDefault();
|
|
|
//查找小于深度第一个
|
|
|
SimpleDeflection deflectionUpper = currtDeflections.Where(a => a.JS < detection.Value).OrderByDescending(a => a.JS).FirstOrDefault();
|
|
|
|
|
|
if (deflectionDowner == null && deflectionUpper == null)
|
|
|
{
|
|
|
if (well != null)
|
|
|
{
|
|
|
x = well.X;
|
|
|
y = well.Y;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
else if (deflectionDowner != null && deflectionUpper != null)
|
|
|
{
|
|
|
// 斜井，计算层位坐标
|
|
|
double dBefore = deflectionUpper.JS;
|
|
|
double dNext = deflectionDowner.JS;
|
|
|
double dFactor = (detection.Value - dBefore) / (dNext - dBefore);
|
|
|
// 东坐标
|
|
|
double dOffsetX = (dFactor * (deflectionDowner.DZB - deflectionUpper.DZB))
|
|
|
+ deflectionUpper.DZB;
|
|
|
// 北坐标
|
|
|
double dOffsetY = (dFactor * (deflectionDowner.BZB - deflectionUpper.BZB))
|
|
|
+ deflectionUpper.BZB;
|
|
|
// 坐标X
|
|
|
x = well.X + dOffsetX;
|
|
|
// 坐标Y
|
|
|
y = well.Y + dOffsetY;
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner == null && deflectionUpper != null)
|
|
|
{ // 仅有上层数据时
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionUpper.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionUpper.BZB;
|
|
|
// 垂深
|
|
|
double dLastCS = deflectionUpper.JS;
|
|
|
detection = dLastCS + (detection - deflectionUpper.JS);
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner != null && deflectionUpper == null)
|
|
|
{ // 仅有下层数据时
|
|
|
double dBefore = 0;
|
|
|
double dNext = deflectionDowner.JS;
|
|
|
double dFactor = (detection.Value - dBefore) / (dNext - dBefore);
|
|
|
// 东坐标
|
|
|
double dOffsetX = dFactor * deflectionDowner.DZB;
|
|
|
// 北坐标
|
|
|
double dOffsetY = dFactor * deflectionDowner.BZB;
|
|
|
// 坐标X
|
|
|
x = well.X + dOffsetX;
|
|
|
// 坐标Y
|
|
|
y = well.Y + dOffsetY;
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 由测深计算井斜XY坐标. （pnp重写）
|
|
|
/// </summary>
|
|
|
/// <param name="wellName">Name of the well.</param>
|
|
|
/// <param name="vertical">The vertical.</param>
|
|
|
/// <param name="x">The x.</param>
|
|
|
/// <param name="y">The y.</param>
|
|
|
/// <returns>是否成功</returns>
|
|
|
public bool ComputedXYByVerticalNew(string wellName, double? vertical, ref double? x, ref double? y)
|
|
|
{
|
|
|
if (this.wells == null)
|
|
|
{
|
|
|
this.Initialize();
|
|
|
}
|
|
|
// 井基础数据
|
|
|
SimpleWell well = this.wells.FirstOrDefault(c => c.JH == wellName);
|
|
|
if (well == null)
|
|
|
{
|
|
|
x = null;
|
|
|
y = null;
|
|
|
return true;
|
|
|
}
|
|
|
if (vertical == null)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X;
|
|
|
// 坐标Y
|
|
|
y = well.Y;
|
|
|
return true;
|
|
|
}
|
|
|
var currtDeflections = this.sysDeflections.Where(it => it.JH == wellName).ToList();
|
|
|
if (currtDeflections == null)
|
|
|
{
|
|
|
x = well.X;
|
|
|
y = well.Y;
|
|
|
return true;
|
|
|
}
|
|
|
//查找是否存在
|
|
|
SimpleDeflection deflectionCurrt = currtDeflections.FirstOrDefault(a => a.CS == vertical.Value);
|
|
|
if (deflectionCurrt != null && deflectionCurrt.JS == vertical)
|
|
|
{
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionCurrt.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionCurrt.BZB;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
//查找大于深度第一个
|
|
|
SimpleDeflection deflectionDowner = currtDeflections.Where(a => a.CS > vertical.Value).OrderBy(a => a.CS).FirstOrDefault();
|
|
|
//查找小于深度第一个
|
|
|
SimpleDeflection deflectionUpper = currtDeflections.Where(a => a.CS < vertical.Value).OrderByDescending(a => a.CS).FirstOrDefault();
|
|
|
|
|
|
if (deflectionDowner != null || deflectionUpper != null)
|
|
|
{
|
|
|
if (deflectionDowner != null && deflectionUpper != null)
|
|
|
{
|
|
|
// 斜井，计算层位坐标
|
|
|
double dBefore = deflectionUpper.CS;
|
|
|
double dNext = deflectionDowner.CS;
|
|
|
double dFactor = (vertical.Value - dBefore) / (dNext - dBefore);
|
|
|
// 东坐标
|
|
|
double dOffsetX = (dFactor * (deflectionDowner.DZB - deflectionUpper.DZB))
|
|
|
+ deflectionUpper.DZB;
|
|
|
// 北坐标
|
|
|
double dOffsetY = (dFactor * (deflectionDowner.BZB - deflectionUpper.BZB))
|
|
|
+ deflectionUpper.BZB;
|
|
|
// 坐标X
|
|
|
x = well.X + dOffsetX;
|
|
|
// 坐标Y
|
|
|
y = well.Y + dOffsetY;
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner == null && deflectionUpper != null)
|
|
|
{ // 仅有上层数据时
|
|
|
// 坐标X
|
|
|
x = well.X + deflectionUpper.DZB;
|
|
|
// 坐标Y
|
|
|
y = well.Y + deflectionUpper.BZB;
|
|
|
// 垂深
|
|
|
double dLastCS = deflectionUpper.CS;
|
|
|
vertical = dLastCS + (vertical - deflectionUpper.CS);
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner != null && deflectionUpper == null)
|
|
|
{ // 仅有下层数据时
|
|
|
double dBefore = 0;
|
|
|
double dNext = deflectionDowner.CS;
|
|
|
double dFactor = (vertical.Value - dBefore) / (dNext - dBefore);
|
|
|
// 东坐标
|
|
|
double dOffsetX = dFactor * deflectionDowner.DZB;
|
|
|
// 北坐标
|
|
|
double dOffsetY = dFactor * deflectionDowner.BZB;
|
|
|
// 坐标X
|
|
|
x = well.X + dOffsetX;
|
|
|
// 坐标Y
|
|
|
y = well.Y + dOffsetY;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (well != null)
|
|
|
{
|
|
|
x = well.X;
|
|
|
y = well.Y;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 由测深通过井斜计算垂深. （pnp重写）
|
|
|
/// </summary>
|
|
|
/// <param name="wellName">井号</param>
|
|
|
/// <param name="detection">测深</param>
|
|
|
/// <param name="vertical">垂深</param>
|
|
|
/// <returns>是否计算成功</returns>
|
|
|
public bool ComputedZByDetection(string wellName, double? detection, ref double? vertical)
|
|
|
{
|
|
|
if (!detection.HasValue)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
// 井基础数据
|
|
|
if (!this.wells.Any(x => x.JH == wellName))
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
var currtDeflections = this.sysDeflections.Where(it => it.JH == wellName).ToList();
|
|
|
if (currtDeflections == null)
|
|
|
{
|
|
|
vertical = detection;
|
|
|
return true;
|
|
|
}
|
|
|
//查找是否存在
|
|
|
SimpleDeflection deflectionCurrt = currtDeflections.AsParallel().FirstOrDefault(a => a.JS == detection);
|
|
|
if (deflectionCurrt != null)
|
|
|
{
|
|
|
vertical = deflectionCurrt.CS;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
//查找大于深度第一个底
|
|
|
SimpleDeflection deflectionDowner = currtDeflections.AsParallel().Where(a => a.JS > detection).OrderBy(a => a.JS).FirstOrDefault();
|
|
|
//查找小于深度第一个
|
|
|
SimpleDeflection deflectionUpper = currtDeflections.AsParallel().Where(a => a.JS < detection).OrderByDescending(a => a.JS).FirstOrDefault();
|
|
|
|
|
|
if (deflectionDowner != null || deflectionUpper != null)
|
|
|
{
|
|
|
if (deflectionDowner != null && deflectionUpper != null)
|
|
|
{
|
|
|
// 斜井，计算层位坐标
|
|
|
double dBeforeJS = deflectionUpper.JS;
|
|
|
double dNextJS = deflectionDowner.JS;
|
|
|
|
|
|
double dBeforeCS = deflectionUpper.CS;
|
|
|
double dNextCS = deflectionDowner.CS;
|
|
|
|
|
|
double dFactor = (dNextCS - dBeforeCS) / (dNextJS - dBeforeJS);
|
|
|
vertical = dBeforeCS + ((detection.Value - dBeforeJS) * dFactor);
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner == null && deflectionUpper != null)
|
|
|
{ // 仅有上层数据时
|
|
|
// 垂深
|
|
|
double dLastCS = deflectionUpper.CS;
|
|
|
vertical = dLastCS + (detection.Value - deflectionUpper.JS);
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner != null && deflectionUpper == null)
|
|
|
{ // 仅有下层数据时
|
|
|
double dBefore = 0;
|
|
|
double dNext = deflectionDowner.JS;
|
|
|
double dFactor = (detection.Value - dBefore) / (dNext - dBefore);
|
|
|
// 垂深
|
|
|
double dLastCS = 0;
|
|
|
double dNextCS = deflectionDowner.CS;
|
|
|
vertical = (dFactor * (dNextCS - dLastCS)) + dLastCS;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
vertical = detection;
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 由垂深通过井斜计算测深. （pnp重写）
|
|
|
/// </summary>
|
|
|
/// <param name="wellName">The well name.</param>
|
|
|
/// <param name="vertical">The vertical.</param>
|
|
|
/// <param name="detection">The detection.</param>
|
|
|
/// <returns>是否计算成功</returns>
|
|
|
public bool ComputedZByVertical(string wellName, double? vertical, ref double? detection)
|
|
|
{
|
|
|
if (!vertical.HasValue)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
// 井基础数据
|
|
|
if (!this.wells.Any(x => x.JH == wellName))
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
//SimpleWell well = this.wells[nWellIndex];
|
|
|
//var currtDeflections = new List<SimpleDeflection>();
|
|
|
//if (this.sysDeflectionsDict.ContainsKey(wellName))
|
|
|
//{
|
|
|
// currtDeflections = this.sysDeflectionsDict[wellName].ToList();
|
|
|
//}
|
|
|
var currtDeflections = this.sysDeflections.Where(it => it.JH == wellName).ToArray();
|
|
|
if (currtDeflections == null)
|
|
|
{
|
|
|
detection = vertical;
|
|
|
return true;
|
|
|
}
|
|
|
//查找是否存在
|
|
|
SimpleDeflection deflectionCurrt = currtDeflections.FirstOrDefault(a => a.CS == vertical);
|
|
|
if (deflectionCurrt != null)
|
|
|
{
|
|
|
detection = deflectionCurrt.JS;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
//查找大于深度第一个
|
|
|
SimpleDeflection deflectionDowner = currtDeflections.Where(a => a.CS > vertical).OrderBy(a => a.CS).FirstOrDefault();
|
|
|
//查找小于深度第一个
|
|
|
SimpleDeflection deflectionUpper = currtDeflections.Where(a => a.CS < vertical).OrderByDescending(a => a.CS).FirstOrDefault();
|
|
|
|
|
|
if (deflectionDowner != null || deflectionUpper != null)
|
|
|
{
|
|
|
if (deflectionDowner != null && deflectionUpper != null)
|
|
|
{
|
|
|
// 斜井，计算层位坐标
|
|
|
double dBeforeJS = deflectionUpper.JS;
|
|
|
double dNextJS = deflectionDowner.JS;
|
|
|
|
|
|
double dBeforeCS = deflectionUpper.CS;
|
|
|
double dNextCS = deflectionDowner.CS;
|
|
|
|
|
|
double dFactor = (dNextJS - dBeforeJS) / (dNextCS - dBeforeCS);
|
|
|
detection = dBeforeJS + ((vertical.Value - dBeforeCS) * dFactor);
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner == null && deflectionUpper != null)
|
|
|
{ // 仅有上层数据时
|
|
|
// 垂深
|
|
|
double dLastJS = deflectionUpper.JS;
|
|
|
detection = dLastJS + (vertical.Value - deflectionUpper.CS);
|
|
|
return true;
|
|
|
}
|
|
|
else if (deflectionDowner != null && deflectionUpper == null)
|
|
|
{ // 仅有下层数据时
|
|
|
double dBefore = 0;
|
|
|
double dNext = deflectionDowner.CS;
|
|
|
double dFactor = (vertical.Value - dBefore) / (dNext - dBefore);
|
|
|
// 垂深
|
|
|
double dLastJS = 0;
|
|
|
double dNextJS = deflectionDowner.JS;
|
|
|
detection = (dFactor * (dNextJS - dLastJS)) + dLastJS;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
detection = vertical;
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 重新计算井斜坐标
|
|
|
/// </summary>
|
|
|
/// <param name="wellDeflections">井斜</param>
|
|
|
/// <returns>DataTable</returns>
|
|
|
public DataTable ReCalcDepthByIncrementPoint(List<WellDeflection> wellDeflections)
|
|
|
{
|
|
|
using (SplashHelper splash = SplashHelper.Create())
|
|
|
{
|
|
|
SplashHelper.SetDescription("正在重新计算井斜坐标...");
|
|
|
|
|
|
var jhs = wellDeflections.Select(d => d.JH).Distinct().ToList();
|
|
|
|
|
|
List<WellDeflection> defaultDeflections = new List<WellDeflection>();
|
|
|
foreach (var jh in jhs)
|
|
|
{
|
|
|
List<WellDeflection> defaultDeflection = EntityHelp.GetWellDeflectionsByWellName(jh);
|
|
|
if (defaultDeflection != null && defaultDeflection.Any())
|
|
|
{
|
|
|
defaultDeflections.AddRange(defaultDeflection);
|
|
|
}
|
|
|
}
|
|
|
defaultDeflections = defaultDeflections.OrderBy(it => it.JS).ToList();
|
|
|
|
|
|
var spaceSize = DataHelp.WellDeflectionCollectCount;
|
|
|
var densifyDeflections = new List<WellDeflection>(); // 增加密度的数据
|
|
|
foreach (var g in wellDeflections.GroupBy(w => w.JH))
|
|
|
{
|
|
|
var densifyDeflectionJH = new List<WellDeflection>(); // 增加密度的数据
|
|
|
|
|
|
// 计算方位数据
|
|
|
var defaultDeflectionJH = defaultDeflections.Where(w => w.JH == g.Key).OrderBy(w => w.JS).ToList();
|
|
|
var maxJS = defaultDeflectionJH.Max(w => w.JS);
|
|
|
|
|
|
var firstDeflectionJH = defaultDeflectionJH[0]; // 新井号的第一条数据
|
|
|
firstDeflectionJH.XHID = densifyDeflections.Count + densifyDeflectionJH.Count + 1;
|
|
|
densifyDeflectionJH.Add(firstDeflectionJH);
|
|
|
|
|
|
// 补充方位数据
|
|
|
for (int i = 1; i < defaultDeflectionJH.Count; i++)
|
|
|
{
|
|
|
var preDeflection = defaultDeflectionJH[i - 1]; // 上一个
|
|
|
var deflection = defaultDeflectionJH[i]; // 当前
|
|
|
var meters = Convert.ToInt32(deflection.JS.Value - preDeflection.JS.Value);
|
|
|
|
|
|
// 计算两个记录之间，每一米的深度大小
|
|
|
var depthStep = Math.Abs(deflection.JS.Value - preDeflection.JS.Value) / meters;
|
|
|
var jxjStep = (deflection.JXJ ?? 0 - preDeflection.JXJ ?? 0) / meters;
|
|
|
var fwjStep = (deflection.FWJ ?? 0 - preDeflection.FWJ ?? 0) / meters;
|
|
|
var bzbStep = (deflection.BZB ?? 0 - preDeflection.BZB ?? 0) / meters;
|
|
|
var dzbStep = (deflection.DZB ?? 0 - preDeflection.DZB ?? 0) / meters;
|
|
|
var csStep = Math.Abs(deflection.CS ?? 0 - preDeflection.CS ?? 0) / meters;
|
|
|
|
|
|
int count = 1;
|
|
|
var nextJS = preDeflection.JS + (depthStep * spaceSize * count);
|
|
|
while (nextJS < deflection.JS)
|
|
|
{
|
|
|
nextJS = preDeflection.JS + (depthStep * spaceSize * count);
|
|
|
if (nextJS >= maxJS)
|
|
|
{
|
|
|
var item = defaultDeflectionJH.Last();
|
|
|
item.XHID = densifyDeflections.Count + densifyDeflectionJH.Count + 1;
|
|
|
densifyDeflectionJH.Add(item);
|
|
|
break;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
densifyDeflectionJH.Add(new WellDeflection
|
|
|
{
|
|
|
XHID = densifyDeflections.Count + densifyDeflectionJH.Count + 1,
|
|
|
JH = g.Key,
|
|
|
JS = nextJS,
|
|
|
JXJ = preDeflection.JXJ + (jxjStep * spaceSize * count),
|
|
|
FWJ = preDeflection.FWJ + (fwjStep * spaceSize * count),
|
|
|
BZB = preDeflection.BZB + (bzbStep * spaceSize * count),
|
|
|
DZB = preDeflection.DZB + (dzbStep * spaceSize * count),
|
|
|
CS = preDeflection.CS + (csStep * spaceSize * count),
|
|
|
});
|
|
|
count++;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 临时替换计算源
|
|
|
this.sysDeflections = densifyDeflectionJH.Select(d => new SimpleDeflection { JH = d.JH, JS = d.JS ?? 0, BZB = d.BZB ?? 0, DZB = d.DZB ?? 0, CS = d.CS ?? 0 }).ToArray();
|
|
|
foreach (var well in densifyDeflectionJH)
|
|
|
{
|
|
|
double x = 0, y = 0;
|
|
|
if (this.ComputedXYByVertical(well.JH, well.JS, ref x, ref y))
|
|
|
{
|
|
|
well.X = x;
|
|
|
well.Y = y;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
densifyDeflections.AddRange(densifyDeflectionJH);
|
|
|
}
|
|
|
|
|
|
this.Initialize(); // 还原数据
|
|
|
return densifyDeflections.ConvertListToDataTable();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|