/// <summary>
/// Funkcja zwraca moment krytyczny w kNm dla zadanej siły podłużnej,
/// dla którego naprężenia w betonie osiągają dopuszczalny poziom
/// </summary>
/// <param name="NEd">siła osiowa w kN</param>
/// <param name="wspRedukcji">współczynnik określający dopuszczalny stopień naprężenia w betonie (wsp * fck)</param>
/// <returns>Zwraca moment krytyczny w kNm</returns>
public double SLS_MomentKrytycznyBeton(double NEd, double wspRedukcji)
{
double minMoment = SLS_MimosrodOsiowegoRozciagania(NEd) * NEd;
double maxMoment = minMoment + 100;
double momentKryt;
double eps = 0.001;
StressState naprezenia = SLS_GetStresses(NEd, maxMoment);
while (naprezenia.ConcreteTopStress < wspRedukcji * CurrentConcrete.fck)
{
maxMoment += 100;
naprezenia = SLS_GetStresses(NEd, maxMoment);
}
momentKryt = (maxMoment + minMoment) / 2;
while (Math.Abs(maxMoment - minMoment) > eps)
{
naprezenia = SLS_GetStresses(NEd, momentKryt);
if (naprezenia.ConcreteTopStress == wspRedukcji * CurrentConcrete.fck)
{
return(momentKryt);
}
else if (naprezenia.ConcreteTopStress > wspRedukcji * CurrentConcrete.fck)
{
maxMoment = momentKryt;
}
else
{
minMoment = momentKryt;
}
momentKryt = (maxMoment + minMoment) / 2;
}
return(momentKryt);
}
/// <summary>
/// Funkcja zwraca moment krytyczny w kNm dla zadanej siły podłużnej,
/// dla którego naprężenia w stali osiągają dopuszczalny poziom
/// </summary>
/// <param name="NEd">siła osiowa w kN</param>
/// <param name="wspRedukcji">współczynnik określający dopuszczalny stopień naprężenia w stali (wsp * fyk)</param>
/// <returns>Zwraca moment krytyczny w kNm</returns>
public double SLS_MomentKrytycznyStal(double NEd, double wspRedukcji)
{
double minMoment = SLS_MimosrodOsiowegoRozciagania(NEd) * NEd;
double maxMoment = minMoment + 100;
double momentKryt = (maxMoment + minMoment) / 2;
double eps = 0.0001;
StressState naprezenia = SLS_GetStresses(NEd, maxMoment);
while (Math.Abs(naprezenia.BottomSteelStress(this)) < CurrentSteel.fyk * wspRedukcji)
{
maxMoment += 100;
naprezenia = SLS_GetStresses(NEd, maxMoment);
}
momentKryt = (maxMoment + minMoment) / 2;
while (Math.Abs(maxMoment - minMoment) > eps)
{
naprezenia = SLS_GetStresses(NEd, momentKryt);
if (Math.Abs(naprezenia.BottomSteelStress(this)) == wspRedukcji * CurrentSteel.fyk)
{
return(momentKryt);
}
else if (Math.Abs(naprezenia.BottomSteelStress(this)) > wspRedukcji * CurrentSteel.fyk)
{
maxMoment = momentKryt;
}
else
{
minMoment = momentKryt;
}
momentKryt = (maxMoment + minMoment) / 2;
}
return(momentKryt);
}
/// <summary>
/// Funkcja zwraca szerokość rozwarcia rysy dla zadanej siły podłużnej oraz momentu zginającego
/// </summary>
/// <param name="section">klasa reprezentująca obliczany przekrój</param>
/// <param name="NEd">siła osiowa w kN</param>
/// <param name="MEd">moment zginający w kNm</param>
/// <param name="k1">współczynnik k1 zależny od przyczepności zbrojenia (0.8 lub 1.6 patrz EC / 0.8 dla prętów żebrowanych)</param>
/// <param name="kt">współczynnik kt zależny od czasu trwania obciążenia (0.6 obc. krótkotrwałe, 0.4 obc. długotrwałe)</param>
/// <returns>Zwraca szerokość rozwarcia rysy w mm</returns>
public double SLS_CrackWidth(double NEd, double MEd, double kt, double k1, bool lowerFace)
{
StressState naprezenia = SLS_GetStresses(NEd, MEd);
double alfaE = CurrentSteel.Es / CurrentConcrete.Ecm;
double As; //w milimetrach kwadratowych!!
double fi, c, spacing;
if (this is RectangleSection)
{
RectangleSection sec = this as RectangleSection;
if (lowerFace)
{
fi = sec.Fi1;
c = sec.C1;
spacing = sec.Spacing1;
As = Asi[1] * Dimfactor * Dimfactor;
}
else
{
fi = sec.Fi2;
c = sec.C2;
spacing = sec.Spacing2;
As = Asi[0] * Dimfactor * Dimfactor;
}
}
else if (this is CircleSection)
{
CircleSection sec = this as CircleSection;
fi = sec.FiB;
c = sec.C;
spacing = sec.Spacing;
As = ZbrRozcPole(naprezenia.WysokośćStrefySciskanej) * Dimfactor * Dimfactor;
}
else
{
fi = 0;
c = 0;
spacing = 0;
As = 0;
}
double roPeff, deltaEpsilon, AcEff, srMax;
double sigmaS;
if (lowerFace)
{
sigmaS = naprezenia.BottomSteelStress(this);
}
else
{
sigmaS = naprezenia.TopSteelStress(this);
}
double Es = this.CurrentSteel.Es;
double fctEff = this.CurrentConcrete.fctm;
double h = HTotal; //wysokosc w milimetrach!!
double x = naprezenia.WysokośćStrefySciskanej * Dimfactor; //w milimetrach!!
double k2;
double k3 = 3.4;
double k4 = 0.425;
//przypadek gdy nie dochodzi do zarysowania w ogóle
if (naprezenia.Faza == 1)
{
return(0);
}
if (As == 0)
{
As = 0.0000001;
}
if (sigmaS > 0)
{
return(0);
}
else
{
sigmaS = Math.Abs(sigmaS);
}
/*
* if (As == 0)
* {
* //return 100;
* As = 0.000001;
* }
*/
AcEff = Crack_AcEff(x); // w milimetrach kwadratowych!!
roPeff = As / AcEff;
double deltaEpsilon1 = (sigmaS - kt * fctEff / roPeff * (1 + alfaE * roPeff)) / Es;
double deltaEpsilon2 = 0.6 * sigmaS / Es;
deltaEpsilon = Math.Max(deltaEpsilon1, deltaEpsilon2);
//określenie współczynnika k2
double epsilon1, epsilon2;
if (naprezenia.BottomSteelStress(this) * naprezenia.TopSteelStress(this) < 0)
{
k2 = 0.5;
}/*
* else if (naprezenia.SteelAs1Stress < 0 && naprezenia.SteelAs1Stress < 0)
* {
* k2 = 1;
* }*/
else if (naprezenia.BottomSteelStress(this) > 0)
{
k2 = 0;
}
else
{
double epsilonAs1 = naprezenia.BottomSteelStress(this) / Es;
double epsilonAs2 = naprezenia.TopSteelStress(this) / Es;
double epsEdge1 = Math.Abs((epsilonAs1 - epsilonAs2) / (DiE.Max() - DiE.Min()) * DiE.Min() - epsilonAs1);
double epsEdge2 = Math.Abs((epsilonAs1 - epsilonAs2) / (DiE.Max() - DiE.Min()) * (HTotal / Dimfactor - DiE.Max()) + epsilonAs2);
epsilon1 = Math.Max(epsEdge1, epsEdge2);
epsilon2 = Math.Min(epsEdge1, epsEdge2);
k2 = (epsilon1 + epsilon2) / (2 * epsilon1);
}
double maxSpace = 5 * (c + 0.5 * fi);
//określenie maksymalnego rozstawu rys
if (As == 0 || spacing > maxSpace)
{ // jesli nie ma zbrojenia lub rozstaw jest zbyt duży
srMax = 1.3 * (h - x); // w milimetrach
}
else
{
srMax = k3 * c + k4 * (k1 * k2 * fi) / roPeff; // w milimetrach
}
double wk1 = srMax * deltaEpsilon;
return(wk1); //w milimetrach
}
/// <summary>Funkcja zwraca naprężenia w MPa</summary>
/// <param name="NEd">siła osiowa w kN </param>
/// <param name="MEd">moment zginający w kNm</param>
/// <returns>Zwraca obiekt typu StressState który zawiera informacje m.in. o naprężeniach w stali i betonie</returns>
public StressState SLS_GetStresses(double NEd, double MEd)
{
//rezultaty
double SigmaBetonTop;
double SigmaBetonBottom;
double[] SigmaStalAs = new double[NoB];
double x;
int faza;
double[] di = RzednePretowUpEdge();
double HTotal = this.HTotal / Dimfactor;
double A_I, A_II, xc, Iy, MEd_c;
//OBLICZENIE PRZEKROJU JAKO FAZA I:
// sprowadzone pole powierzchni przekroju w m2
A_I = SprowPolePrzekr(HTotal);
// wysokosc srodka ciezkosci przekroju od gornej krawedzi przekroju w m
xc = SrCiezkPrzekr(HTotal);
// sprowadzony moment bezwladnosci przekroju wzgledem srodka ciezkosci! w m4
Iy = MomBezwPrzekr(HTotal);
// moment zginajacy w srodku ciezkosci przekroju
MEd_c = MEd - NEd * (0.5 * HTotal - xc);
double zTop = xc; //odleglosc gornej krawedzi przekroju od srodka ciezkosci
double zBottom = xc - HTotal; //odleglosc dolnej krawedzi strefy ściskanej od srodka ciezkosci
// naprezenia w betonie
SigmaBetonTop = SLS_Naprezenie(NEd, MEd_c, zTop, Iy, A_I);
SigmaBetonBottom = SLS_Naprezenie(NEd, MEd_c, zBottom, Iy, A_I);
// naprezenia w stali
for (int i = 0; i < NoB; i++)
{
SigmaStalAs[i] = AlfaE * SLS_Naprezenie(NEd, MEd_c, xc - di[i], Iy, A_I);
}
//określenie wysokości strefy ściskanej
if (SigmaBetonBottom <= 0 && SigmaBetonTop <= 0)
{
x = 0;
}
else if (SigmaBetonBottom >= 0 && SigmaBetonTop >= 0)
{
x = HTotal;
}
else
{
if (SigmaBetonTop > 0)
{
x = (SigmaBetonTop / (SigmaBetonTop + Math.Abs(SigmaBetonBottom))) * HTotal;
}
else
{
x = (SigmaBetonBottom / (SigmaBetonBottom + Math.Abs(SigmaBetonTop))) * HTotal;
}
}
faza = 1;
if (SigmaBetonBottom >= -CurrentConcrete.fctm && SigmaBetonTop >= -CurrentConcrete.fctm)
{
return(new StressState(SigmaBetonTop, SigmaBetonBottom, SigmaStalAs, x, 0.5 * HTotal - xc, faza));
}
else
{
StressState naprezenia;
bool reversed = false;
StressState reversedStresses;
A_II = A_I;
double x1 = 0;
double x2 = HTotal;
do
{
x = (x1 + x2) / 2;
if (x < 0.00001 * HTotal)
{
x = 0;
}
// sprowadzone pole powierzchni przekroju w m2
A_II = SprowPolePrzekr(x);
// wysokosc srodka ciezkosci przekroju od gornej krawedzi przekroju w m
xc = SrCiezkPrzekr(x);
// sprowadzony moment bezwladnosci przekroju wzgledem srodka ciezkosci! w m4
Iy = MomBezwPrzekr(x);
// moment zginajacy w srodku ciezkosci przekroju
MEd_c = MEd - NEd * (0.5 * HTotal - xc);
zTop = xc; //odleglosc gornej krawedzi przekroju od srodka ciezkosci w mm
zBottom = xc - x; //odleglosc dolnej krawedzi strefy ściskanej od srodka ciezkosci w mm
// naprezenia w betonie
if (x < 0.00001 * HTotal)
{
SigmaBetonBottom = 0;
SigmaBetonTop = 0;
}
else
{
SigmaBetonTop = SLS_Naprezenie(NEd, MEd_c, zTop, Iy, A_II);
SigmaBetonBottom = SLS_Naprezenie(NEd, MEd_c, zBottom, Iy, A_II);
}
// naprezenia w stali
for (int i = 0; i < NoB; i++)
{
SigmaStalAs[i] = AlfaE * SLS_Naprezenie(NEd, MEd_c, xc - di[i], Iy, A_II);
}
if (SigmaBetonBottom < 0)
{
x2 = x;
}
else
{
x1 = x;
}
for (int i = 0; i < NoB; i++)
{
if (Asi[i] == 0.0)
{
SigmaStalAs[i] = 0;
}
}
faza = 2;
naprezenia = new StressState(SigmaBetonTop, SigmaBetonBottom, SigmaStalAs, x, 0.5 * HTotal - xc, faza);
}while (Math.Abs(x1 - x2) >= 0.000001 * HTotal && x != 0);
if (faza == 2 && Math.Abs(x1 - x2) < 0.0001 * HTotal && MEd - NEd * (0.5 * HTotal - xc) < 0 && naprezenia.BottomSteelStress(this) > 0)
{
reversed = !reversed;
reversedStresses = ReversedSection.SLS_GetStresses(NEd, -MEd);
SigmaStalAs = reversedStresses.SteelStress;
x = reversedStresses.WysokośćStrefySciskanej;
SigmaBetonTop = reversedStresses.ConcreteTopStress;
SigmaBetonBottom = reversedStresses.ConcreteBottomStress;
xc = reversedStresses.Mimosrod;
}
if (x == 0)
{
if (!reversed)
{
return(new StressState(0, 0, SigmaStalAs, x, 0.5 * HTotal - xc, faza));
}
else
{
double[] SigmaStalAsRev = new double[NoB];
for (int i = 0; i < NoB; i++)
{
SigmaStalAsRev[i] = SigmaStalAs[NoB - i - 1];
}
return(new StressState(0, 0, SigmaStalAsRev, x, -(0.5 * HTotal - xc), faza));
}
}
else
{
if (!reversed)
{
return(new StressState(SigmaBetonTop, SigmaBetonBottom, SigmaStalAs, x, 0.5 * HTotal - xc, faza));
}
else
{
double[] SigmaStalAsRev = new double[NoB];
for (int i = 0; i < NoB; i++)
{
SigmaStalAsRev[i] = SigmaStalAs[NoB - i - 1];
}
return(new StressState(SigmaBetonBottom, SigmaBetonTop, SigmaStalAsRev, x, -(0.5 * HTotal - xc), faza));
}
}
}
}