You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1504 lines
68 KiB
C#

1 month ago
// <copyright file="WellDistribute.cs" company="jindongfang">
// Copyright (c) jindongfang. All rights reserved.
// </copyright>
//using DfdIO;
//using DfdIO.DrawModel;
//using DQ.Construction.NewLook;
//using DQ.Construction.NewLook.Chart;
//using DQ.Construction.Util;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using WorkData;
using WorkData.Entity;
//using static DQ.Construction.NewLook.CtChart;
namespace WellWorkDataUI
{
/// <summary>
/// 井位分布.
/// </summary>
public class WellDistribute
{
private static readonly object BalanceLock = new object();
/// <summary>
/// 处理进度
/// </summary>
/// <param name="layerName">图层名称</param>
public delegate void ProgressLayer(string layerName, bool isOk);
// private string layerName;
///// <summary>
///// 地层
///// </summary>
// public string LayerName
// {
// get
// {
// return this.layerName;
// }
// set
// {
// this.layerName = value;
// }
// }
/// <summary>
/// Initializes a new instance of the <see cref="WellDistribute"/> class.
/// </summary>
/// <param name="layerName">层位</param>
public WellDistribute()
{
// this.layerName = layerName;
}
/// <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 static bool ComputedXY(string wellName, double detection, ref double x, ref double y, ref double vertical)
{
// 井基础数据
WellBase well = DBHelp.NewDb.Queryable<WellBase>()
.Where(it => it.JH == wellName && it.X > 0 && it.Y > 0)
.Select(it => new WellBase() { JH = it.JH, X = it.X, Y = it.Y }).First();
int nCount = DBHelp.NewDb.Queryable<WellDeflection>()
.Where(it => it.JH == wellName)
.Select(it => it.JH).Count();
if (nCount > 0)
{
var deflectionNext = DBHelp.NewDb.Queryable<WellDeflection>()
.Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
.Where(it => it.JH.Equals(wellName))
.Where(it => it.JS >= detection)
.OrderBy(it => it.JS, OrderByType.Asc)
.First();
var deflectionBefore = DBHelp.NewDb.Queryable<WellDeflection>()
.Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
.Where(it => it.JH.Equals(wellName))
.Where(it => it.JS < detection)
.OrderBy(it => it.JS, OrderByType.Desc)
.First();
if (deflectionNext != null && deflectionBefore != null)
{
// 斜井,计算层位坐标
double dBefore = deflectionBefore.JS.Value;
double dNext = deflectionNext.JS.Value;
double dFactor = (detection - dBefore) / (dNext - dBefore);
// 东坐标
double dOffsetX = (dFactor * (deflectionNext.DZB - deflectionBefore.DZB).Value)
+ deflectionBefore.DZB.Value;
// 北坐标
double dOffsetY = (dFactor * (deflectionNext.BZB - deflectionBefore.BZB).Value)
+ deflectionBefore.BZB.Value;
// 坐标X
x = well.X.Value + dOffsetX;
// 坐标Y
y = well.Y.Value + dOffsetY;
// 垂深
double dLastCS = deflectionBefore.CS.Value;
double dNextCS = deflectionNext.CS.Value;
vertical = (dFactor * (dNextCS - dLastCS)) + dLastCS;
return true;
}
else if (deflectionNext == null && deflectionBefore != null)
{ // 仅有上层数据时
// 坐标X
x = well.X.Value + deflectionBefore.DZB.Value;
// 坐标Y
y = well.Y.Value + deflectionBefore.BZB.Value;
// 垂深
double dLastCS = deflectionBefore.CS.Value;
vertical = dLastCS + (detection - deflectionBefore.JS.Value);
return true;
}
else if (deflectionNext != null && deflectionBefore == null)
{ // 仅有下层数据时
double dBefore = 0;
double dNext = deflectionNext.JS.Value;
double dFactor = (detection - dBefore) / (dNext - dBefore);
// 东坐标
double dOffsetX = dFactor * deflectionNext.DZB.Value;
// 北坐标
double dOffsetY = dFactor * deflectionNext.BZB.Value;
// 坐标X
x = well.X.Value + dOffsetX;
// 坐标Y
y = well.Y.Value + dOffsetY;
// 垂深
double dLastCS = 0;
double dNextCS = deflectionNext.CS.Value;
vertical = (dFactor * (dNextCS - dLastCS)) + dLastCS;
return true;
}
}
else
{
if (well != null)
{
x = well.X.Value;
y = well.Y.Value;
vertical = detection;
return true;
}
}
return false;
}
/// <summary>
/// 创建井位分布图
/// </summary>
/// <param name="layers">层位数据字典</param>
/// <param name="action">处理的层位</param>
/// <returns>是否成功</returns>
//public bool CreateWellDistributes(Dictionary<string, LeafNodeData> layers, ProgressLayer action)
//{
// foreach (var layer in layers.Keys)
// {
// this.CreateWellDistribute(layer, layers[layer], action);
// }
// return true;
//}
/// <summary>
/// 创建工区井位分布图
/// </summary>
/// <param name="filePath">保存路径</param>
/// <param name="action"></param>
/// <param name="tag"></param>
/// <returns></returns>
//public bool CreateWorkspaceDistribute(string filePath, ProgressLayer action, LeafNodeData tag)
//{
// Action<string> writeWells = (drawFile) =>
// {
// var template = tag.Param.OtherData;
// var workWells = this.GetWorkspaceWells(template);
// List<string> wells = workWells.Select(w => $@"{w.JB},{w.JH}").ToList();
// tag.Param.OtherData.Wells = wells;
// tag.Param.WriteData(); // 设置默认选中井
// using (StreamWriter sw = new StreamWriter(drawFile, true, Encoding.Default))
// {
// foreach (var well in workWells)
// {
// sw.WriteLine($"Layer M {well.JB}");
// // 3dPoint X,Y,Z,0,井号
// sw.WriteLine($"3dPoint {well.X},{well.Y},{0} 0 {well.JH}");
// }
// }
// };
// var wResult = this.WriteWellDistributeFile(filePath, writeWells, action);
// return wResult;
//}
//private bool WriteWellDistributeFile(string drawFile, Action<string> writeWells, ProgressLayer action)
//{
// // 写文件头
// DfdWriter dfdWriter = new DfdWriter(drawFile);
// dfdWriter.WriteHead(false);
// // 写符号
// string strSymbolFile = FileHelp.GetDefaultSymbolFile();
// if (!string.IsNullOrEmpty(strSymbolFile))
// {
// string strSymbolData = string.Empty;
// using (StreamReader sr = new StreamReader(strSymbolFile, Encoding.Default))
// {
// strSymbolData = sr.ReadToEnd();
// }
// using (StreamWriter sw = new StreamWriter(drawFile, true, Encoding.Default))
// {
// sw.WriteLine(strSymbolData);
// }
// }
// // 写井
// writeWells.Invoke(drawFile);
// // 回调事件
// if (action != null)
// {
// action(drawFile, true);
// }
// return true;
//}
/// <summary>
/// 创建井位分布图
/// </summary>
/// <param name="layerName">层位</param>
/// <param name="nodeData">层位数据</param>
/// <param name="action">完成后的事件</param>
/// <returns>是否成功</returns>
//public bool CreateWellDistribute(string layerName, LeafNodeData nodeData, ProgressLayer action)
//{
// bool isOk = false;
// string drawFile = FileHelp.GetWellDeployFile(layerName);
// if (nodeData.TreeType == TreeTypeClass.WellDeploy && File.Exists(drawFile))
// {
// // 图件已存在不需要写井
// isOk = true;
// }
// var template = nodeData.Param.OtherData;
// var lstWells = this.GetWellsFromDB(layerName, template);
// if (lstWells.Count > 0)
// {
// drawFile = FileHelp.GetWellDistributeFile(layerName);
// if (nodeData.TreeType == TreeTypeClass.WellDeploy)
// {
// drawFile = FileHelp.GetWellDeployFile(layerName);
// }
// // 写文件头
// DfdWriter dfdWriter = new DfdWriter(drawFile);
// dfdWriter.WriteHead(false);
// // 写符号
// string strSymbolFile = FileHelp.GetDefaultSymbolFile();
// if (!string.IsNullOrEmpty(strSymbolFile))
// {
// CsharpFileUtility.DecodeOverrideFile(strSymbolFile);
// string strSymbolData = string.Empty;
// using (StreamReader sr = new StreamReader(strSymbolFile, Encoding.Default))
// {
// strSymbolData = sr.ReadToEnd();
// }
// using (StreamWriter sw = new StreamWriter(drawFile, true, Encoding.Default))
// {
// sw.WriteLine(strSymbolData);
// }
// }
// template.Wells = lstWells.Select(w => $@"{w.JB},{w.JH}").ToList();
// // 写井
// using (StreamWriter sw = new StreamWriter(drawFile, true, Encoding.Default))
// {
// foreach (var well in lstWells)
// {
// // 井号 井别 X Y 垂深 测深
// sw.WriteLine($"Layer M {well.JB}");
// sw.WriteLine($"3dPoint {well.X},{well.Y},{well.SD} 0 {well.JH}");
// }
// }
// isOk = true;
// }
// // 回调事件
// action?.Invoke(layerName, isOk);
// return isOk;
//}
/// <summary>
/// 从数据库获得井的坐标和深度
/// </summary>
/// <returns>井数据: 井号 井别 X Y 垂深 测深</returns>
//private List<(string JH, string JB, double X, double Y, double CS, double SD)> GetWellsFromDB(string layerName, MergeTemplate template)
//{
// var wells = new List<(string, string, double, double, double, double)>();
// var lstWells = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
// (layer, well) => new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
// .Where((layer, well) => layer.CW.ToUpper().Equals(SqlFunc.ToUpper(layerName)))
// .Where((layer, well) => layer.SD != null)
// .Where((layer, well) => layer.X != null)
// .Select((layer, well) => new { well.CXB, well.JB, well.MQJB, layer.JH, layer.SD, layer.X, layer.Y, well.BXHB })
// .ToList();
// Dictionary<string, string> dictJBs = new Dictionary<string, string>();
// // 获取井别数据
// DataTable tbWell = DBHelp.Db.Queryable<WellBase>().ToDataTable();
// foreach (DataRow dr in tbWell.Rows)
// {
// string strLayer = BatchChartHelper.ParseWellLayerStrByMergeGroup(template.WellGroups, dr);
// dictJBs.Add(dr["JH"] + string.Empty, strLayer);
// if (!template.LegendLayers.Contains(strLayer))
// {
// template.LegendLayers.Add(strLayer);
// }
// }
// foreach (var well in lstWells)
// {
// var strJB = dictJBs.ContainsKey(well.JH) ? dictJBs[well.JH] : well.MQJB;
// var sd = well.BXHB ?? 0;
// var addCxb = template.WellGroups.Contains(nameof(well.CXB)) && !string.IsNullOrEmpty(well.CXB);
// wells.Add((well.JH,
// addCxb ? well.CXB + "\\" + strJB : strJB,
// well.X.Value,
// well.Y.Value,
// 0D, // 垂深
// (well.SD.Value - sd) * -1)); // 测深
// }
// return wells;
//}
///// <summary>
///// 获取工区井位数据
///// </summary>
///// <param name="layerName"></param>
///// <returns>井数据: 井号 井别 X Y</returns>
//private List<(string JH, string JB, double X, double Y)> GetWorkspaceWells(MergeTemplate template)
//{
// var wells = new List<(string, string, double, double)>();
// var wellGroup = DBHelp.NewDb.Queryable<WellBase>().Select(well => new { well.JH, well.JB, well.MQJB, well.X, well.Y, well.BXHB })
// .ToList();
// Dictionary<string, string> dictJBs = new Dictionary<string, string>();
// // 获取井别数据
// DataTable tbWell = DBHelp.Db.Queryable<WellBase>().ToDataTable();
// foreach (DataRow dr in tbWell.Rows)
// {
// string strLayer = BatchChartHelper.ParseWellLayerStrByMergeGroup(template.WellGroups, dr);
// dictJBs.Add(dr["JH"] + string.Empty, strLayer);
// if (!template.LegendLayers.Contains(strLayer))
// {
// template.LegendLayers.Add(strLayer);
// }
// }
// foreach (var well in wellGroup)
// {
// var strJB = dictJBs.ContainsKey(well.JH) ? dictJBs[well.JH] : well.MQJB;
// wells.Add((well.JH, strJB, well.X.Value, well.Y.Value));
// }
// //var wells = new List<(string, string, double, double, double)>();
// //var wellGroup = DBHelp.NewDb.Queryable<WellBase>().LeftJoin<InterpretDrillWellLayered>((well, l) => well.JH == l.JH)
// // .Select((well, l) => new { well.JH, well.JB, well.MQJB, well.X, well.Y, l.SD, well.BXHB })
// // .ToList();
// //foreach (var well in wellGroup)
// //{
// // string strJB = BatchChartHelper.GetJBNameByID(well.JB ?? well.MQJB);
// // double z = 0f;
// // if (well.SD.HasValue && well.SD.Value > 0 && well.BXHB.HasValue)
// // {
// // z = (well.SD.Value - well.BXHB.Value) * -1;
// // }
// // wells.Add((well.JH, strJB, well.X.Value, well.Y.Value, z));
// //}
// return wells;
//}
/// <summary>
/// 生成层位井分布数据
/// </summary>
/// <param name="layerName">层位名</param>
/// <param name="borderFile">边界文件</param>
/// <param name="useInclined">使用斜井</param>
/// <returns>是否成功</returns>
//public static bool CreateLayerWells(string layerName, string borderFile = null, bool useInclined = false)
//{
// NtsGeometryServices.Instance = new NtsGeometryServices(
// CoordinateArraySequenceFactory.Instance,
// new PrecisionModel(1d),
// 4326);
// GeometryFactory gf = NtsGeometryServices.Instance.CreateGeometryFactory();
// // 读取计算配置
// GlobalSetting globalSetting = GlobalSetting.ReadFromFile();
// // 排除的井
// List<string> lstWellsExclude = new List<string>();
// string strFileAdjustExclude = FileHelp.GetAdjustFileExclude(TreeTypeClass.Deep.Type, layerName);
// if (File.Exists(strFileAdjustExclude))
// {
// using (StreamReader sw = new StreamReader(
// File.Open(strFileAdjustExclude, FileMode.Open, FileAccess.Read),
// Encoding.Default))
// {
// string strLine;
// while ((strLine = sw.ReadLine()) != null)
// {
// if (!string.IsNullOrWhiteSpace(strLine))
// {
// lstWellsExclude.Add(strLine);
// }
// }
// }
// }
// List<Geometry> lstBorder = new List<Geometry>();
// if (File.Exists(borderFile))
// {
// List<LineString> lstLine = new List<LineString>();
// Xy reader = new Xy();
// bool bEncode = CsharpFileUtility.DecodeOverrideFile(borderFile);
// reader.DfdRead(borderFile);
// if (bEncode)
// {
// CsharpFileUtility.EncodeFile(borderFile);
// }
// foreach (DrawerElementBase element in reader.Elements)
// {
// if (element is DrawerLine drawerLine)
// {
// List<Coordinate> coordinates = new List<Coordinate>();
// foreach (DrawerLineNode node in drawerLine.Nodes)
// {
// coordinates.Add(new Coordinate(node.X, node.Y));
// }
// if (coordinates.Count > 0)
// {
// if (coordinates[0] != coordinates[coordinates.Count - 1])
// {
// coordinates.Add(new Coordinate(coordinates[0].X, coordinates[0].Y));
// }
// Polygon polygon = gf.CreatePolygon(coordinates.ToArray());
// //lstBorder.Add(polygon.Buffer(1));
// lstBorder.Add(polygon);
// }
// }
// }
// }
// List<Tuple<string, double, double, double>> wellData = new List<Tuple<string, double, double, double>>();
// //if (!useInclined)
// //{
// //.Where((layer, wellBase) => SqlFunc.Subqueryable<WellDeflection>().Where(s => s.JH == layer.JH).NotAny())
// var straightWells = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
// (layer, wellBase) => new JoinQueryInfos(JoinType.Inner, layer.JH == wellBase.JH))
// .Where((layer, wellBase) => SqlFunc.ToUpper(layer.CW) == SqlFunc.ToUpper(layerName))
// .Where((layer, wellBase) => layer.SD > 0)
// .Where((layer, wellBase) => wellBase.X != null)
// .Select((layer, wellBase) => new { layer.JH, layer.CW, layer.SD, wellBase.BXHB, wellBase.X, layerX = layer.X, layerY = layer.Y, wellBase.Y, layer.CS_T })
// .ToList();
// // int nIndex = 0;
// foreach (var well in straightWells)
// {
// // nIndex++;
// // Trace.WriteLine($"{nIndex}: {well.JH}, {well.X}, {well.Y}, {well.SD}, {well.BXHB}");
// if (lstWellsExclude.Contains(well.JH))
// {
// continue;
// }
// if (well.X == null || well.Y == null || well.X.Value * well.Y.Value == 0)
// {
// continue;
// }
// // 排除边界外的井
// if (lstBorder.Count > 0)
// {
// bool isOut = false;
// foreach (Geometry border in lstBorder)
// {
// Point pt = gf.CreatePoint(new Coordinate(well.X.Value, well.Y.Value));
// if (!border.Contains(pt))
// {
// isOut = true;
// break;
// }
// }
// if (isOut == true)
// {
// continue;
// }
// }
// bool bWithKellyBushing = WorkspaceConfig.Instance.FindConfigValue<bool>("LayerAdjust", "UseKellyBushing", true);
// double sd = well.SD ?? 0;
// bool is_awry = DBHelp.Db.Queryable<WellDeflection>().Any(d => d.JH == well.JH);
// double x = well.X.Value;
// double y = well.Y.Value;
// if (is_awry)
// {
// sd = well.CS_T ?? 0;
// x = well.layerX.Value;
// y = well.layerY.Value;
// }
// if (bWithKellyBushing)
// {
// // 已考虑了补心海拔
// wellData.Add(Tuple.Create(
// well.JH,
// x,
// y,
// sd - (well.BXHB ?? 0)));
// }
// else
// {
// wellData.Add(Tuple.Create(
// well.JH,
// x,
// y,
// sd));
// }
// }
// if (false)
// {
// //}
// // 如果考虑斜井
// // 获得所有斜井井号
// //List<Tuple<string, double>> lstDefWell = new List<Tuple<string, double>>();
// //var lstDef = DBHelp.NewDb.Queryable<WellDeflection, WellBase>(
// // (def, well) => new JoinQueryInfos(JoinType.Left, def.JH == well.JH))
// // .Select((def, well) => new { JH = def.JH, well.BXHB })
// // .GroupBy(def => def.JH).ToList();
// //lstDef = DBHelp.NewDb.Queryable<WellDeflection, WellBase>(
// // (def, well) => new JoinQueryInfos(JoinType.Left, def.JH == well.JH))
// // .Select((def, well) => new { JH = def.JH, well.BXHB })
// // .MergeTable()
// // .GroupBy(it => it.JH).ToList();
// DataTable dtLayerWellsDef = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
// (layer, wellBase) => new JoinQueryInfos(JoinType.Inner, layer.JH == wellBase.JH))
// // .Where((layer, wellBase) => layer.JH.Equals(wellName))
// .Where((layer, wellBase) => SqlFunc.ToUpper(layer.CW) == SqlFunc.ToUpper(layerName))
// .Where((layer, wellBase) => layer.SD > 0)
// .Where((layer, wellBase) => wellBase.X != null)
// .Where((layer, wellBase) => SqlFunc.Subqueryable<WellDeflection>().Where(s => s.JH == layer.JH).Any())
// .Select((layer, wellBase) => new { layer.JH, layer.SD, wellBase.BXHB, wellBase.X, wellBase.Y })
// //.OrderBy(it=>it.JH)
// //.OrderBy(it=>it.SD)
// .ToDataTable();
// // var lstDefWell = DBHelp.NewDb.Queryable<WellDeflection>().Select(it => it.JH).Distinct().ToList();
// DataTable dtDrill = DBHelp.NewDb.Queryable<WellDeflection>()
// .Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
// //.Where(it => it.BZB != null && it.DZB != null)
// .OrderBy(it => it.JH)
// .OrderBy(it => it.CS)
// .ToDataTable();
// // int n = lstDefWell.Count;
// DataRowCollection drs = dtLayerWellsDef.Rows;
// string wellName = string.Empty;
// // 获得层位上的井,包括层位、测深
// foreach (DataRow drWell in drs)
// {
// wellName = drWell[0].ToString(); // JH-井号
// if (lstWellsExclude.Contains(wellName))
// {
// continue;
// }
// // 排除边界外的井
// bool isOut = false;
// foreach (Geometry border in lstBorder)
// {
// if (!border.Contains(new Point(Convert.ToDouble(drWell["X"])
// , Convert.ToDouble(drWell["Y"]))))
// {
// isOut = true;
// break;
// }
// }
// if (isOut == true)
// {
// continue;
// }
// // Trace.WriteLine(wellName);
// // 目的层深度
// double dLayerDeepth = Convert.ToDouble(drWell[1]); // 垂深 AND CS>{dLayerDeepth}",JS ASC"
// DataRow[] drsdeflection = dtDrill.Select(
// $"JH='{wellName}'", "JS ASC");
// // 前后深度
// double dCSNext = double.MinValue;
// double dCSBefore = double.MinValue;
// double dDzbNext = 0; // DZB -
// double dBzbNext = 0; // BZB
// double dDzbBefore = 0; // DZB -
// double dBzbBefore = 0; // BZB
// for (int i = 0; i < drsdeflection.Length; i++)
// {
// //dCSNext = Convert.ToDouble(drsdeflection[i][4]);
// if (double.TryParse($"{drsdeflection[i][4]}", out dCSNext) == false)
// {
// dCSNext = 0;
// }
// if (dCSNext >= dLayerDeepth)
// {
// if (double.TryParse($"{drsdeflection[i][2]}", out dDzbNext) == false)
// {
// dDzbNext = 0;
// }
// if (double.TryParse($"{drsdeflection[i][1]}", out dBzbNext) == false)
// {
// dBzbNext = 0;
// }
// //dDzbNext = Convert.ToDouble(drsdeflection[i][2]); // DZB -
// //dBzbNext = Convert.ToDouble(drsdeflection[i][1]); // BZB
// if (i == 0)
// {
// i++;
// }
// if (double.TryParse($"{drsdeflection[i - 1][4]}", out dCSBefore) == false)
// {
// dCSBefore = 0;
// }
// if (double.TryParse($"{drsdeflection[i - 1][2]}", out dDzbBefore) == false)
// {
// dDzbBefore = 0;
// }
// if (double.TryParse($"{drsdeflection[i - 1][1]}", out dBzbBefore) == false)
// {
// dBzbBefore = 0;
// }
// //dCSBefore = Convert.ToDouble(drsdeflection[i - 1][4]);
// //dDzbBefore = Convert.ToDouble(drsdeflection[i - 1][2]);
// //dBzbBefore = Convert.ToDouble(drsdeflection[i - 1][1]);
// break;
// } // 未考虑补心海拔
// }
// if (dCSNext == double.MinValue || dCSBefore == double.MinValue)
// {
// continue;
// }
// // 斜井,计算层位坐标
// double dFactor = (dLayerDeepth - dCSBefore) / (dCSNext - dCSBefore);
// double dOffsetX = (dFactor * (dDzbNext - dDzbBefore)) + dDzbBefore;
// double dOffsetY = (dFactor * (dBzbNext - dBzbBefore)) + dBzbBefore;
// // double dLastCS = deflectionBefore.CS.Value;
// // double dNextCS = deflectionNext.CS.Value;
// // double dCS = (dFactor * (dNextCS - dLastCS)) + dLastCS; // 垂深
// // 补心海拔
// bool bWithKellyBushing = WorkspaceConfig.Instance.FindConfigValue<bool>("LayerAdjust", "UseKellyBushing", true);
// if (bWithKellyBushing)
// {
// object objBxhb = drWell["BXHB"];
// if (objBxhb != DBNull.Value && objBxhb != null)
// {
// dLayerDeepth -= Convert.ToDouble(objBxhb);
// }
// }
// wellData.Add(Tuple.Create(
// wellName,
// Convert.ToDouble(drWell["X"]) + dOffsetX,
// Convert.ToDouble(drWell["Y"]) + dOffsetY,
// dLayerDeepth));
// }
// }
// int nWellCount = wellData.Count;
// if (nWellCount == 0)
// {
// return false;
// }
// // 写入文件
// string wellFile = FileHelp.GetWellLayerDeepthAdjustFile(layerName);
// StringBuilder strbContent = new StringBuilder();
// for (int i = 0; i < wellData.Count; i++)
// {
// strbContent.AppendLine($"{wellData[i].Item2},{wellData[i].Item3},{-wellData[i].Item4},{wellData[i].Item1}");
// }
// File.WriteAllText(wellFile, strbContent.ToString(), Encoding.Default);
// return true;
//}
/// <summary>
/// 创建井位分布图
/// </summary>
/// <param name="wells">井列表</param>
/// <param name="layerName">层位</param>
/// <param name="useInclined">是否考虑斜井</param>
/// <returns>是否成功</returns>
public static bool CreateLayerWells(List<string> wells, string layerName, bool useInclined = false)
{
List<Tuple<string, double, double, double>> wellData = new List<Tuple<string, double, double, double>>();
// 获得层位上的井,包括层位、测深
foreach (string wellName in wells)
{
if (!useInclined)
{
// 仅考虑直井
int nCount = DBHelp.NewDb.Queryable<WellDeflection>()
.Select(it => new { it.JH })
.Where(it => it.JH.Equals(wellName))
.Count();
if (nCount > 0)
{
continue;
}
var straightWell = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
(layer, wellBase) => new JoinQueryInfos(JoinType.Inner, layer.JH == wellBase.JH))
.Where((layer, wellBase) => layer.JH.Equals(wellName))
.Where((layer, wellBase) => SqlFunc.ToUpper(layer.CW) == SqlFunc.ToUpper(layerName))
.Where((layer, wellBase) => layer.SD > 0)
.Where((layer, wellBase) => wellBase.X != null)
.Select((layer, wellBase) => new { layer.JH, layer.CW, layer.SD, wellBase.BXHB, wellBase.X, wellBase.Y })
.First();
if (straightWell == null)
{
continue;
}
wellData.Add(Tuple.Create(
wellName,
straightWell.X.Value,
straightWell.Y.Value,
(straightWell.SD - straightWell.BXHB).Value));
continue;
}
var layerWell = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
(layer, wellBase) => new JoinQueryInfos(JoinType.Inner, layer.JH == wellBase.JH))
.Where((layer, wellBase) => layer.JH.Equals(wellName))
.Where((layer, wellBase) => SqlFunc.ToUpper(layer.CW) == SqlFunc.ToUpper(layerName))
.Where((layer, wellBase) => layer.SD > 0)
.Where((layer, wellBase) => wellBase.X != null)
.Select((layer, wellBase) => new { layer.JH, layer.CW, layer.SD, wellBase.BXHB, wellBase.X, wellBase.Y })
.First();
if (layerWell == null)
{
continue;
}
// 目的层深度
double dLayerDeepth = layerWell.SD.Value;
// TODO考虑补心海拔
var deflectionNext = DBHelp.NewDb.Queryable<WellDeflection>()
.Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
.Where(it => it.JH.Equals(wellName))
.Where(it => it.JS >= dLayerDeepth)
.OrderBy(it => it.JS, OrderByType.Asc)
.First();
var deflectionBefore = DBHelp.NewDb.Queryable<WellDeflection>()
.Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
.Where(it => it.JH.Equals(wellName))
.Where(it => it.JS < dLayerDeepth)
.OrderBy(it => it.JS, OrderByType.Desc)
.First();
if (deflectionNext == null || deflectionBefore == null)
{
// 直井
wellData.Add(Tuple.Create(wellName, layerWell.X.Value, layerWell.Y.Value, (layerWell.SD - layerWell.BXHB).Value));
continue;
}
// 斜井,计算层位坐标
double dBefore = deflectionBefore.JS.Value;
double dNext = deflectionNext.JS.Value;
double dFactor = (dLayerDeepth - dBefore) / (dNext - dBefore);
double dOffsetX = (dFactor * (deflectionNext.DZB - deflectionBefore.DZB).Value)
+ deflectionBefore.DZB.Value;
double dOffsetY = (dFactor * (deflectionNext.BZB - deflectionBefore.BZB).Value)
+ deflectionBefore.BZB.Value;
double dLastCS = deflectionBefore.CS.Value;
double dNextCS = deflectionNext.CS.Value;
double dCS = (dFactor * (dNextCS - dLastCS)) + dLastCS; // 垂深
wellData.Add(Tuple.Create(wellName, layerWell.X.Value + dOffsetX, layerWell.Y.Value + dOffsetY, dCS));
}
int nWellCount = wellData.Count;
if (nWellCount == 0)
{
return false;
}
// 写入文件
string wellFile = FileHelp.GetWellLayerDeepthAdjustFile(layerName);
StringBuilder strbContent = new StringBuilder();
for (int i = 0; i < wellData.Count; i++)
{
strbContent.AppendLine($"{wellData[i].Item2},{wellData[i].Item3},{-wellData[i].Item4},{wellData[i].Item1}");
}
File.WriteAllText(wellFile, strbContent.ToString(), Encoding.Default);
return true;
}
/// <summary>
/// 创建储层数据
/// </summary>
/// <param name="dataType">数据类型</param>
/// <param name="layerName">层位名称</param>
/// <param name="subType">子类型</param>
/// <returns>是否成功</returns>
//public static bool CreateReservoir(TreeTypeClass dataType, string layerName, int subType)
//{
// List<ReservoirEntity> lstLayerData = CreateReservoirData(dataType, layerName, subType);
// if (lstLayerData.Count > 0)
// {
// string inputXYZFile = FileHelp.GetTuneFileByReservoirData(dataType.GetDir(subType), layerName);
// FileHelp.DeleteFile(inputXYZFile);
// List<string> noExcludeWells = new List<string>();
// //剔除井数据获取
// var ccsjWells = DBHelp.Db.Queryable<CcsjWellSetting>().Where(x => x.SJLX == dataType.Text && x.CW == layerName).Select(x => x.JH).ToList();
// if (ccsjWells != null)
// {
// noExcludeWells.AddRange(ccsjWells);
// }
// using (StreamWriter sw = new StreamWriter(inputXYZFile, false, Encoding.Default))
// {
// foreach (ReservoirEntity dr in lstLayerData)
// {
// if (dr == null)
// {
// continue;
// }
// if (!noExcludeWells.Contains(dr.JH))
// {
// sw.WriteLine($"{dr.X},{dr.Y},{dr.DATA},{dr.JH}");
// }
// }
// }
// return true;
// }
// return false;
//}
/// <summary>
/// 创建分层数据
/// </summary>
/// <param name="dataType">数据类型</param>
/// <param name="layerName">层位名称</param>
/// <param name="depthType">深度类型</param>
/// <returns>是否成功</returns>
//public static bool CreateDrillWellLayer(string dataType, string layerName, GeoLayerDepthType depthType)
//{
// List<InterpretDrillWellLayered> lstLayerData = CreateDrillWellLayerData(layerName, depthType);
// if (lstLayerData.Count > 0)
// {
// string inputXYZFile = FileHelp.GetMiddleFile(dataType, layerName, ".xyz");
// FileHelp.DeleteFile(inputXYZFile);
// using (StreamWriter sw = new StreamWriter(inputXYZFile, false, Encoding.Default))
// {
// foreach (InterpretDrillWellLayered dr in lstLayerData)
// {
// if (dr == null)
// {
// continue;
// }
// sw.WriteLine($"{dr.X},{dr.Y},{dr.SD},{dr.JH}");
// }
// }
// return true;
// }
// return false;
//}
/// <summary>
/// Creates the adjust reservoir.
/// </summary>
/// <param name="dataType">The data type.</param>
/// <param name="layerName">The layer name.</param>
/// <param name="inputXYZFile">The inputXYZFile name.</param>
/// <returns>A bool.</returns>
//public static bool CreateAdjustReservoir(TreeTypeClass dataType, string layerName, string inputXYZFile, int subType)
//{
// if (string.IsNullOrWhiteSpace(inputXYZFile))
// {
// inputXYZFile = FileHelp.GetAdjustFileByReservoirData(dataType.GetDir(subType), layerName);
// }
// var wellFile = FileHelp.GetReservoirAdjustFileByReservoirData(dataType.GetDir(subType), layerName);
// List<ReservoirEntity> lstLayerData = CreateReservoirData(dataType, layerName, subType);
// if (lstLayerData.Count > 0)
// {
// var strLayerAdjustFileXyzContent = new StringBuilder();
// var strLayerAdjustFileCsvContent = new StringBuilder();
// foreach (ReservoirEntity dr in lstLayerData)
// {
// if (dr == null)
// {
// continue;
// }
// strLayerAdjustFileXyzContent.AppendLine($"{dr.X},{dr.Y},{dr.DATA}");
// strLayerAdjustFileCsvContent.AppendLine($"{dr.X},{dr.Y},{dr.DATA},{dr.JH}");
// }
// File.WriteAllText(inputXYZFile, strLayerAdjustFileXyzContent.ToString(), Encoding.Default);
// File.WriteAllText(wellFile, strLayerAdjustFileCsvContent.ToString(), Encoding.Default);
// return true;
// }
// return false;
//}
/// <summary>
/// 通过层级获取储层分层下级所有层
/// </summary>
/// <param name="layerLevel">层级</param>
/// <param name="includeChild">是否包含子层</param>
/// <returns>储层数据</returns>
//public static List<string> GetReservoirChildLayers(int layerLevel, bool includeChild = false)
//{
// if (!includeChild)
// {
// return DBHelp.NewDb.Queryable<GeologicalStratification>().Where(it => it.Level == layerLevel).Select(x => x.Code).ToList();
// }
// List<string> lstLayerName = new List<string>();
// int nNodeID = DBHelp.NewDb.Queryable<GeologicalStratification>()
// .Where(it => it.Level == layerLevel).Select(it => it.ID).First();
// List<GeologicalStratification> lstLayer = DBHelp.NewDb.Queryable<GeologicalStratification>()
// .ToChildList(it => it.ParentID, nNodeID);
// foreach (GeologicalStratification layer in lstLayer)
// {
// string strChildName = layer.Code.ToUpper();
// if (!lstLayerName.Contains(strChildName))
// {
// lstLayerName.Add(strChildName);
// }
// }
// lstLayerName = lstLayerName.Select(s => s.ToUpper()).ToList();
// return lstLayerName;
//}
/// <summary>
/// 通过层名获取储层分层下级所有层
/// </summary>
/// <param name="layerName">层位名称</param>
/// <returns>储层数据</returns>
public static List<string> GetReservoirChildLayers(string layerName)
{
layerName = layerName.ToUpper();
int nNodeID = DBHelp.NewDb.Queryable<GeologicalStratification>().Where(it => SqlFunc.ToUpper(it.Code) == layerName).Select(it => it.ID).First();
List<GeologicalStratification> lstLayer = DBHelp.NewDb.Queryable<GeologicalStratification>().ToChildList(it => it.ParentID, nNodeID);
List<string> lstLayerName = new List<string>
{
layerName,
};
foreach (GeologicalStratification layer in lstLayer)
{
string strChildName = layer.Code;
if (!lstLayerName.Any(x => x.Equals(strChildName, StringComparison.CurrentCultureIgnoreCase)))
{
lstLayerName.Add(strChildName);
}
}
lstLayerName = lstLayerName.Select(s => s.ToUpper()).ToList();
return lstLayerName;
}
/// <summary>
/// 创建储层数据
/// </summary>
/// <param name="dataType">数据类型</param>
/// <param name="layerName">层位名称</param>
/// <returns>储层数据</returns>
//public static List<ReservoirEntity> CreateReservoirData(TreeTypeClass dataType, string layerName, int subType)
//{
// List<string> lstLayerName = GetReservoirChildLayers(layerName);
// return CreateReservoirData(dataType, layerName, lstLayerName, subType);
//}
///// <summary>
///// 创建储层数据
///// </summary>
///// <param name="dataType">数据类型</param>
///// <param name="layerName">层位名称</param>
///// <param name="lstLayerName">下级层位名称</param>
///// <returns>储层数据</returns>
//public static List<ReservoirEntity> CreateReservoirData(TreeTypeClass dataType, string layerName, List<string> lstLayerName, int subType)
//{
// GeoLayerDepthType depthType = (GeoLayerDepthType)subType;
// bool isAvg = WorkspaceConfig.Instance.FindConfigValue("ReservoirSet", "KsbCalcModel", 0) == 0 ? true : false;
// List<ReservoirEntity> lstLayerData = null;
// if (dataType == TreeTypeClass.Porosity || dataType == TreeTypeClass.InterpretPorosity)
// {
// // 孔隙度
// var result = DBHelp.NewDb.Queryable<CcsjKxd, WellBase>((layer, well) =>
// new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
// .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
// .Where((layer, well) => layer.KXD != null && layer.KXD.HasValue)
// .Where((layer, well) => layer.X > 0)
// .Where((layer, well) => layer.Y > 0)
// .Where((layer, well) => (layer.DJSD1 != null && layer.DJSD1.Value > 0))
// .OrderBy((layer, well) => new { layer.JH, layer.CW })
// .Select((layer, well) => new
// {
// well.CXB,
// well.MQJB,
// layer.JH,
// layer.DJSD1,
// layer.X,
// layer.Y,
// layer.CW,
// layer.KXD,
// layer.YXHD,
// layer.YXHD_CS,
// }).ToList();
// List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
// {
// CXB = x.CXB,
// MQJB = x.MQJB,
// JH = x.JH,
// SD = x.DJSD1.Value,
// X = x.X.Value,
// Y = x.Y.Value,
// Layer = x.CW,
// DATA = x.KXD.Value,
// KXD = x.KXD.Value,
// YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(0) : x.YXHD_CS.GetValueOrDefault(0),
// }).ToList();
// if (isAvg)
// {
// lstLayerData = AverageRows(lstReservoir);
// }
// else
// {
// lstLayerData = PorosityAverageRows(lstReservoir);
// }
// lstLayerData = lstLayerData.Where(x => !double.IsNaN(x.DATA)).ToList();
// }
// else if (dataType == TreeTypeClass.Permeability || dataType == TreeTypeClass.InterpretPenetration)
// {
// // 渗透率
// var result = DBHelp.NewDb.Queryable<CcsjStl, WellBase>((layer, well) =>
// new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
// .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
// .Where((layer, well) => layer.STL != null && layer.STL.HasValue)
// .Where((layer, well) => layer.X > 0)
// .Where((layer, well) => layer.Y > 0)
// .Where((layer, well) => (layer.DJSD1 != null && layer.DJSD1.Value > 0))
// .Select((layer, well) => new
// {
// well.CXB,
// well.MQJB,
// layer.JH,
// layer.DJSD1,
// layer.X,
// layer.Y,
// layer.CW,
// layer.STL,
// layer.YXHD,
// layer.YXHD_CS,
// }).ToList();
// List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
// {
// CXB = x.CXB,
// MQJB = x.MQJB,
// JH = x.JH,
// SD = x.DJSD1.Value,
// X = x.X.Value,
// Y = x.Y.Value,
// Layer = x.CW,
// DATA = x.STL.Value,
// STL = x.STL.Value,
// YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(0) : x.YXHD_CS.GetValueOrDefault(0),
// }).ToList();
// if (isAvg)
// {
// lstLayerData = AverageRows(lstReservoir);
// }
// else
// {
// lstLayerData = PorosityAverageRows(lstReservoir);
// }
// lstLayerData = lstLayerData.Where(x => !double.IsNaN(x.DATA)).ToList();
// }
// else if (dataType == TreeTypeClass.CcsjSyhd || dataType == TreeTypeClass.InterpretSandThickness)
// {
// // 砂岩厚度
// var result = DBHelp.NewDb.Queryable<CcsjSyhd, WellBase>((layer, well) =>
// new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
// .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
// .Where((layer, well) => layer.SYHD != null)
// .Where((layer, well) => layer.X > 0)
// .Where((layer, well) => layer.Y > 0)
// .OrderBy((layer, well) => new { layer.JH, layer.SYSD_T })
// .Select((layer, well) => new
// {
// well.CXB,
// well.MQJB,
// layer.JH,
// layer.SYSD_T,
// layer.X,
// layer.Y,
// layer.CW,
// layer.SYHD,
// layer.SYCS_HD,
// })
// .ToList();
// List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
// {
// CXB = x.CXB,
// MQJB = x.MQJB,
// JH = x.JH,
// SD = x.SYSD_T,
// X = x.X.Value,
// Y = x.Y.Value,
// Layer = x.CW,
// DATA = depthType == GeoLayerDepthType.测深厚度 ? x.SYHD.GetValueOrDefault(double.NaN) : x.SYCS_HD.GetValueOrDefault(double.NaN),
// SYHD = depthType == GeoLayerDepthType.测深厚度 ? x.SYHD.GetValueOrDefault(double.NaN) : x.SYCS_HD.GetValueOrDefault(double.NaN),
// }).ToList();
// lstLayerData = SumRows(lstReservoir, layerName);
// }
// else if (dataType == TreeTypeClass.CcsjYxhd || dataType == TreeTypeClass.InterpretVaildThickness)
// {
// // 有效厚度
// var result = DBHelp.NewDb.Queryable<CcsjYxhd, WellBase>((layer, well) =>
// new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
// .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
// .Where((layer, well) => layer.YXHD != null)
// .Where((layer, well) => layer.X > 0)
// .Where((layer, well) => layer.Y > 0)
// .OrderBy((layer, well) => new { layer.JH, layer.DJSD1 })
// .Select((layer, well) => new
// {
// well.CXB,
// well.MQJB,
// layer.JH,
// layer.DJSD1,
// layer.X,
// layer.Y,
// layer.YXHD,
// layer.YXCS_HD,
// layer.CW,
// }).ToList();
// List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
// {
// CXB = x.CXB,
// MQJB = x.MQJB,
// JH = x.JH,
// SD = x.DJSD1,
// X = x.X.Value,
// Y = x.Y.Value,
// DATA = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(double.NaN) : x.YXCS_HD.GetValueOrDefault(double.NaN),
// YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(double.NaN) : x.YXCS_HD.GetValueOrDefault(double.NaN),
// Layer = x.CW,
// }).ToList();
// lstLayerData = SumRows(lstReservoir, layerName);
// }
// else if (dataType == TreeTypeClass.WaterSaturation || dataType == TreeTypeClass.InterpretSaturation)
// {
// // 含水饱和度
// var q = DBHelp.NewDb.Queryable<CcsjBhd, WellBase>((layer, well) => new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
// .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
// .Where((layer, well) => layer.HSBHD != null && layer.HSBHD.HasValue)
// .Where((layer, well) => layer.X > 0)
// .Where((layer, well) => layer.Y > 0)
// .Where((layer, well) => (layer.DJSD1 != null && layer.DJSD1.Value > 0));
// if (!isAvg)
// {
// q = q.Where((layer, well) => layer.KXD != null && layer.YXHD != null && layer.KXD.HasValue && layer.YXHD.HasValue);
// }
// var result = q.Select((layer, well) => new
// {
// well.CXB,
// well.MQJB,
// layer.JH,
// layer.DJSD1,
// layer.X,
// layer.Y,
// layer.CW,
// layer.HSBHD,
// layer.YXHD,
// layer.YXHD_CS,
// layer.KXD,
// }).ToList();
// List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
// {
// CXB = x.CXB,
// MQJB = x.MQJB,
// JH = x.JH,
// SD = x.DJSD1.Value,
// X = x.X.Value,
// Y = x.Y.Value,
// Layer = x.CW,
// DATA = x.HSBHD.Value,
// BHD = x.HSBHD.Value,
// YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(0) : x.YXHD_CS.GetValueOrDefault(0),
// KXD = x.KXD.GetValueOrDefault(0),
// }).ToList();
// if (isAvg)
// {
// lstLayerData = AverageRows(lstReservoir);
// }
// else
// {
// lstLayerData = SaturationAverageRows(lstReservoir);
// }
// lstLayerData = lstLayerData.Where(x => !double.IsNaN(x.DATA)).ToList();
// }
// else if (dataType == TreeTypeClass.BeamWaterSaturation)
// {
// // 束水饱和度
// var result = DBHelp.NewDb.Queryable<CcsjBhd, WellBase>((layer, well) => new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
// .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
// .Where((layer, well) => layer.HSBHD != null)
// .Where((layer, well) => layer.X > 0)
// .Where((layer, well) => layer.Y > 0)
// .Where((layer, well) => (layer.DJSD1 != null && layer.DJSD1.Value > 0))
// .Select((layer, well) => new
// {
// well.CXB,
// well.MQJB,
// layer.JH,
// layer.DJSD1,
// layer.X,
// layer.Y,
// layer.CW,
// layer.HSBHD,
// layer.YXHD,
// layer.YXHD_CS,
// layer.KXD,
// }).ToList();
// List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
// {
// CXB = x.CXB,
// MQJB = x.MQJB,
// JH = x.JH,
// SD = x.DJSD1.Value,
// X = x.X.Value,
// Y = x.Y.Value,
// Layer = x.CW,
// DATA = x.HSBHD.Value,
// BHD = x.HSBHD.Value,
// YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(0) : x.YXHD_CS.GetValueOrDefault(0),
// KXD = x.KXD.Value,
// }).ToList();
// if (isAvg)
// {
// lstLayerData = AverageRows(lstReservoir);
// }
// else
// {
// lstLayerData = SaturationAverageRows(lstReservoir);
// }
// lstLayerData = lstLayerData.Where(x => !double.IsNaN(x.DATA)).ToList();
// }
// return lstLayerData;
//}
///// <summary>
///// 创建井分层数据
///// </summary>
///// <param name="layerName">层位名称</param>
///// <param name="depthType">类型名称</param>
///// <returns>List<InterpretDrillWellLayered></returns>
//public static List<InterpretDrillWellLayered> CreateDrillWellLayerData(string layerName, GeoLayerDepthType depthType = GeoLayerDepthType.测深厚度)
//{
// // 井分层
// // 获取层
// List<string> lstLayerName = GetReservoirChildLayers(layerName);
// List<InterpretDrillWellLayered> lstLayerData = DBHelp.NewDb.Queryable<InterpretDrillWellLayered>().Where(d => lstLayerName.Contains(SqlFunc.ToUpper(d.CW)) && d.X.HasValue && d.Y.HasValue).Select(d => new InterpretDrillWellLayered
// {
// CW = d.CW,
// X = d.X,
// Y = d.Y,
// DJSD = depthType == GeoLayerDepthType.测深厚度 ? (d.DJSD ?? 0) : (depthType == GeoLayerDepthType.海拔 ? d.HBSD2 ?? 0 : d.CS_B ?? 0),
// SD = depthType == GeoLayerDepthType.测深厚度 ? (d.SD ?? 0) : (depthType == GeoLayerDepthType.海拔 ? d.HBSD1 ?? 0 : d.CS_T ?? 0),
// JH = d.JH,
// }).ToList();
// //按井分组求和
// var lstResult = lstLayerData.GroupBy(x => x.JH).Select(x => new InterpretDrillWellLayered()
// {
// JH = x.Key,
// CW = x.First().CW,
// X = x.First().X,
// Y = x.First().Y,
// SD = depthType == GeoLayerDepthType.海拔 ? x.Max(c => c.SD) : x.Min(c => c.SD),
// }).ToList();
// return lstResult;
//}
/// <summary>
/// 求和算法
/// </summary>
/// <param name="lstReservoir">The lst reservoir.</param>
/// <param name="parentLayer">The parent layer.</param>
/// <returns>A list of ReservoirEntities.</returns>
private static List<ReservoirEntity> SumRows(List<ReservoirEntity> lstReservoir, string parentLayer)
{
List<string> wells = lstReservoir.Select(e => e.JH).Distinct().ToList();
List<ReservoirEntity> lstLayerData = new List<ReservoirEntity>();
foreach (string well in wells)
{
List<ReservoirEntity> layerData = lstReservoir.Where(it => it.JH == well && it.Layer == parentLayer).ToList();
if (layerData.Count > 0)
{
ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(layerData[0]);
entityPush.DATA = 0;
foreach (ReservoirEntity item in layerData)
{
entityPush.DATA += item.DATA;
}
lstLayerData.Add(entityPush);
continue;
}
// 累加所有子层
layerData = lstReservoir.Where(it => it.JH == well && it.Layer != parentLayer).ToList();
if (layerData.Count > 0)
{
ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(layerData[0]);
entityPush.DATA = 0;
foreach (ReservoirEntity item in layerData)
{
entityPush.DATA += item.DATA;
}
lstLayerData.Add(entityPush);
}
}
return lstLayerData;
}
/// <summary>
/// 平均值
/// </summary>
/// <param name="lstReservoir">The lst reservoir.</param>
/// <returns>A list of ReservoirEntities.</returns>
private static List<ReservoirEntity> AverageRows(List<ReservoirEntity> lstReservoir)
{
List<ReservoirEntity> lstLayerData = new List<ReservoirEntity>();
if (lstReservoir.Count == 0)
{
return lstLayerData;
}
int nCount = 0;
double dDataSum = 0;
ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(lstReservoir.FirstOrDefault());
foreach (ReservoirEntity item in lstReservoir)
{
if (!entityPush.JH.Equals(item.JH))
{
entityPush.DATA = dDataSum / nCount;
lstLayerData.Add(entityPush);
entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(item);
nCount = 0;
dDataSum = 0;
}
nCount++;
dDataSum += item.DATA;
}
entityPush.DATA = Math.Round(dDataSum / nCount, 2);
lstLayerData.Add(entityPush);
return lstLayerData;
}
/// <summary>
/// 孔隙度/渗透率加权算法值
/// </summary>
/// <param name="lstReservoir">The lst reservoir.</param>
/// <returns>A list of ReservoirEntities.</returns>
private static List<ReservoirEntity> PorosityAverageRows(List<ReservoirEntity> lstReservoir)
{
List<ReservoirEntity> lstLayerData = new List<ReservoirEntity>();
if (lstReservoir.Count == 0)
{
return lstLayerData;
}
ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(lstReservoir.FirstOrDefault());
double kxdSum = 0;
double yxhdSum = 0;
entityPush = lstReservoir.FirstOrDefault();
foreach (ReservoirEntity item in lstReservoir)
{
if (!entityPush.JH.Equals(item.JH))
{
// 保存上一条数据
entityPush.DATA = kxdSum / yxhdSum;
lstLayerData.Add(entityPush);
// 生成新的数据
entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(item);
kxdSum = 0;
yxhdSum = 0;
}
kxdSum += item.DATA * item.YXHD;
yxhdSum += item.YXHD;
}
// 保存最一条数据
entityPush.DATA = Math.Round(kxdSum / yxhdSum, 2);
lstLayerData.Add(entityPush);
return lstLayerData;
}
/// <summary>
/// 饱和度加权算法值
/// </summary>
/// <param name="lstReservoir">The lst reservoir.</param>
/// <returns>A list of ReservoirEntities.</returns>
private static List<ReservoirEntity> SaturationAverageRows(List<ReservoirEntity> lstReservoir)
{
List<ReservoirEntity> lstLayerData = new List<ReservoirEntity>();
if (lstReservoir.Count == 0)
{
return lstLayerData;
}
double kxdSum = 0;
double yxhdSum = 0;
ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(lstReservoir.FirstOrDefault());
foreach (ReservoirEntity item in lstReservoir)
{
if (!entityPush.JH.Equals(item.JH))
{
// 保存上一条数据
entityPush.DATA = kxdSum / yxhdSum;
lstLayerData.Add(entityPush);
// 生成新的数据
entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(item);
kxdSum = 0;
yxhdSum = 0;
}
kxdSum += item.KXD * item.YXHD * item.BHD;
yxhdSum += item.KXD * item.YXHD;
}
entityPush.DATA = Math.Round(kxdSum / yxhdSum, 2);
lstLayerData.Add(entityPush);
return lstLayerData;
}
/// <summary>
/// 储层计算临时类
/// </summary>
public class ReservoirEntity
{
public string CXB { get; set; }
public string MQJB { get; set; }
public string JH { get; set; } = string.Empty;
public double? SD { get; set; }
public double X { get; set; }
public double Y { get; set; }
/// <summary>
/// 数据
/// </summary>
public double DATA { get; set; }
/// <summary>
/// 层位
/// </summary>
public string Layer { get; set; }
/// <summary>
/// 孔隙度
/// </summary>
public double KXD { get; set; }
/// <summary>
/// 有效厚度
/// </summary>
public double YXHD { get; set; }
/// <summary>
/// 饱和度
/// </summary>
public double BHD { get; set; }
/// <summary>
/// 渗透率
/// </summary>
public double STL { get; set; }
/// <summary>
/// 砂岩厚度
/// </summary>
public double SYHD { get; set; }
}
}
}