public void Calculate(BeamUnderLoad beam)
{
double L = beam.Beam.Dimensions.Length;
g = beam.CrossSectionCalculatedCharacteristics.Area * 0.0001 * beam.Beam.ConcreteParameters.RhoB;
switch (beam.Beam.Loads.StaticSystem)
{
case Loads.StaticSystemTypes.jednoprzeslowa:
momentDGK = (beam.Beam.Loads.DGLoad * Math.Pow(L, 2)) / 8;
momentGK = (g * Math.Pow(L, 2)) / 8;
momentQK = (beam.Beam.Loads.QLoad * Math.Pow(L, 2)) / 8;
momentPK = beam.Beam.Loads.SilaP * L / 4;
break;
//case Loads.StaticSystemTypes.przewieszenie:
// momentDGK = (beam.Beam.Loads.DGLoad * Math.Pow(L, 2)) / 8;
// momentGK = (g * Math.Pow(L, 2)) / 8;
// momentQK = (beam.Beam.Loads.QLoad * Math.Pow(L, 2)) / 8;
// momentPK = beam.Beam.Loads.SilaP * L / 4;
// break;
case Loads.StaticSystemTypes.jednoZamocowanie:
momentDGK = (beam.Beam.Loads.DGLoad * Math.Pow(L, 2)) * 0.0703;
momentGK = (g * Math.Pow(L, 2)) * 0.0703;
momentQK = (beam.Beam.Loads.QLoad * Math.Pow(L, 2)) * 0.0703;
momentPK = beam.Beam.Loads.SilaP * L * 0.156;
break;
case Loads.StaticSystemTypes.dwaZamocowania:
momentDGK = (beam.Beam.Loads.DGLoad * Math.Pow(L, 2)) * 0.0417;
momentGK = (g * Math.Pow(L, 2)) * 0.0417;
momentQK = (beam.Beam.Loads.QLoad * Math.Pow(L, 2)) * 0.0417;
momentPK = beam.Beam.Loads.SilaP * L * 0.125;
break;
default:
break;
}
momentDG = 1.35 * momentDGK;
momentG = 1.35 * momentGK;
momentP = 1.35 * momentPK;
momentQ = 1.5 * MomentQK;
force = (beam.Beam.Loads.QLoad * beam.Beam.Dimensions.Length * beam.Beam.Dimensions.Length) / 8;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("MomentGK"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("MomentG"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("MomentDGK"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("MomentDG"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("MomentQK"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("MomentQ"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("MomentPK"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("MomentP"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("G"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Force"));
}
public void Calculate(BeamUnderLoad beam)
{
PrestressingSteelParameters p = beam.Beam.PrestressingSteelParameters;
CrossSectionCalculatedCharacteristics ch = beam.CrossSectionCalculatedCharacteristics;
p0Max = Math.Min(0.8 * p.Fpk * ch.AreaAp, 0.9 * p.Fp01k * ch.AreaAp) / 10;
pM0Max = Math.Min(0.75 * p.Fpk * ch.AreaAp, 0.85 * p.Fp01k * ch.AreaAp) / 10;
pMtMax = 0.65 * p.Fpk * ch.AreaAp / 10;
}
public void Calculate(BeamUnderLoad beam)
{
lToru = 3 * beam.Beam.Dimensions.Length + 4 * 0.2;
deltaPs1 = (beam.Beam.DifferentData.As1 / lToru) * beam.Beam.PrestressingSteelParameters.EP * beam.CrossSectionCalculatedCharacteristics.AreaAp * 0.1;
p0s1 = beam.MaxForcesInActiveSteel.P0Max - deltaPs1;
technologicalLosse = deltaPs1 / beam.MaxForcesInActiveSteel.P0Max * 100;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("LToru"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("DeltaPs1"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("P0s1"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("TechnologicalLosse"));
}
public void Calculate(BeamUnderLoad beam)
{
hz = beam.CrossSectionCalculatedCharacteristics.Hz;
// Moment in [kNcm]
Double M = (beam.Forces.MomentQ + beam.Forces.MomentDG + beam.Forces.MomentG + beam.Forces.MomentP) * 100;
x = hz - Math.Sqrt(Math.Pow(hz, 2) - 2 * M / ((beam.Beam.ConcreteParameters.Fcd / 10) * beam.CrossSectionCalculatedCharacteristics.BNmin));
aAp1 = beam.Beam.ConcreteParameters.Fcd / beam.Beam.PrestressingSteelParameters.Fpd * beam.CrossSectionCalculatedCharacteristics.BNmin * x;
nMin = aAp1 / (beam.Beam.PrestressingSteelParameters.Ap / 100);
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("NMin"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Hz"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("X"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Ap1"));
}
public void Calculate(BeamUnderLoad beam)
{
aw = (beam.Shear.VEd - beam.Shear.VRdC) * 100 / beam.Shear.Q;
asw = beam.Beam.DifferentData.M * Math.Pow(beam.Beam.SteelParameters.FiS / 10, 2) * Math.PI / 4.0;
swMax = (asw / beam.Shear.VEdd) * beam.Shear.Z * beam.Beam.SteelParameters.Fyd / 10;
vRds = (asw / beam.Beam.DifferentData.Swa) * beam.Shear.Z * beam.Beam.SteelParameters.Fyd / 10;
slMax = 0.75 * (beam.Beam.Dimensions.DimH - beam.Beam.Dimensions.E1);
roWmin = 0.08 * (Math.Sqrt(beam.Beam.ConcreteParameters.Fck) / beam.Beam.SteelParameters.Fyk) * 100;
slMax2 = asw * 100 / (roWmin * beam.Beam.Dimensions.DimB);
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Aw"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Asw"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SwMax"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("VRds"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SlMax"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("RoWmin"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SlMax2"));
}
public void Calculate(BeamUnderLoad beam)
{
q = beam.Beam.Loads.DGLoad + beam.Beam.Loads.QLoad + beam.Forces.G;
eCeff = beam.Beam.ConcreteParameters.ECm * 1000 / (1 + beam.DelayedLosses.Fi8T0);
//u = (5 * (q/100) * Math.Pow(beam.Beam.Dimensions.Length * 100, 4)) / (384 * (eCeff/10) * beam.CrossSectionCalculatedCharacteristics.IXCS);
double l3EI = Math.Pow(beam.Beam.Dimensions.Length * 100, 3) / ((eCeff / 10) * beam.CrossSectionCalculatedCharacteristics.IXCS);
switch (beam.Beam.Loads.StaticSystem)
{
case Loads.StaticSystemTypes.jednoprzeslowa:
u = (5.0 / 384.0) * (q / 100) * beam.Beam.Dimensions.Length * 100 * l3EI + (1 / 48.0) * beam.Beam.Loads.SilaP * l3EI;
break;
//case Loads.StaticSystemTypes.przewieszenie:
// u = 0.0;
// break;
case Loads.StaticSystemTypes.jednoZamocowanie:
u = 0.00541 * (q / 100) * beam.Beam.Dimensions.Length * 100 * l3EI + 0.00933 * beam.Beam.Loads.SilaP * l3EI;
break;
case Loads.StaticSystemTypes.dwaZamocowania:
u = 0.0026 * (q / 100) * beam.Beam.Dimensions.Length * 100 * l3EI + 0.00521 * beam.Beam.Loads.SilaP * l3EI;
break;
default:
break;
}
s = (-1.0 / 8.0) * (beam.DelayedLosses.Pmt * beam.AdHocLosses.Zcp * Math.Pow(beam.Beam.Dimensions.Length * 100, 2) / ((eCeff / 10) * beam.CrossSectionCalculatedCharacteristics.IXCS));
uU = u + s;
condition = beam.Beam.Dimensions.Length * 100 / 250;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("ECeff"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("S"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("U"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("UU"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Condition"));
}
public void Calculate(BeamUnderLoad beam)
{
betaCC = Math.Pow(Math.E, 0.2 * (1 - Math.Sqrt(28 / beam.Beam.DifferentData.TSGN)));
fCmT = betaCC * beam.Beam.ConcreteParameters.Fcm;
fCkT = fCmT - 8;
fCtmT = betaCC * beam.Beam.ConcreteParameters.Fctm;
pKSup = 1.05 * beam.AdHocLosses.PMo;
sig2F0 = ((pKSup / beam.CrossSectionCalculatedCharacteristics.AreaAcs) - ((pKSup * beam.AdHocLosses.Zcp) / beam.CrossSectionCalculatedCharacteristics.WCSg) + (beam.Forces.MomentGK * 100 / beam.CrossSectionCalculatedCharacteristics.WCSg)) * 10;
sig1F0 = ((pKSup / beam.CrossSectionCalculatedCharacteristics.AreaAcs) + ((pKSup * beam.AdHocLosses.Zcp) / beam.CrossSectionCalculatedCharacteristics.WCSd) - (beam.Forces.MomentGK * 100 / beam.CrossSectionCalculatedCharacteristics.WCSd)) * 10;
pD1 = 1.2 * beam.AdHocLosses.PMo;
sig2F1 = ((pD1 / beam.CrossSectionCalculatedCharacteristics.AreaAcs) - ((pD1 * beam.AdHocLosses.Zcp) / beam.CrossSectionCalculatedCharacteristics.WCSg) + (beam.Forces.MomentG * 100 / beam.CrossSectionCalculatedCharacteristics.WCSg)) * 10;
sig1F1 = ((pD1 / beam.CrossSectionCalculatedCharacteristics.AreaAcs) + ((pD1 * beam.AdHocLosses.Zcp) / beam.CrossSectionCalculatedCharacteristics.WCSd) - (beam.Forces.MomentG * 100 / beam.CrossSectionCalculatedCharacteristics.WCSd)) * 10;
pD2 = 1.0 * beam.AdHocLosses.PMo;
Double moment = beam.Forces.MomentG + beam.Forces.MomentDG + beam.Forces.MomentQ + beam.Forces.MomentP;
sig2F2 = ((pD2 / beam.CrossSectionCalculatedCharacteristics.AreaAcs) - ((pD2 * beam.AdHocLosses.Zcp) / beam.CrossSectionCalculatedCharacteristics.WCSg) + (moment * 100 / beam.CrossSectionCalculatedCharacteristics.WCSg)) * 10;
sig1F2 = ((pD2 / beam.CrossSectionCalculatedCharacteristics.AreaAcs) + ((pD2 * beam.AdHocLosses.Zcp) / beam.CrossSectionCalculatedCharacteristics.WCSd) - (moment * 100 / beam.CrossSectionCalculatedCharacteristics.WCSd)) * 10;
fck06 = beam.Beam.ConcreteParameters.Fck * 0.6;
allLossValue = (beam.TechnologicalLosses.DeltaPs1 + beam.AdHocLosses.DeltaPr + beam.AdHocLosses.DeltaPel + beam.DelayedLosses.DeltaPt) * 100 / beam.MaxForcesInActiveSteel.P0Max;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BetaCC"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("FCmT"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("FCkT"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("FCtmT"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("PKSup"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Sig2F0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Sig1F0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("PD1"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Sig2F1"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Sig1F1"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("PD2"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Sig2F2"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Sig1F2"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Fck06"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Fckt06"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("AllLossValue"));
}
public void Calculate(BeamUnderLoad beam)
{
q = ((beam.Beam.Loads.DGLoad + beam.Forces.G) * 1.35 + beam.Beam.Loads.QLoad * 1.5);
vEd = q * beam.Beam.Dimensions.Length * 0.5 + beam.Beam.Loads.SilaP * 0.5;
vEdd = vEd - q * beam.Beam.DifferentData.D / 100;
sXCS = beam.CrossSectionCalculatedCharacteristics.SxCS2;
sigmaCp = (beam.DelayedLosses.Pmt / beam.CrossSectionCalculatedCharacteristics.AreaAcs) * 10;
vRdC = (beam.CrossSectionCalculatedCharacteristics.IXCS * beam.CrossSectionCalculatedCharacteristics.BShear / sXCS) * Math.Sqrt(Math.Pow(beam.Beam.ConcreteParameters.Fctd, 2) + (1 * sigmaCp * beam.Beam.ConcreteParameters.Fctd)) / 10;
sigmaCp2 = Math.Min(10 * beam.DelayedLosses.Pmt / beam.CrossSectionCalculatedCharacteristics.Area, 0.2 * beam.Beam.ConcreteParameters.Fcd);
alfaC = 0.0;
if (sigmaCp2 < 0.25 * beam.Beam.ConcreteParameters.Fcd)
{
alfaC = 1 + sigmaCp2 / beam.Beam.ConcreteParameters.Fcd;
}
z = 0.9 * beam.CrossSectionCalculatedCharacteristics.Hz;
double v1 = 0.6 * (1.0 - beam.Beam.ConcreteParameters.Fck / 250.0);
int m = 1;
while (m < 20)
{
m = m + 1;
}
vRdMax = (alfaC * beam.CrossSectionCalculatedCharacteristics.BShear * z * v1 * beam.Beam.ConcreteParameters.Fcd) / 20;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("VEd"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("VEdd"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SXCS"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SigmaCp"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("VRdC"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SigmaCp2"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("AlfaC"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("VRdMax"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Q"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Z"));
}
public void Calculate(BeamUnderLoad beam)
{
Dimensions d = beam.Beam.Dimensions;
switch (d.BeamType)
{
case Dimensions.BeamTypes.prostokatny:
area = d.PrH * d.PrB;
sC = 0.5 * d.PrB * Math.Pow(d.PrH, 2);
yC = sC / area;
iXC = d.PrB * Math.Pow(d.PrH, 3) / 12;
break;
case Dimensions.BeamTypes.dwuteowy:
area = d.DimB * (d.DimH - d.DimD1 - d.DimD2)
+ d.DimD1 * d.DimBD1 + d.DimD2 * d.DimBD2;
sC = (d.DimBD1 * d.DimD1 * d.DimD1) / 2
+ d.DimB * (d.DimH - d.DimD1 - d.DimD2)
* ((d.DimH - d.DimD1 - d.DimD2) / 2 + d.DimD1)
+ d.DimBD2 * d.DimD2 * (d.DimH - d.DimD2 / 2);
yC = sC / area;
iXC = d.DimB * Math.Pow((d.DimH - d.DimD1 - d.DimD2), 3) / 12
+ d.DimB * (d.DimH - d.DimD1 - d.DimD2) * Math.Pow((yC - (d.DimH + d.DimD1 - d.DimD2) / 2), 2)
+ d.DimBD2 * Math.Pow(d.DimD2, 3) / 12
+ d.DimBD2 * d.DimD2 * Math.Pow((yC - d.DimH + d.DimD2 / 2), 2)
+ d.DimBD1 * Math.Pow(d.DimD1, 3) / 12 + d.DimBD1 * d.DimD1 * Math.Pow((yC - d.DimD1 / 2), 2);
break;
case Dimensions.BeamTypes.skrzynkowy:
area = d.SB1 * d.SH1 + d.SB2 * d.SH2 + 2 * d.SB3 * (d.SH - d.SH1 - d.SH2);
sC = d.SB1 * d.SH1 * (d.SH - 0.5 * d.SH1) + 0.5 * d.SB2 * Math.Pow(d.SH2, 2) + 2 * (d.SB3 * (d.SH - d.SH1 - d.SH2) * (d.SH2 + 0.5 * (d.SH - d.SH1 - d.SH2)));
yC = sC / area;
iXC = d.SB1 * Math.Pow(d.SH1, 3) / 12 + d.SB1 * d.SH1 * Math.Pow(d.SH - 0.5 * d.SH1 - yC, 2) + d.SB2 * Math.Pow(d.SH2, 3) / 12 + d.SB2 * d.SH2 * Math.Pow(yC - d.SH2, 2)
+ 2 * (d.SB3 * Math.Pow((d.SH - d.SH1 - d.SH2), 3) / 12 + d.SB3 * (d.SH - d.SH1 - d.SH2) * Math.Pow(yC + d.SH2 - 0.5 * (d.SH - d.SH1 - d.SH2), 2));
break;
case Dimensions.BeamTypes.belkatt:
area = d.TtHf * d.TtB + 2 * (d.TtH - d.TtHf) * d.TtB1;
sC = d.TtHf * d.TtB * (d.TtH - d.TtHf / 2) + d.TtB1 * Math.Pow(d.TtH - d.TtHf, 2);
yC = sC / area;
iXC = d.TtB * Math.Pow(d.TtHf, 3) / 12 + d.TtB * d.TtHf * Math.Pow(d.TtH - d.TtHf / 2 - yC, 2)
+ 2 * (d.TtB1 * Math.Pow(d.TtH - d.TtHf, 3) / 12 + d.TtB1 * (d.TtH - d.TtHf) * Math.Pow((d.TtH - d.TtHf) / 2 - yC, 2));
break;
default:
area = 1.1;
sC = 1.1;
yC = 1.1;
iXC = 1.1;
break;
}
alfaP = beam.Beam.PrestressingSteelParameters.EP / beam.Beam.ConcreteParameters.ECm;
areaAp = beam.Beam.PrestressingSteelParameters.N * beam.Beam.PrestressingSteelParameters.Ap / 100;
areaAcs = area + (alfaP - 1) * areaAp;
sCS = sC + (alfaP - 1) * areaAp * d.E1;
yCS = sCS / areaAcs;
iXCS = iXC + area * Math.Pow(yCS - yC, 2) + (alfaP - 1) * areaAp * Math.Pow(yCS - d.E1, 2);
wCSd = iXCS / yCS;
switch (d.BeamType)
{
case Dimensions.BeamTypes.prostokatny:
wCSg = iXCS / (d.PrH - yCS);
sxCS2 = 0.5 * d.PrB * Math.Pow(d.PrH - yCS, 2);
hz = d.PrH - d.E1;
bNmin = d.PrB;
bShear = d.PrB;
u = 2 * d.PrH + d.PrB;
break;
case Dimensions.BeamTypes.dwuteowy:
wCSg = iXCS / (d.DimH - yCS);
sxCS2 = d.DimBD2 * d.DimD2 * (d.DimH - yCS - 0.5 * d.DimD2) + 0.5 * d.DimB * Math.Pow(d.DimH - yCS - d.DimD2, 2);
hz = d.DimH - d.E1;
bNmin = d.DimBD2;
bShear = d.DimB;
u = 2 * d.DimH + d.DimBD1;
break;
case Dimensions.BeamTypes.skrzynkowy:
wCSg = iXCS / (d.SH - yCS);
sxCS2 = d.SB1 * d.SH1 * (d.SH - yCS - 0.5 * d.SH1) + d.SB3 * Math.Pow(d.SH - d.SH1 - yCS, 2);
hz = d.SH - d.E1;
bNmin = d.SB1;
bShear = d.SB3 * 2;
u = 4 * d.SH + d.SB2;
break;
case Dimensions.BeamTypes.belkatt:
wCSg = iXCS / (d.TtH - yCS);
sxCS2 = d.TtB * Math.Pow(d.TtHf, 3) / 12 + d.TtB * d.TtHf * Math.Pow(d.TtH - d.TtHf / 2 - yCS, 2) + 2 * (d.TtB1 * Math.Pow(d.TtH - d.TtHf - yCS, 3) / 12 + 0.5 * d.TtB1 * Math.Pow(d.TtH - d.TtHf - yCS, 2));
hz = d.TtH - d.E1;
bNmin = d.TtB;
bShear = 2 * d.TtB1;
u = 4 * d.TtH + 2 * d.TtB1;
break;
default:
wCSg = 1.1;
sxCS2 = 1.1;
hz = 1.1;
break;
}
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Area"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SC"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IXC"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SCS"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IXCS"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("WCSd"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("WCSg"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("AlfaP"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("AreaAcs"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("AreaAp"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SxCS2"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Hz"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BNmin"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BShear"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("U"));
}
public CrossSectionCalculatedCharacteristics(BeamUnderLoad beam)
{
Calculate(beam);
}
public Ranges(BeamUnderLoad beam)
{
Calculate(beam);
}
public Conditions(BeamUnderLoad beam)
{
Calculate(beam);
}
public Stirrups(BeamUnderLoad beam)
{
Calculate(beam);
}
public void Calculate(BeamUnderLoad beam)
{
if (beam.MaxForcesInActiveSteel.PMtMax > beam.DelayedLosses.Pmt)
{
pmtPmtmax = true;
}
else
{
pmtPmtmax = false;
}
if (beam.SGN.Sig2F0 > -beam.SGN.FCtmT)
{
ns2f0 = true;
}
else
{
ns2f0 = false;
}
if (beam.SGN.Sig1F0 <= beam.SGN.Fckt06)
{
ns1f0 = true;
}
else
{
ns1f0 = false;
}
if (beam.SGN.Sig2F1 > -beam.SGN.FCtmT)
{
ns2f1 = true;
}
else
{
ns2f1 = false;
}
if (beam.SGN.Sig1F1 <= beam.SGN.Fckt06)
{
ns1f1 = true;
}
else
{
ns1f1 = false;
}
if (beam.SGN.Sig2F2 <= 0.6 * beam.Beam.ConcreteParameters.Fck)
{
ns2f2 = true;
}
else
{
ns2f2 = false;
}
if (beam.SGN.Sig1F2 > -beam.Beam.ConcreteParameters.Fctm)
{
ns1f2 = true;
}
else
{
ns1f2 = false;
}
if (beam.Shear.VRdC > beam.Shear.VEdd)
{
vrdcVedd = true;
}
else
{
vrdcVedd = false;
}
if (beam.Shear.VRdMax > beam.Shear.VEdd)
{
vrdmaxVedd = true;
}
else
{
vrdmaxVedd = false;
}
if (beam.Stirrups.VRds > beam.Shear.VEdd)
{
vrdsVedd = true;
}
else
{
vrdsVedd = false;
}
if (beam.SGU.UU < beam.SGU.Condition)
{
uLeff = true;
}
else
{
uLeff = false;
}
if (beam.Beam.Dimensions.BeamType == Dimensions.BeamTypes.prostokatny)
{
isProstokat = true;
}
else
{
isProstokat = false;
}
if (beam.Beam.Dimensions.BeamType == Dimensions.BeamTypes.skrzynkowy)
{
isSkrzynkowy = true;
}
else
{
isSkrzynkowy = false;
}
if (beam.Beam.Dimensions.BeamType == Dimensions.BeamTypes.dwuteowy)
{
isTeowy = true;
}
else
{
isTeowy = false;
}
if (beam.Beam.Dimensions.BeamType == Dimensions.BeamTypes.belkatt)
{
isTT = true;
}
else
{
isTT = false;
}
if (beam.Beam.Loads.StaticSystem == Loads.StaticSystemTypes.jednoprzeslowa)
{
isZwykla = true;
}
else
{
isZwykla = false;
}
//if (beam.Beam.Loads.StaticSystem == Loads.StaticSystemTypes.przewieszenie)
//{
// isPrzewieszona = true;
//}
//else
//{
// isPrzewieszona = false;
//}
if (beam.Beam.Loads.StaticSystem == Loads.StaticSystemTypes.jednoZamocowanie)
{
is1Utwierdzenie = true;
}
else
{
is1Utwierdzenie = false;
}
if (beam.Beam.Loads.StaticSystem == Loads.StaticSystemTypes.dwaZamocowania)
{
is2Utwierdzenia = true;
}
else
{
is2Utwierdzenia = false;
}
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("TestP"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("TestF"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("PmtPmtmax"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Ns2f0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Ns1f0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Ns2f1"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Ns1f1"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Ns2f2"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Ns1f2"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("VrdcVedd"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("VrdmaxVedd"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("VrdsVedd"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("ULeff"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IsProstokat"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IsTeowy"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IsSkrzynkowy"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IsTT"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IsZwykla"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IsPrzewieszona"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Is1Utwierdzenie"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Is2Utwierdzenia"));
}
public MaxForcesInActiveSteel(BeamUnderLoad beam)
{
Calculate(beam);
}
public DelayedLosses(BeamUnderLoad beam)
{
Calculate(beam);
}
public SGN(BeamUnderLoad beam)
{
Calculate(beam);
}
public Forces(BeamUnderLoad beam)
{
Calculate(beam);
}
public void Calculate(BeamUnderLoad beam)
{
sigmaCg = -1000 * (beam.Forces.MomentGK + beam.Forces.MomentDGK + beam.Forces.MomentPK) * beam.AdHocLosses.Zcp / beam.CrossSectionCalculatedCharacteristics.IXCS;
sigmaCp0 = ((beam.AdHocLosses.PMo / beam.CrossSectionCalculatedCharacteristics.AreaAcs) + ((beam.AdHocLosses.PMo * Math.Pow(beam.AdHocLosses.Zcp, 2)) / beam.CrossSectionCalculatedCharacteristics.IXCS)) * 10;
sigmaPi = ((beam.AdHocLosses.PMo / beam.CrossSectionCalculatedCharacteristics.AreaAp) + (((beam.Forces.MomentGK + beam.Forces.MomentDGK + beam.Forces.MomentPK) * 100 * beam.AdHocLosses.Zcp) / beam.CrossSectionCalculatedCharacteristics.IXCS)
* beam.CrossSectionCalculatedCharacteristics.AlfaP) * 10;
mi = sigmaPi / beam.Beam.PrestressingSteelParameters.Fpk;
deltaSigmaPr = 0.66 * sigmaPi * 2.5 * Math.Pow(Math.E, 9.1 * mi) * Math.Pow(500, 0.75 * (1 - mi)) * Math.Pow(10, -5);
betaAsT = 1 - Math.Pow(Math.E, -0.2 * Math.Sqrt(beam.Beam.DifferentData.TOpoznione * 365));
epsilonCa8 = 2.5 * (beam.Beam.ConcreteParameters.Fck - 10) * Math.Pow(10, -6);
epsilonCaT = betaAsT * epsilonCa8;
u = beam.CrossSectionCalculatedCharacteristics.U;
h0 = (2 * beam.CrossSectionCalculatedCharacteristics.Area) / u;
kh = 0.7 + Math.Pow(Math.E, -(h0 / 100));
deltaT = beam.Beam.DifferentData.TOpoznione * 365 - beam.Beam.DifferentData.TsOpoznione;
betaDsTTs = deltaT / (deltaT + 0.4 * Math.Sqrt(Math.Pow(h0, 2)));
setAlfaFromKlasaCem(beam.Beam.DifferentData.KlasaCem);
epsilonCd0 = 1.318 * (220 + 110 * alfaDs1) * (1 - Math.Pow(0.01 * beam.Beam.DifferentData.RH, 3)) * Math.Pow(Math.E, -0.1 * alfaDs2 * beam.Beam.ConcreteParameters.Fcm) * Math.Pow(10, -6);
epsilonCdT = betaDsTTs * kh * epsilonCd0;
epsilonCs = epsilonCaT + epsilonCdT;
alfa1 = Math.Pow(35 / beam.Beam.ConcreteParameters.Fcm, 0.7);
alfa2 = Math.Pow(35 / beam.Beam.ConcreteParameters.Fcm, 0.2);
alfa3 = Math.Sqrt(35 / beam.Beam.ConcreteParameters.Fcm);
fiRH = alfa2 * (1 + alfa1 * (1 - 0.01 * beam.Beam.DifferentData.RH) / (0.1 * Math.Pow(h0, 0.333)));
t0 = beam.Beam.DifferentData.TsOpoznione * Math.Pow((9 / (2 + Math.Pow(beam.Beam.DifferentData.TsOpoznione, 1.2))) + 1, alfa);
betaT0 = 1 / (0.1 + Math.Pow(t0, 0.2));
fi0 = (16.8 / Math.Sqrt(beam.Beam.ConcreteParameters.Fcm)) * fiRH * betaT0;
betaH = 1.5 * (1 + Math.Pow(0.012 * beam.Beam.DifferentData.RH, 18)) * h0 + 250 * alfa3;
betaC8T0 = Math.Pow((beam.Beam.DifferentData.TOpoznione * 365 - beam.Beam.DifferentData.TsOpoznione) / (betaH + beam.Beam.DifferentData.TOpoznione * 365 - beam.Beam.DifferentData.TsOpoznione), 0.3);
fi8T0 = fi0 * betaC8T0;
deltaSigmaPCSR = (epsilonCs * beam.Beam.PrestressingSteelParameters.EP * 1000 + 0.8 * DeltaSigmaPr + beam.CrossSectionCalculatedCharacteristics.AlfaP * fi8T0 * (sigmaCg + sigmaCp0))
/ (1 + beam.CrossSectionCalculatedCharacteristics.AlfaP * (beam.CrossSectionCalculatedCharacteristics.AreaAp / beam.CrossSectionCalculatedCharacteristics.Area)
* (1 + (beam.CrossSectionCalculatedCharacteristics.AreaAcs / beam.CrossSectionCalculatedCharacteristics.IXCS) * Math.Pow(beam.AdHocLosses.Zcp, 2))
* (1 + 0.8 * fi8T0));
deltaPt = beam.CrossSectionCalculatedCharacteristics.AreaAp * deltaSigmaPCSR * 0.1;
pmt = beam.AdHocLosses.P0 - beam.AdHocLosses.DeltaPel - deltaPt;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SigmaCg"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SigmaCp0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("SigmaPi"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Mi"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("DeltaSigmaPr"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BetaAsT"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("EpsilonCa8"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("EpsilonCaT"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Kh"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BetaDsTTs"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("EpsilonCd0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("EpsilonCdT"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("EpsilonCs"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("FiRH"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("T0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BetaT0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Fi0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BetaH"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("BetaC8T0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Fi8T0"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("DeltaSigmaPCSR"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("DeltaPt"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Pmt"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Alfa"));
}
public Shear(BeamUnderLoad beam)
{
Calculate(beam);
}
public TechnologicalLosses(BeamUnderLoad beam)
{
Calculate(beam);
}