921 lines
38 KiB
C#
921 lines
38 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Collections.ObjectModel;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using System.Threading.Tasks;
|
||
using Geo;
|
||
using TriangleNet;
|
||
using TriangleNet.Geometry;
|
||
using TriangleNet.Meshing;
|
||
using TriangleNet.Tools;
|
||
|
||
namespace GroundOrganizer
|
||
{
|
||
[Serializable]
|
||
public class Foundation
|
||
{
|
||
public int Number { get; set; }
|
||
public string Name { get; set; }
|
||
public TypeFound Type { get; set; }
|
||
public bool Basement { get; set; }
|
||
public double B { get; set; }
|
||
public double L { get; set; }
|
||
public double Db { get; set; }
|
||
public double D1 { get; set; }
|
||
public double H { get; set; }
|
||
public double AlfaDeg { get; set; }
|
||
public double Hs { get; set; }
|
||
public double Hcf { get; set; }
|
||
public double Ycf { get; set; }
|
||
public double X { get; set; }
|
||
public double Y { get; set; }
|
||
/// <summary>
|
||
/// Относительная отметка подошвы фундамента
|
||
/// </summary>
|
||
public double FL { get; set; }
|
||
/// <summary>
|
||
/// Абсолютная отметка планировки в центральной точке фундамента
|
||
/// </summary>
|
||
public double DL { get; set; }
|
||
/// <summary>
|
||
/// Абсолютная отметка естественного рельефа в центральной точке фундамента
|
||
/// </summary>
|
||
public double NL { get; set; }
|
||
public ObservableCollection<FoundLoad> Loads { get; set; }
|
||
public UnitsForce UnitsF { get; set; }
|
||
public UnitsLin UnitsL { get; set; }
|
||
public Quadrangle Contour { get; set; }
|
||
|
||
public List<DataPair> FullResults { get; private set; }
|
||
public List<DataPairProps> FullProps { get; private set; }
|
||
public List<DataPair> MediumResults { get; private set; }
|
||
public List<DataPairProps> MediumProps { get; private set; }
|
||
public List<DataPair> SmallResults{ get; private set; }
|
||
public List<DataPairProps> SmallProps{ get; private set; }
|
||
|
||
public Foundation()
|
||
{
|
||
Loads = new ObservableCollection<FoundLoad>();
|
||
Type = TypeFound.Прямоугольный;
|
||
UnitsF = UnitsForce.т;
|
||
UnitsL = UnitsLin.м;
|
||
Ycf = 2.2;
|
||
FullResults = new List<DataPair>();
|
||
MediumResults = new List<DataPair>();
|
||
SmallResults = new List<DataPair>();
|
||
}
|
||
|
||
public Foundation(Quadrangle cntr)
|
||
{
|
||
if (cntr.Units == UnitsLin.см)
|
||
{
|
||
Contour.Vertex1 = cntr.Vertex1 * 0.01;
|
||
Contour.Vertex2 = cntr.Vertex2 * 0.01;
|
||
Contour.Vertex3 = cntr.Vertex3 * 0.01;
|
||
Contour.Vertex4 = cntr.Vertex4 * 0.01;
|
||
}
|
||
if (cntr.Units == UnitsLin.мм)
|
||
{
|
||
Contour.Vertex1 = cntr.Vertex1 * 0.001;
|
||
Contour.Vertex2 = cntr.Vertex2 * 0.001;
|
||
Contour.Vertex3 = cntr.Vertex3 * 0.001;
|
||
Contour.Vertex4 = cntr.Vertex4 * 0.001;
|
||
}
|
||
if(cntr.Units == UnitsLin.м) Contour = cntr;
|
||
|
||
X = Math.Round(Contour.Centroid.X, 3);
|
||
Y = Math.Round(Contour.Centroid.Y, 3);
|
||
|
||
IOrderedEnumerable<Line2d> selected = from l in Contour.Segments // определяем каждый объект как
|
||
orderby l.Length // упорядочиваем по возрастанию
|
||
select l; // выбираем объект
|
||
|
||
AlfaDeg = Math.Round(RadToDeg(Math.Acos(selected.First().Directive.Vx / selected.First().Length)), 3);
|
||
B = Math.Round(selected.First().Length, 3);
|
||
L = Math.Round(selected.Last().Length, 3);
|
||
|
||
Loads = new ObservableCollection<FoundLoad>();
|
||
Type = TypeFound.Прямоугольный;
|
||
UnitsF = UnitsForce.т;
|
||
UnitsL = UnitsLin.м;
|
||
Ycf = 2.2;
|
||
FullResults = new List<DataPair>();
|
||
MediumResults = new List<DataPair>();
|
||
SmallResults = new List<DataPair>();
|
||
}
|
||
|
||
internal void CreateFullPropsList()
|
||
{
|
||
FullProps = new List<DataPairProps>();
|
||
DataPairProps dataPair = new DataPairProps() { Описание = "Номер", Параметр = Number };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Марка", Параметр = Name };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Ширина", Параметр = B, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Длина", Параметр = L, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Высота", Параметр = H, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка подошвы", Параметр = FL, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Глубина заложения", Параметр = D1, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка планировки", Параметр = DL };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка рельефа", Параметр = NL };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Наличие подвала", Параметр = Basement };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Глубина подвала", Параметр = Db, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "h_s", Параметр = Hs, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "h_cf", Параметр = Hcf, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Ycf, т/м3", Параметр = Ycf };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Х", Параметр = X, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Y", Параметр = Y, Ед_изм = UnitsList.м };
|
||
FullProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Поворот", Параметр = AlfaDeg, Ед_изм= UnitsList.градус };
|
||
FullProps.Add(dataPair);
|
||
|
||
}
|
||
|
||
internal void CreateMediumPropsList()
|
||
{
|
||
MediumProps = new List<DataPairProps>();
|
||
DataPairProps dataPair = new DataPairProps() { Описание = "Номер", Параметр = Number };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Марка", Параметр = Name };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Ширина", Параметр = B, Ед_изм = UnitsList.м };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Длина", Параметр = L, Ед_изм = UnitsList.м };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Высота", Параметр = H, Ед_изм = UnitsList.м };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка подошвы", Параметр = FL, Ед_изм = UnitsList.м };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Глубина заложения", Параметр = D1, Ед_изм = UnitsList.м };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка планировки", Параметр = DL };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка рельефа", Параметр = NL };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Наличие подвала", Параметр = Basement };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Глубина подвала", Параметр = Db, Ед_изм = UnitsList.м };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "h_s", Параметр = Hs, Ед_изм = UnitsList.м };
|
||
MediumProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "h_cf", Параметр = Hcf, Ед_изм = UnitsList.м };
|
||
MediumProps.Add(dataPair);
|
||
}
|
||
|
||
internal void CreateSmallPropsList()
|
||
{
|
||
SmallProps = new List<DataPairProps>();
|
||
DataPairProps dataPair = new DataPairProps() { Описание = "Номер", Параметр = Number };
|
||
SmallProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Марка", Параметр = Name };
|
||
SmallProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Ширина b", Параметр = B, Ед_изм = UnitsList.м };
|
||
SmallProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Длина l", Параметр = L, Ед_изм = UnitsList.м };
|
||
SmallProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Высота h", Параметр = H, Ед_изм = UnitsList.м };
|
||
SmallProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка подошвы FL", Параметр = FL, Ед_изм = UnitsList.м };
|
||
SmallProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Глубина заложения d_1", Параметр = D1, Ед_изм = UnitsList.м };
|
||
SmallProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка планировки DL", Параметр = DL, Ед_изм = UnitsList.м };
|
||
SmallProps.Add(dataPair);
|
||
dataPair = new DataPairProps() { Описание = "Отметка рельефа NL", Параметр = NL, Ед_изм = UnitsList.м };
|
||
SmallProps.Add(dataPair);
|
||
}
|
||
|
||
public DataS Sp(Bore bore, FoundLoad load, double kHc = 0.5, PointFound ptFond = PointFound.Центр)
|
||
{
|
||
DataS res = new DataS();
|
||
List<Layer> downFS = DownFS(bore);
|
||
List<double> n = res.N;
|
||
n = new List<double>();
|
||
|
||
foreach (Layer item in downFS)
|
||
{
|
||
n.Add(Math.Ceiling(item.H / (0.4 * B)));
|
||
}
|
||
|
||
List<Layer> layers = new List<Layer>();
|
||
for (int i = 0; i < n.Count; i++)
|
||
{
|
||
double z = downFS[i].Up;
|
||
double dlt = downFS[i].H / n[i];
|
||
while (downFS[i].Down > z)
|
||
{
|
||
z += dlt;
|
||
Layer lay = downFS[i].Clone();
|
||
lay.Down = z;
|
||
lay.H = dlt;
|
||
lay.Up = z - dlt;
|
||
layers.Add(lay);
|
||
}
|
||
}
|
||
|
||
double FL;
|
||
if (Basement) FL = Hs + Hcf + Db;
|
||
else FL = D1;
|
||
|
||
res.Z = new List<double>() { 0 };
|
||
foreach (Layer item in layers)
|
||
{
|
||
res.Z.Add(item.Up + 0.5 * item.H - FL);
|
||
}
|
||
|
||
res.Alfa = TablesInterolator.Table_5_8(res.Z, B, L, Type);
|
||
|
||
List<Layer> upF = UpF(bore);
|
||
double roh = 0;
|
||
double h = 0;
|
||
if (upF.Count > 0)
|
||
{
|
||
foreach (Layer item in upF)
|
||
{
|
||
roh += item.H * item.IGE.RoII;
|
||
h += item.H;
|
||
}
|
||
}
|
||
res.YIIu = Math.Round(roh / h, 3);
|
||
|
||
double sig_zg0 = res.YIIu * FL;
|
||
double p = load.N / (B * L) + load.q + 2 * FL;
|
||
|
||
res.sig_zy = new List<double>();
|
||
res.sig_zp = new List<double>();
|
||
for (int i = 0; i < res.Z.Count; i++)
|
||
{
|
||
res.sig_zp.Add((double)res.Alfa[i] * p);
|
||
res.sig_zy.Add((double)res.Alfa[i] * sig_zg0);
|
||
}
|
||
|
||
res.sig_zg = new List<double> { sig_zg0 };
|
||
res.E = new List<double>();
|
||
for (int i = 0; i < layers.Count; i++)
|
||
{
|
||
res.sig_zg.Add(sig_zg0 + layers[i].IGE.RoII * (res.Z[i + 1] - (layers[i].Up - FL)));
|
||
sig_zg0 += layers[i].H * layers[i].IGE.RoII;
|
||
res.E.Add(layers[i].IGE.E * 101.972);
|
||
}
|
||
|
||
sig_zg0 = res.YIIu * FL;
|
||
|
||
if (B <= 10) res.Hmin = B / 2;
|
||
else if (B > 10 && B <= 60) res.Hmin = 4 + 0.1 * B;
|
||
else res.Hmin = 10;
|
||
|
||
int j = 0;
|
||
for (int i = 0; i < layers.Count; i++)
|
||
{
|
||
if (res.sig_zp[i] >= kHc * res.sig_zg[i])
|
||
{
|
||
res.Hc = res.Z[i];
|
||
}
|
||
else
|
||
{
|
||
j = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
int t = 0; double pt = layers[t].H;
|
||
while (pt <= res.Hmin)
|
||
{
|
||
t++;
|
||
pt += layers[t].H;
|
||
}
|
||
|
||
if (res.Hmin > res.Hc)
|
||
{
|
||
res.Hc = res.Hmin;
|
||
j = t;
|
||
}
|
||
|
||
if (sig_zg0 >= p)
|
||
{
|
||
for (int i = 0; i <= j; i++)
|
||
{
|
||
res.Sp += res.sig_zp[i + 1] * layers[i].H / (5 * res.E[i]);
|
||
}
|
||
res.Sp *= 0.8;
|
||
}
|
||
else
|
||
{
|
||
for (int i = 0; i <= j; i++)
|
||
{
|
||
res.Sp += (res.sig_zp[i + 1] - res.sig_zy[i + 1]) * layers[i].H / res.E[i] + res.sig_zy[i + 1] * layers[i].H / (5 * res.E[i]);
|
||
}
|
||
res.Sp *= 0.8;
|
||
}
|
||
|
||
res.Sp = Math.Round(res.Sp * 100, 1);
|
||
res.p = Math.Round(p, 2);
|
||
|
||
return res;
|
||
}
|
||
public DataR P(Bore bore, TypeFlexStructure ts, double ls, double hs, double k = 1)
|
||
{
|
||
DataR dataR = R(bore, ts, ls, hs, k);
|
||
dataR.Base = Name;
|
||
dataR.Bore = "Скв." + bore.Name;
|
||
|
||
if (Loads == null || Loads.Count == 0)
|
||
{
|
||
FullResults = dataR.FullResults();
|
||
MediumResults = dataR.MediumResults();
|
||
SmallResults = dataR.SmallResults();
|
||
return dataR;
|
||
}
|
||
List<double> P = new List<double>(Loads.Count);
|
||
List<double> PmaxX = new List<double>(Loads.Count);
|
||
List<double> PmaxY = new List<double>(Loads.Count);
|
||
List<double> chP = new List<double>(Loads.Count);
|
||
List<double> GapX = new List<double>(Loads.Count);
|
||
List<double> GapY = new List<double>(Loads.Count);
|
||
List<double> chGap = new List<double>(Loads.Count);
|
||
foreach (FoundLoad item in Loads)
|
||
{
|
||
P.Add(item.N / (B * L) + item.q + 2 * D1);
|
||
double ex = (Math.Abs(item.Mx) / (item.N + 2 * D1 * L * B)) / L;
|
||
double wx = (B * L * L * L) / 6;
|
||
double pmaxx;
|
||
if (ex <= (1.0 / 6)) {pmaxx= item.N / (B * L) + 2 * D1 + Math.Abs(item.Mx) / wx; PmaxX.Add(pmaxx); GapX.Add(0); ex = 0; }
|
||
else
|
||
{
|
||
double C0x = 0.5 * L - item.Mx / (item.N + 2 * D1 * L * B);
|
||
pmaxx = 2 * (item.N + 2 * D1 * L * B) / (3 * B * C0x);
|
||
PmaxX.Add(pmaxx);
|
||
GapX.Add(ex);
|
||
}
|
||
double ey = (Math.Abs(item.My) / (item.N + 2 * D1 * L * B)) / B;
|
||
double wy = (L * B * B * B) / 6;
|
||
double pmaxy;
|
||
if (ey <= (1.0 / 6)) {pmaxy= item.N / (B * L) + 2 * D1 + Math.Abs(item.My) / wy; PmaxY.Add(pmaxy); GapY.Add(0); ey = 0; }
|
||
else
|
||
{
|
||
double C0y = 0.5 * B - item.My / (item.N + 2 * D1 * L * B);
|
||
pmaxy = 2 * (item.N + 2 * D1 * L * B) / (3 * L * C0y);
|
||
PmaxY.Add(pmaxy);
|
||
GapY.Add(ey);
|
||
}
|
||
chGap.Add(Math.Max(ex, ey));
|
||
List<double> chp = new List<double> { (item.N / (B * L) + item.q + 2 * D1) / dataR.R, pmaxx / (1.2 * dataR.R), pmaxy / (1.2 * dataR.R) };
|
||
chP.Add(chp.Max());
|
||
}
|
||
dataR.P = Math.Round(P.Max(), 3);
|
||
dataR.PmaxX = Math.Round(PmaxX.Max(), 3);
|
||
dataR.PmaxY = Math.Round(PmaxY.Max(), 3);
|
||
dataR.CheckP = Math.Round(chP.Max(), 3);
|
||
dataR.CheckGap = Math.Round(chGap.Max(), 3);
|
||
dataR.GapX = Math.Round(GapX.Max(), 3);
|
||
dataR.GapY = Math.Round(GapY.Max(), 3);
|
||
|
||
FullResults = dataR.FullResults();
|
||
MediumResults = dataR.MediumResults();
|
||
SmallResults = dataR.SmallResults();
|
||
|
||
return dataR;
|
||
}
|
||
public ObservableCollection<DataR> P(ObservableCollection<Bore> bores, TypeFlexStructure ts, double ls, double hs, double k = 1)
|
||
{
|
||
ObservableCollection<DataR> res = new ObservableCollection<DataR>();
|
||
foreach (Bore bore in bores)
|
||
{
|
||
DataR dataR = R(bore, ts, ls, hs, k);
|
||
dataR.Base = Name;
|
||
dataR.Bore = "Скв." + bore.Name;
|
||
|
||
if (Loads == null || Loads.Count == 0)
|
||
{
|
||
dataR.CreateFullData();
|
||
dataR.CreateMediumData();
|
||
dataR.CreateSmallData();
|
||
res.Add(dataR);
|
||
continue;
|
||
}
|
||
List<double> P = new List<double>(Loads.Count);
|
||
List<double> PmaxX = new List<double>(Loads.Count);
|
||
List<double> PmaxY = new List<double>(Loads.Count);
|
||
List<double> chP = new List<double>(Loads.Count);
|
||
List<double> GapX = new List<double>(Loads.Count);
|
||
List<double> GapY = new List<double>(Loads.Count);
|
||
List<double> chGap = new List<double>(Loads.Count);
|
||
foreach (FoundLoad item in Loads)
|
||
{
|
||
P.Add(item.N / (B * L) + item.q + 2 * D1);
|
||
double ex = (item.Mx / (item.N + 2 * D1 * L * B)) / L;
|
||
double wx = (B * L * L * L) / 6;
|
||
double pmaxx;
|
||
if (ex <= 1 / 6) { pmaxx = item.N / (B * L) + 2 * D1 + Math.Abs(item.Mx) / wx; PmaxX.Add(pmaxx); GapX.Add(0); ex = 0; }
|
||
else
|
||
{
|
||
double C0x = 0.5 * L - item.Mx / (item.N + 2 * D1 * L * B);
|
||
pmaxx = 2 * (item.N + 2 * D1 * L * B) / (3 * B * C0x);
|
||
PmaxX.Add(pmaxx);
|
||
GapX.Add(ex);
|
||
}
|
||
double ey = (item.My / (item.N + 2 * D1 * L * B)) / B;
|
||
double wy = (L * B * B * B) / 6;
|
||
double pmaxy;
|
||
if (ey <= 1 / 6) { pmaxy = item.N / (B * L) + 2 * D1 + Math.Abs(item.My) / wy; PmaxY.Add(pmaxy); GapY.Add(0); ey = 0; }
|
||
else
|
||
{
|
||
double C0y = 0.5 * B - item.My / (item.N + 2 * D1 * L * B);
|
||
pmaxy = 2 * (item.N + 2 * D1 * L * B) / (3 * L * C0y);
|
||
PmaxY.Add(pmaxy);
|
||
GapY.Add(ey);
|
||
}
|
||
chGap.Add(Math.Max(ex, ey));
|
||
List<double> chp = new List<double> { (item.N / (B * L) + item.q + 2 * D1) / dataR.R, pmaxx / (1.2 * dataR.R), pmaxy / (1.2 * dataR.R) };
|
||
chP.Add(chp.Max());
|
||
}
|
||
dataR.P = Math.Round(P.Max(), 3);
|
||
dataR.PmaxX = Math.Round(PmaxX.Max(), 3);
|
||
dataR.PmaxY = Math.Round(PmaxY.Max(), 3);
|
||
dataR.CheckP = Math.Round(chP.Max(), 3);
|
||
dataR.CheckGap = Math.Round(chGap.Max(), 3);
|
||
dataR.GapX = Math.Round(GapX.Max(), 3);
|
||
dataR.GapY = Math.Round(GapY.Max(), 3);
|
||
|
||
dataR.CreateFullData();
|
||
dataR.CreateMediumData();
|
||
dataR.CreateSmallData();
|
||
|
||
res.Add(dataR);
|
||
}
|
||
|
||
return res;
|
||
}
|
||
private DataR R(Bore bore, TypeFlexStructure ts, double ls, double hs, double k = 1)
|
||
{
|
||
DataR res = new DataR();
|
||
List<Layer> upF = UpF(bore);
|
||
List<Layer> downF = DownF(bore);
|
||
double roh = 0;
|
||
double h = 0;
|
||
if (upF.Count > 0)
|
||
{
|
||
foreach (Layer item in upF)
|
||
{
|
||
roh += item.H * item.IGE.RoII;
|
||
h += item.H;
|
||
}
|
||
}
|
||
res.YIIu = Math.Round(roh / h, 3);
|
||
|
||
double fih = 0;
|
||
double ch = 0;
|
||
roh = 0;
|
||
h = 0;
|
||
if (downF.Count > 0)
|
||
{
|
||
foreach (Layer item in downF)
|
||
{
|
||
fih += item.H * item.IGE.FiII;
|
||
ch += item.H * item.IGE.CII * 100;
|
||
roh += item.H * item.IGE.RoII;
|
||
h += item.H;
|
||
}
|
||
}
|
||
res.YII = Math.Round(roh / h, 3);
|
||
res.FiII = Math.Round(fih / h);
|
||
res.CII = Math.Round(ch / h, 3);
|
||
res.IL = downF[0].IGE.IL;
|
||
res.Ke = downF[0].IGE.Ke;
|
||
res.Ys = downF[0].IGE.Ys;
|
||
res.Ground = "ИГЭ " + downF[0].IGE.NumIGE + " " + downF[0].IGE.Description;
|
||
res.GroundType = downF[0].IGE.GroundType;
|
||
res.Yc1 = TablesInterolator.Yc1(res.GroundType);
|
||
res.Yc2 = TablesInterolator.Yc2(res.GroundType, ts, ls, hs);
|
||
double[] MyMqMc = TablesInterolator.My_Mq_Mc(res.FiII);
|
||
res.My = MyMqMc[0];
|
||
res.Mq = MyMqMc[1];
|
||
res.Mc = MyMqMc[2];
|
||
res.K = k;
|
||
|
||
if (B < 10) res.Kz = 1;
|
||
else res.Kz = 8 / B + 0.2;
|
||
|
||
if (Basement) res.d1 = Math.Round(Hs + Hcf * (Ycf / res.YIIu), 3);
|
||
else res.d1 = D1;
|
||
|
||
if (Basement && Db > 2) res.db = 2;
|
||
else if (Basement && Db <= 2) res.db = Db;
|
||
else res.db = 0;
|
||
|
||
res.R = res.Yc1 * res.Yc2 * (res.My * res.Kz * B * res.YII + res.Mq * res.d1 * res.YIIu + (res.Mq - 1) * res.db * res.YIIu + res.Mc * res.CII) / k;
|
||
res.R = Math.Round(res.R, 2);
|
||
//res.GroundType = "";
|
||
|
||
return res;
|
||
}
|
||
private List<Layer> UpF(Bore bore)
|
||
{
|
||
List<Layer> res = new List<Layer>();
|
||
double d;
|
||
if (Basement) d = Hs + Hcf + Db;
|
||
else d = D1;
|
||
|
||
double FL;
|
||
FL = d;
|
||
|
||
Bore boreW = BoreW(bore);
|
||
if (boreW.Layers.Count == 0) return res;
|
||
foreach (Layer item in boreW.Layers)
|
||
{
|
||
if (item.Up > FL) break;
|
||
res.Add(item.Clone());
|
||
}
|
||
res[res.Count - 1].Down = FL;
|
||
res[res.Count - 1].H = res[res.Count - 1].Down - res[res.Count - 1].Up;
|
||
|
||
return res;
|
||
}
|
||
private List<Layer> DownF(Bore bore)
|
||
{
|
||
List<Layer> res = new List<Layer>();
|
||
double d, z;
|
||
if (Basement) d = Hs + Hcf + Db;
|
||
else d = D1;
|
||
|
||
if (B < 10) z = 0.5 * B;
|
||
else z = 4 + 0.1 * B;
|
||
|
||
double FL, ZL;
|
||
FL = d;
|
||
ZL = d + z;
|
||
|
||
Bore boreW = BoreW(bore);
|
||
if (boreW.Layers.Count == 0) return res;
|
||
foreach (Layer item in boreW.Layers)
|
||
{
|
||
if (item.Down > FL) res.Add(item.Clone());
|
||
if (item.Down >= ZL) break;
|
||
}
|
||
res[0].Up = FL;
|
||
res[0].H = res[0].Down - res[0].Up;
|
||
res[res.Count - 1].Down = ZL;
|
||
res[res.Count - 1].H = res[res.Count - 1].Down - res[res.Count - 1].Up;
|
||
return res;
|
||
}
|
||
private List<Layer> UpW(Bore bore)
|
||
{
|
||
List<Layer> res = new List<Layer>();
|
||
foreach (Layer item in bore.Layers)
|
||
{
|
||
if (item.Up > bore.WL) break;
|
||
res.Add(item.Clone());
|
||
}
|
||
if (res.Count > 0)
|
||
{
|
||
res[res.Count - 1].Down = (double)bore.WL;
|
||
res[res.Count - 1].H = res[res.Count - 1].Down - res[res.Count - 1].Up;
|
||
}
|
||
return res;
|
||
}
|
||
private List<Layer> DownW(Bore bore)
|
||
{
|
||
List<Layer> layers = new List<Layer>(bore.Layers.Reverse());
|
||
List<Layer> res = new List<Layer>();
|
||
foreach (Layer item in layers)
|
||
{
|
||
if (item.Down <= bore.WL) break;
|
||
if (item.IGE.W) item.IGE.RoII = (item.IGE.Ys - 1) / (1 + item.IGE.Ke);
|
||
res.Add(item.Clone());
|
||
}
|
||
if (res.Count > 0)
|
||
{
|
||
res.Reverse();
|
||
res[0].Up = (double)bore.WL;
|
||
res[0].H = res[0].Down - res[0].Up;
|
||
}
|
||
return res;
|
||
}
|
||
private List<Layer> DownFS(Bore bore)
|
||
{
|
||
List<Layer> res = new List<Layer>();
|
||
double FL;
|
||
|
||
if (Basement) FL = Hs + Hcf + Db;
|
||
else FL = D1;
|
||
|
||
Bore boreW = BoreW(bore);
|
||
if (boreW.Layers.Count == 0) return res;
|
||
|
||
foreach (Layer item in boreW.Layers.Reverse())
|
||
{
|
||
if (item.Down < FL) break;
|
||
res.Add(item.Clone());
|
||
}
|
||
|
||
if (res.Count > 0) res.Reverse();
|
||
res[0].Up = FL;
|
||
res[0].H = res[0].Down - res[0].Up;
|
||
|
||
return res;
|
||
}
|
||
private Bore BoreW(Bore bore)
|
||
{
|
||
Bore res = new Bore
|
||
{
|
||
Name = bore.Name,
|
||
Number = bore.Number,
|
||
WL = bore.WL,
|
||
X = bore.X,
|
||
Y = bore.Y,
|
||
Z = bore.Z
|
||
};
|
||
List<Layer> downW = DownW(bore);
|
||
List<Layer> layers = new List<Layer>(UpW(bore));
|
||
if (downW.Count > 0) layers.AddRange(downW);
|
||
if (layers.Count > 0)
|
||
{
|
||
res.Layers = new ObservableCollection<Layer>(layers);
|
||
res.Layers[res.Layers.Count - 1].Down = res.Layers[res.Layers.Count - 1].Down + bore.DZ;
|
||
res.Layers[res.Layers.Count - 1].H = res.Layers[res.Layers.Count - 1].H + bore.DZ;
|
||
res.Layers[res.Layers.Count - 1].Z = res.Layers[res.Layers.Count - 1].Z - bore.DZ;
|
||
return res;
|
||
}
|
||
else
|
||
{
|
||
bore.Layers[bore.Layers.Count - 1].Down = bore.Layers[bore.Layers.Count - 1].Down + bore.DZ;
|
||
bore.Layers[bore.Layers.Count - 1].H = bore.Layers[bore.Layers.Count - 1].H + bore.DZ;
|
||
bore.Layers[bore.Layers.Count - 1].Z = bore.Layers[bore.Layers.Count - 1].Z - bore.DZ;
|
||
return bore;
|
||
}
|
||
}
|
||
|
||
internal void CalcDL(Structure str)
|
||
{
|
||
if (str == null || str.RedPlanning == null || str.RedPlanning.Count == 0) return;
|
||
|
||
List<Vertex> vrtxs = new List<Vertex>();
|
||
Vertex vrtx;
|
||
int i = 1;
|
||
foreach (PlanningVertex item in str.RedPlanning)
|
||
{
|
||
vrtx = new Vertex(item.X, item.Y, item.Number, 2);
|
||
vrtx.Attributes[0] = item.Red;
|
||
vrtx.Attributes[1] = item.Black;
|
||
vrtxs.Add(vrtx);
|
||
i++;
|
||
}
|
||
|
||
Contour cnt = new Contour(vrtxs);
|
||
TriangleNet.Geometry.Polygon polygon = new TriangleNet.Geometry.Polygon();
|
||
polygon.Add(cnt);
|
||
GenericMesher mesher = new GenericMesher();
|
||
ConstraintOptions constraint = new ConstraintOptions();
|
||
constraint.Convex = true;
|
||
Mesh meshPlanning = (Mesh)mesher.Triangulate(polygon, constraint);
|
||
TriangleQuadTree meshTree = new TriangleQuadTree(meshPlanning);
|
||
TriangleNet.Topology.Triangle trgl = (TriangleNet.Topology.Triangle)meshTree.Query(X, Y);
|
||
if (trgl == null)
|
||
{
|
||
Dictionary<Vertex, double> valuePairs = new Dictionary<Vertex, double>();
|
||
Line2d ln;
|
||
foreach (Vertex item in meshPlanning.Vertices)
|
||
{
|
||
ln = new Line2d(new Point2d(X, Y), new Point2d(item.X, item.Y));
|
||
valuePairs.Add(item, ln.Length);
|
||
}
|
||
IOrderedEnumerable<KeyValuePair<Vertex, double>> selected = from v in valuePairs // определяем каждый объект как
|
||
orderby v.Value // упорядочиваем по возрастанию
|
||
select v; // выбираем объект
|
||
List<KeyValuePair<Vertex, double>> lst = selected.ToList();
|
||
foreach (TriangleNet.Topology.Triangle item in meshPlanning.Triangles)
|
||
{
|
||
if (item.Contains(lst[0].Key) && item.Contains(lst[1].Key)) { trgl = item; break; }
|
||
}
|
||
}
|
||
vrtx = new Vertex(X, Y, Number, 2);
|
||
Interpolation.InterpolateAttributes(vrtx, trgl, 1);
|
||
DL = Math.Round(vrtx.Attributes[0], 3);
|
||
}
|
||
|
||
internal void CalcDL(Mesh planningMesh)
|
||
{
|
||
if (planningMesh == null) return;
|
||
|
||
Vertex vrtx;
|
||
TriangleQuadTree meshTree = new TriangleQuadTree(planningMesh);
|
||
TriangleNet.Topology.Triangle trgl = (TriangleNet.Topology.Triangle)meshTree.Query(X, Y);
|
||
if (trgl == null)
|
||
{
|
||
Dictionary<Vertex, double> valuePairs = new Dictionary<Vertex, double>();
|
||
Line2d ln;
|
||
foreach (Vertex item in planningMesh.Vertices)
|
||
{
|
||
ln = new Line2d(new Point2d(X, Y), new Point2d(item.X, item.Y));
|
||
valuePairs.Add(item, ln.Length);
|
||
}
|
||
IOrderedEnumerable<KeyValuePair<Vertex, double>> selected = from v in valuePairs // определяем каждый объект как
|
||
orderby v.Value // упорядочиваем по возрастанию
|
||
select v; // выбираем объект
|
||
List<KeyValuePair<Vertex, double>> lst = selected.ToList();
|
||
foreach (TriangleNet.Topology.Triangle item in planningMesh.Triangles)
|
||
{
|
||
if (item.Contains(lst[0].Key) && item.Contains(lst[1].Key)) { trgl = item; break; }
|
||
}
|
||
}
|
||
vrtx = new Vertex(X, Y, Number, 2);
|
||
Interpolation.InterpolateAttributes(vrtx, trgl, 1);
|
||
DL = Math.Round(vrtx.Attributes[0], 3);
|
||
}
|
||
|
||
internal void CalcNL(Mesh blackMesh)
|
||
{
|
||
if (blackMesh == null) return;
|
||
|
||
Vertex vrtx;
|
||
TriangleQuadTree meshTree = new TriangleQuadTree(blackMesh);
|
||
TriangleNet.Topology.Triangle trgl = (TriangleNet.Topology.Triangle)meshTree.Query(X, Y);
|
||
if (trgl == null)
|
||
{
|
||
Dictionary<Vertex, double> valuePairs = new Dictionary<Vertex, double>();
|
||
Line2d ln;
|
||
foreach (Vertex item in blackMesh.Vertices)
|
||
{
|
||
ln = new Line2d(new Point2d(X, Y), new Point2d(item.X, item.Y));
|
||
valuePairs.Add(item, ln.Length);
|
||
}
|
||
IOrderedEnumerable<KeyValuePair<Vertex, double>> selected = from v in valuePairs // определяем каждый объект как
|
||
orderby v.Value // упорядочиваем по возрастанию
|
||
select v; // выбираем объект
|
||
List<KeyValuePair<Vertex, double>> lst = selected.ToList();
|
||
foreach (TriangleNet.Topology.Triangle item in blackMesh.Triangles)
|
||
{
|
||
if (item.Contains(lst[0].Key) && item.Contains(lst[1].Key)) { trgl = item; break; }
|
||
}
|
||
}
|
||
vrtx = new Vertex(X, Y, Number, 2);
|
||
Interpolation.InterpolateAttributes(vrtx, trgl, 1);
|
||
NL = Math.Round(vrtx.Attributes[0], 3);
|
||
}
|
||
|
||
internal void DLtoD1(double nullLevel)
|
||
{
|
||
double dlt = nullLevel - DL;
|
||
D1 = Math.Round(-FL - dlt, 3);
|
||
}
|
||
|
||
internal void D1toDL(double nullLevel)
|
||
{
|
||
DL = Math.Round(nullLevel + FL + D1, 3);
|
||
}
|
||
|
||
internal void D1toFL(double nullLevel)
|
||
{
|
||
double dlt = nullLevel - DL;
|
||
FL = Math.Round(-dlt - D1, 3);
|
||
}
|
||
|
||
internal void FLtoD1(double nullLevel)
|
||
{
|
||
double dlt = nullLevel + FL;
|
||
D1 = Math.Round(DL - dlt, 3);
|
||
}
|
||
|
||
internal string PropsToString()
|
||
{
|
||
string s = ";";
|
||
return Number + s + Name + s + (int)Type + s + Basement + s + B + s + L + s + H + s + Db + s + D1 + s + Hs + s + Hcf + s + Ycf + s + X + s + Y + s + FL
|
||
+ s + DL + s + NL + s + AlfaDeg;
|
||
}
|
||
|
||
internal List<object> PropsToList()
|
||
{
|
||
return new List<object> { Number, Name, (int)Type, Basement, B, L, H, Db, D1, Hs, Hcf, Ycf, X, Y, FL, DL, NL, AlfaDeg };
|
||
}
|
||
|
||
internal void StringToProps(string line, char separator = ';')
|
||
{
|
||
string[] src = line.Split(separator);
|
||
try
|
||
{
|
||
Number = Int32.Parse(src[0]);
|
||
Name = src[1];
|
||
Type = (TypeFound)Int32.Parse(src[2]);
|
||
Basement = bool.Parse(src[3]);
|
||
B = double.Parse(src[4]);
|
||
L = double.Parse(src[5]);
|
||
H = double.Parse(src[6]);
|
||
Db = double.Parse(src[7]);
|
||
D1 = double.Parse(src[8]);
|
||
Hs = double.Parse(src[9]);
|
||
Hcf = double.Parse(src[10]);
|
||
Ycf = double.Parse(src[11]);
|
||
X = double.Parse(src[12]);
|
||
Y = double.Parse(src[13]);
|
||
FL = double.Parse(src[14]);
|
||
DL = double.Parse(src[15]);
|
||
NL = double.Parse(src[16]);
|
||
AlfaDeg = double.Parse(src[17]);
|
||
}
|
||
catch
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
internal void ListToProps(List<object> src)
|
||
{
|
||
try
|
||
{
|
||
Number = (int)(double)src[0];
|
||
Name = (string)src[1];
|
||
Type = (TypeFound)(int)(double)src[2];
|
||
Basement = (bool)src[3];
|
||
B = (double)src[4];
|
||
L = (double)src[5];
|
||
H = (double)src[6];
|
||
Db = (double)src[7];
|
||
D1 = (double)src[8];
|
||
Hs = (double)src[9];
|
||
Hcf = (double)src[10];
|
||
Ycf = (double)src[11];
|
||
X = (double)src[12];
|
||
Y = (double)src[13];
|
||
FL = (double)src[14];
|
||
DL = (double)src[15];
|
||
NL = (double)src[16];
|
||
AlfaDeg = (double)src[17];
|
||
}
|
||
catch
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
internal void CalcLevels(Mesh planningMesh, Mesh blackMesh)
|
||
{
|
||
CalcDL(planningMesh);
|
||
CalcNL(blackMesh);
|
||
}
|
||
|
||
public void CopyProps(IEnumerable<Foundation> founds)
|
||
{
|
||
foreach (Foundation item in founds)
|
||
{
|
||
if (this.Equals(item)) continue;
|
||
item.Name = Name;
|
||
item.B = B;
|
||
item.L = L;
|
||
item.H = H;
|
||
item.FL = FL;
|
||
item.DL = DL;
|
||
item.D1 = D1;
|
||
item.Loads = Loads;
|
||
}
|
||
}
|
||
|
||
internal void CalcContour()
|
||
{
|
||
if (Type == TypeFound.Круглый) return;
|
||
Point2d v1 = new Point2d(-0.5 * B, -0.5 * L);
|
||
Point2d v2 = new Point2d(-0.5 * B, 0.5 * L);
|
||
Point2d v3 = new Point2d(0.5 * B, 0.5 * L);
|
||
Point2d v4 = new Point2d(0.5 * B, -0.5 * L);
|
||
double alfa = DegToRad(AlfaDeg);
|
||
double x = v1.X; double y = v1.Y;
|
||
v1.X = x * Math.Cos(alfa) - y * Math.Sin(alfa) + X;
|
||
v1.Y = x * Math.Sin(alfa) + y * Math.Cos(alfa) + Y;
|
||
x = v2.X; y = v2.Y;
|
||
v2.X = x * Math.Cos(alfa) - y * Math.Sin(alfa) + X;
|
||
v2.Y = x * Math.Sin(alfa) + y * Math.Cos(alfa) + Y;
|
||
x = v3.X; y = v3.Y;
|
||
v3.X = x * Math.Cos(alfa) - y * Math.Sin(alfa) + X;
|
||
v3.Y = x * Math.Sin(alfa) + y * Math.Cos(alfa) + Y;
|
||
x = v4.X; y = v4.Y;
|
||
v4.X = x * Math.Cos(alfa) - y * Math.Sin(alfa) + X;
|
||
v4.Y = x * Math.Sin(alfa) + y * Math.Cos(alfa) + Y;
|
||
|
||
Contour = new Quadrangle(v1, v2, v3, v4);
|
||
}
|
||
|
||
private double RadToDeg(double radians)
|
||
{
|
||
return radians * 180 / Math.PI;
|
||
}
|
||
|
||
private double DegToRad(double degries)
|
||
{
|
||
return degries * Math.PI / 180;
|
||
}
|
||
}
|
||
}
|