/// <summary>
/// Initializes a new instance of the <see cref="SnowLoad"/> class.
/// </summary>
/// <param name="buildingSite">Set instance of a class implementing <see cref="IBuildingSite"/> for <see cref="BuildingSite"/>.</param>
/// <param name="snowDensity">Set <see cref="SnowDensity"/> in kN/m3.</param>
/// <param name="returnPeriod">Set <see cref="ReturnPeriod"/> in years</param>
/// <param name="currentDesignSituation">Set <see cref="CurrentDesignSituation"/>.</param>
/// <param name="excepctionalSituation">Set <see cref="ExcepctionalSituation"/>.</param>
public SnowLoad(IBuildingSite buildingSite, double snowDensity, int returnPeriod,
DesignSituation currentDesignSituation = DesignSituation.A,
bool excepctionalSituation = false) : this(buildingSite, currentDesignSituation, excepctionalSituation)
{
SnowDensity = snowDensity;
ReturnPeriod = returnPeriod;
}
/// <summary>
/// Checks the conditions for current design situation.
/// </summary>
/// <param name="exceptionalSituation"><c>true</c> if situation is exceptional.</param>
/// <param name="designSituation">Design situation to be checked.</param>
/// <param name="annexB">If annex B is used.</param>
/// <returns><c>true</c> if current design situation can be used in calculations.</returns>
/// <remarks>[PN-EN 1991-1-3 Table A.1]</remarks>
/// <example>
/// <code>
/// bool canBeUsedInCalculations = ConditionChecker.ForDesignSituation(true, DesignSituation.A, false);
/// </code>
/// </example>
public static bool ForDesignSituation(bool exceptionalSituation, DesignSituation designSituation, bool annexB)
{
if (exceptionalSituation)
{
switch (designSituation)
{
case DesignSituation.A:
return(false);
case DesignSituation.B1:
return(!annexB);
case DesignSituation.B2:
return(annexB);
case DesignSituation.B3:
return(true);
default:
return(false);
}
}
if (!annexB)
{
return(true);
}
return(false);
}
/// <summary>
/// Funkcja zwraca wartość krytycznej osiowej siły ściskającej dla przekroju
/// </summary>
/// <param name="situation">Określa sytuację obliczeniową dla której przeprowadzone zostaną obliczenia</param>
/// <returns>Wartość krytycznej osiowej siły ściskającej dla przekroju w kN</returns>
public double ULS_SilaKrytycznaSciskajaca(DesignSituation situation)
{
double gammaC, gammaS;
if (situation == DesignSituation.Accidental)
{
gammaC = 1.2;
gammaS = 1.0;
}
else
{
gammaC = 1.5;
gammaS = 1.15;
}
double alfaCC = 0.85;
double lambda, eta;
double fck = CurrentConcrete.fck;
double epsilon = CurrentConcrete.epsilon_cu2;
double Es = CurrentSteel.Es;
double fyd = CurrentSteel.fyk / gammaS;
if (fck <= 50)
{
eta = 1;
lambda = 0.8;
}
else
{
eta = 1.0 - ((fck - 50) / 200);
lambda = 0.8 - ((fck - 50) / 400);
}
return(((AcTotal * CurrentConcrete.fck / gammaC * alfaCC) / Forcefactor) + (AsTotal * CurrentSteel.SigmaS(epsilon, fyd)) / Forcefactor);
}
//public int NewNo { get; set; }
// Display Info of the RFEM Objects on Panels
// Parameters are separated by ";". The component split text can be used to break the string down into a list.
public override string ToString()
{
return(string.Format($"RFEM-LoadCombination;No:{No};" +
$"Definition:{Definition};DesignSituation:{DesignSituation.ToString()};" +
$"Description:{((Description == "") ? "-" : Description)};ToSolve:{ToSolve.ToString()};" +
$"IsValid:{IsValid};ID:{((ID == "") ? "-" : ID)};Tag:{((Tag == "") ? "-" : Tag)};" +
$"ToModify:{ToModify};ToDelete:{ToDelete};Comment:{((Comment == "") ? "-" : Comment)};"));
}
/// <summary>
/// Initializes a new instance of the <see cref="SnowLoad"/> class.
/// </summary>
/// <param name="buildingSite">Set instance of a class implementing <see cref="IBuildingSite"/> for <see cref="BuildingSite"/>.</param>
/// <param name="currentDesignSituation">Set <see cref="CurrentDesignSituation"/>.</param>
/// <param name="excepctionalSituation">Set <see cref="ExcepctionalSituation"/>.</param>
public SnowLoad(IBuildingSite buildingSite,
DesignSituation currentDesignSituation = DesignSituation.A,
bool excepctionalSituation = false)
{
BuildingSite = buildingSite;
CurrentDesignSituation = currentDesignSituation;
ExcepctionalSituation = excepctionalSituation;
}
private BuildingData CreateBuildingData(
DesignSituation designSituation = DesignSituation.A, bool exceptional = false)
{
var buildingSite = new BuildingSite(ZoneEnum.FirstZone, TopographyEnum.Sheltered, 250);
var snowLoad = new SnowLoad(buildingSite, designSituation, exceptional);
var building = new Building(snowLoad);
return(new BuildingData()
{
BuildingSite = buildingSite,
SnowLoad = snowLoad,
Building = building
});
}
/// <summary>
/// Funkcja zwraca wartość krytycznej osiowej siły rozciągającej dla przekroju
/// </summary>
/// <param name="situation">Określa sytuację obliczeniową dla której przeprowadzone zostaną obliczenia</param>
/// <returns>Wartość krytycznej osiowej siły rozciągającej dla przekroju w kN</returns>
public double ULS_SilaKrytycznaRozciagajaca(DesignSituation situation)
{
double gammaS;
if (situation == DesignSituation.Accidental)
{
gammaS = 1.0;
}
else
{
gammaS = 1.15;
}
return(-((AsTotal) * (CurrentSteel.fyk / gammaS) / Forcefactor));
}
public override double ULS_ScinanieBeton(double NEd, DesignSituation situation)
{
double gammaC;
if (situation == DesignSituation.Accidental)
{
gammaC = 1.2;
}
else
{
gammaC = 1.5;
}
double alfaCC = 0.85;
double k1 = 0.15;
double b = this.B / 1000; // szerokość przekroju w metrach
double bw = b;
double h = this.H / 1000; // wysokość przekroju w metrach
double d = h - (this.A1 / 1000); // wysokosc uzyteczna przekroju w metrach
double fck = this.CurrentConcrete.fck;
double fcd = fck / gammaC * alfaCC; //obliczeniowa nośność betonu na ściskanie
double sigmaCP1 = NEd / (b * h) / 1000;
double sigmaCP2 = 0.2 * fcd;
double sigmaCP = Math.Max(sigmaCP1, sigmaCP2);
double k = 1 + Math.Sqrt(200 / (d * 1000));
double Asl = Math.Min(this.As1, this.As2) / 1000 / 1000; // to trzeba jeszcze dobrze przeanalizowac jak dobierac to zbrojenie
double rol = Math.Min(Asl / (bw * d), 0.02);
double VRdc = (0.18 / gammaC * k * Math.Pow(100 * rol * fck, 1 / 3) + k1 * sigmaCP) * bw * d;
double vmin = 0.035 * Math.Pow(k, 3 / 2) * Math.Pow(fck, 0.5);
double VRdcMin = (vmin + k1 * sigmaCP) * bw * d;
VRdc = Math.Max(VRdcMin, VRdc);
//korekta ze wzgledu na punkt 6.2 EN
double ni = 0.6 * (1 - fck / 250);
double VEdmax = 0.5 * bw * d * ni * fcd;
VRdc = Math.Min(VRdc, VEdmax);
return(VRdc * 1000);
}
/// <summary>
/// Funkcja zwraca wskaźnik macierzy złożonej z punktów tworzących krzywą interkacji VRd / NEd
/// </summary>
/// <param name="situation">Określa sytuację obliczeniową dla której przeprowadzone zostaną obliczenia</param>
/// <param name="NoOfPoints">Liczba punktów towrzących krzywą</param>
/// <returns></returns>
public double[][] ULS_VRdN_Curve(DesignSituation situation, int NoOfPoints)
{
double max = ULS_SilaKrytycznaSciskajaca(situation);
double min = ULS_SilaKrytycznaRozciagajaca(situation);
double[][] results = new double[2 * NoOfPoints][];
for (int i = 0; i < NoOfPoints; i++)
{
double Ned = max - (max - min) / NoOfPoints * i;
results[i] = new double[2];
results[i][0] = Ned;
results[i][1] = ULS_ScinanieTotal(Ned, situation);
results[results.Length - i - 1] = new double[2];
results[results.Length - i - 1][0] = Ned;
results[results.Length - i - 1][1] = -ReversedSection.ULS_ScinanieTotal(Ned, situation);
}
return(results);
}
public override double ULS_ScinanieTotal(double NEd, DesignSituation situation)
{
return(0);
}
public override double ULS_MomentKrytyczny(double NEd, DesignSituation situation)
{
double gammaC, gammaS;
if (situation == DesignSituation.Accidental)
{
gammaC = 1.2;
gammaS = 1.0;
}
else
{
gammaC = 1.5;
gammaS = 1.15;
}
double alfaCC = 0.85;
double D = this.D / 1000; // w metrach
double a = A / 1000; // w metrach
double Ab = this.Ab / 1000000; // w metrach kwadratowych
double fiB = FiB / 1000;
int noB = NoB;
double fyk = CurrentSteel.fyk; // w MPa
double Es = CurrentSteel.Es; // w MPa
//double Ecm = currentConcrete.Ecm; // w MPa
double fck = CurrentConcrete.fck; // w MPa
double fcd = fck / gammaC * alfaCC; // w MPa
double fyd = fyk / gammaS;
double n = CurrentConcrete.n;
double eps = 0.00001;
double epsilonC2 = CurrentConcrete.epsilon_c2;
double epsilonCU2 = CurrentConcrete.epsilon_cu2;
double x1 = 0;
double x2 = 100000 * D;
double d; //wysokość użyteczna, zależna od wysokości strefy ściskanej x
double As; //pole zbrojenia rozciąganego, zależne od wysokości strefy ściskanej x
//obliczenia parametrów geometryczny dla przekroju okragłego
double R = D / 2; //promień przekroju
double rAs = R - a; //promień okręgu po którym rozmieszczone są pręty
double[] di; //tablica z odległościami prętów od górnej krawędzi przekroju (ściskanej)
bool[] ki; //tablica okreslajaca czy dany pret jest rozciagany (true), ściskany(false)
di = RzednePretowUpEdge();
double Pc = 0;
double PAs1 = 0;
double PAs2 = 0;
double x, range;
int k = 100;
double NRd = 0;
//d = di.Max();
NEd = NEd / 1000;
do
{
x = (x1 + x2) / 2;
Pc = 0;
//określenie wysokości użytecznej d która jest zależna od x
As = 0; // sumaryczne pole powierzchni zbrojenia rozciaganego
double Asd = 0; //moment statyczny zbrojenia rozciaganego wzgledem gornej krawedzi przekroju
ki = CzyPretRozciagany(x);
for (int i = 0; i < noB; i++)
{
Asd += Ab * Convert.ToUInt32(ki[i]) * di[i];
As += Ab * Convert.ToUInt32(ki[i]);
}
if (As == 0)
{
d = D;
}
else
{
d = Asd / As; //wysokość uzyteczna znana
}
range = Math.Min(x, D);
for (int i = 0; i < k; i++)
{
double ri = d - range / k * (i + 0.5);
double riT = d - range / k * (i);
double riB = d - range / k * (i + 1);
Pc += CurrentConcrete.SigmaC(fcd, EpsilonR(ri, x, d)) * (DlugoscOK(d - riT) + DlugoscOK(d - riB)) / 2 * range / k;
}
double[] PAsi = new double[noB];
PAs1 = 0;
PAs2 = 0;
for (int i = 0; i < noB; i++)
{
PAsi[i] = Ab * CurrentSteel.SigmaS(EpsilonR(d - di[i], x, d), fyd);
if (!ki[i])
{
PAs2 += PAsi[i];
}
else
{
PAs1 += Ab * CurrentSteel.SigmaS(EpsilonR(0, x, d), fyd);
}
}
NRd = Pc + PAs1 + PAs2;
if (NRd >= NEd)
{
x2 = x;
}
else
{
x1 = x;
}
} while (Math.Abs(x1 - x2) > eps);
double Pcz = 0;
for (int i = 0; i < k; i++)
{
double ri = d - range / k * (i + 0.5);
double sC = CurrentConcrete.SigmaC(fcd, EpsilonR(ri, x, d));
Pcz += sC * DlugoscOK(d - ri) * (range / k) * ri;
}
double[] MAs2i = new double[noB];
double MAs2 = 0;
for (int i = 0; i < noB; i++)
{
MAs2i[i] = Convert.ToUInt32(!ki[i]) * Ab * CurrentSteel.SigmaS(EpsilonR(d - di[i], x, d), fyd) * (d - di[i]);
MAs2 += MAs2i[i];
}
double Ms1 = Pcz + MAs2;
double MRd = Ms1 - NEd * (d - 0.5 * D);
return(MRd * 1000);
}
/// <summary> /// Funkcja oblicza nośność przekroju ze zbrojeniem na ścinanie przy podanej sile podłużnej /// </summary> /// <param name="NEd">Siła podłużna w przekroju w kN</param> /// <param name="situation">Określa sytuację obliczeniową dla której przeprowadzone zostaną obliczenia</param> /// <returns>Zwraca wartość nośności przekroju zbrojonego na ścinanie w kN</returns> public abstract double ULS_ScinanieTotal(double NEd, DesignSituation situation);
/// <summary> /// Funkcja oblicza nośność przekroju betonowego na ścinanie przy podanej sile podłużnej /// </summary> /// <param name="NEd">Siła podłużna w przekroju w kN</param> /// <param name="situation">Określa sytuację obliczeniową dla której przeprowadzone zostaną obliczenia</param> /// <returns>Zwraca wartość nośności betonu na ścinanie przekroju w kN</returns> public abstract double ULS_ScinanieBeton(double NEd, DesignSituation situation);
/// <summary>Funkcja zwraca wartość momentu krytycznego dla siły NEd</summary> /// <param name="NEd"> Siła podłużna w kN </param> /// <param name="situation">Określa sytuację obliczeniową dla której przeprowadzone zostaną obliczenia</param> /// <returns>Zwraca moment krytyczny w kNm</returns> public abstract double ULS_MomentKrytyczny(double NEd, DesignSituation situation);
public override double ULS_ScinanieTotal(double NEd, DesignSituation situation)
{
double gammaC, gammaS;
if (situation == DesignSituation.Accidental)
{
gammaC = 1.2;
gammaS = 1.0;
}
else
{
gammaC = 1.5;
gammaS = 1.15;
}
double alfaCC = 0.85;
double VRdc = ULS_ScinanieBeton(NEd, situation);
double d = (H - A1) / 1000; // wysokosc uzyteczna przekroju w metrach
double Asw = this.MyStirrups.Asw / 1000 / 1000;
double s = this.MyStirrups.Swd / 1000;
double z = 0.9 * d; // ramię sił wewnętrznych - trzeba sprawdzić jak to analizować, dla czystego zginania z=0.9d
double bw = B / 1000;
double fywd = 0.8 * CurrentSteel.fyk / gammaS;
double fcd = CurrentConcrete.fck / gammaC * alfaCC;
double cotQ;
if (NEd >= 0)
{
cotQ = 2.0;
}
else
{
cotQ = 1.25;
}
double VRds = Asw / s * z * fywd * cotQ; // w meganiotonach
double alfaCW = 1;
double alfa = this.MyStirrups.Alfa / (2 * Math.PI);
double ni1;
if (CurrentConcrete.fck <= 60)
{
ni1 = 0.54 * (1 - 0.5 * Math.Cos(alfa));
}
else
{
ni1 = Math.Max((0.84 - CurrentConcrete.fck / 200) * (1 - 0.5 * Math.Cos(alfa)), 0.5);
}
double VRdMax = alfaCW * bw * z * ni1 * fcd / (cotQ + 1 / cotQ); //w meganiotonach
if (this.MyStirrups.Alfa != 90.0)
{
VRds = Asw / s * z * fywd * (cotQ + (1 / Math.Tan(alfa))) * Math.Sin(alfa);
VRdMax = alfaCW * bw * z * ni1 * fcd * (cotQ + (1 / Math.Tan(alfa))) / (1 + Math.Pow(cotQ, 2.0));
}
double VRd = Math.Min(VRds, VRdMax);
return(VRd * 1000);
}
public override double ULS_MomentKrytyczny(double NEd, DesignSituation situation)
{
double gammaC, gammaS;
if (situation == DesignSituation.Accidental)
{
gammaC = 1.2;
gammaS = 1.0;
}
else
{
gammaC = 1.5;
gammaS = 1.15;
}
double alfaCC = 0.85;
double h = H / 1000; // w metrach
double b = B / 1000; // w metrach
double a1 = A1 / 1000; // w metrach
double a2 = A2 / 1000; // w metrach
double As1 = this.As1 / 1000000; // w metrach kwadratowych
double As2 = this.As2 / 1000000; // w metrach kwadratowych
double fyk = CurrentSteel.fyk; // w MPa
double Es = CurrentSteel.Es; // w MPa
//double Ecm = currentConcrete.Ecm; // w MPa
double fck = CurrentConcrete.fck; // w MPa
double fcd = fck / gammaC * alfaCC; // w MPa
double fyd = fyk / gammaS;
double n = CurrentConcrete.n;
double eps = 0.00001;
double d = h - a1;
double epsilonC2 = CurrentConcrete.epsilon_c2;
double epsilonCU2 = CurrentConcrete.epsilon_cu2;
double x1 = 0;
double x2 = 100000 * h;
double rAs2 = d - a2;
double Pc = 0;
double x, range;
int k = 100;
double NRd = 0;
NEd = NEd / 1000;
do
{
x = (x1 + x2) / 2;
Pc = 0;
range = Math.Min(x, h);
for (int i = 0; i < k; i++)
{
double ri = d - range / k * (i + 0.5);
Pc += CurrentConcrete.SigmaC(fcd, EpsilonR(ri, x, d)) * b * range / k;
}
double PAs1 = As1 * CurrentSteel.SigmaS(EpsilonR(0, x, d), fyd);
double PAs2 = As2 * CurrentSteel.SigmaS(EpsilonR(d - a2, x, d), fyd);
NRd = Pc + PAs2 + PAs1;
if (NRd >= NEd)
{
x2 = x;
}
else
{
x1 = x;
}
} while (Math.Abs(NEd - NRd) > eps);
double Pcz = 0;
for (int i = 0; i < k; i++)
{
double ri = d - range / k * (i + 0.5);
double sC = CurrentConcrete.SigmaC(fcd, EpsilonR(ri, x, d));
Pcz += sC * b * (range / k) * ri;
}
double MAs2 = As2 * CurrentSteel.SigmaS(EpsilonR(d - a2, x, d), fyd) * (d - a2);
double Ms1 = Pcz + MAs2;
double MRd = Ms1 - NEd * (d - 0.5 * h);
return(MRd * 1000);
}
