|
|
// <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; }
|
|
|
}
|
|
|
}
|
|
|
}
|