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);
}
}
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);
}
public void AddBore(Bore bore)
{
if (Bores == null)
{
Bores = new ObservableCollection <Bore>();
}
Bores.Add(bore);
}
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> 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 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 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);
}
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 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);
}
