public ConcreteSectionFlexure GetRectangularSectionFourSidesDistributed(double b, double h,
double A_sTopBottom, double A_sLeftRight, double c_centTopBottom, double c_centLeftRight, IConcreteMaterial mat, IRebarMaterial rebarMaterial)
{
double YTop = h / 2.0 - c_centTopBottom;
double YBottom = -h / 2.0 + c_centTopBottom;
double XLeft = -b / 2.0 + c_centLeftRight;
double XRight = b / 2.0 - c_centLeftRight;
Point2D P1 = new Point2D(XLeft, YTop);
Point2D P2 = new Point2D(XRight, YTop);
Point2D P3 = new Point2D(XRight, YBottom);
Point2D P4 = new Point2D(XLeft, YBottom);
RebarLine topLine = new RebarLine(A_sTopBottom, P1, P2, rebarMaterial, false);
RebarLine bottomLine = new RebarLine(A_sTopBottom, P3, P4, rebarMaterial, false);
RebarLine leftLine = new RebarLine(A_sLeftRight, P2, P3, rebarMaterial, true);
RebarLine rightLine = new RebarLine(A_sLeftRight, P4, P1, rebarMaterial, true);
List<RebarPoint> LongitudinalBars = new List<RebarPoint>();
LongitudinalBars.AddRange(topLine.RebarPoints);
LongitudinalBars.AddRange(bottomLine.RebarPoints);
LongitudinalBars.AddRange(leftLine.RebarPoints);
LongitudinalBars.AddRange(rightLine.RebarPoints);
CrossSectionRectangularShape section = new CrossSectionRectangularShape(mat, null, b, h);
CalcLog log = new CalcLog();
ConcreteSectionFlexure sectionFlexure = new ConcreteSectionFlexure(section, LongitudinalBars, log);
return sectionFlexure;
}
public static Dictionary<string, object> WindGustEffectFactor(double B,double h,double L,double beta,double n_1,double V,
string WindExposureCategory, string WindStructureDynamicResponseType = "Flexible", string Code = "ASCE7-10")
{
//Default values
double G = 0;
//Calculation logic:
WindExposureCategory Exposure;
bool IsValidStringExposure = Enum.TryParse(WindExposureCategory, true, out Exposure);
if (IsValidStringExposure == false)
{
throw new Exception("Exposure category is not recognized. Check input string.");
}
WindStructureDynamicResponseType response;
bool IsValidStringResponse = Enum.TryParse(WindStructureDynamicResponseType, true, out response);
if (IsValidStringResponse == false)
{
throw new Exception("Dynamic response type is not recognized. Specify Rigid or Flexible. Check input string.");
}
CalcLog Log = new CalcLog();
WindStructure structure = new WindStructure(Log);
G = structure.GetGustFacor(response,B,h,L,beta,n_1,V,Exposure);
return new Dictionary<string, object>
{
{ "G", G }
};
}
public static Dictionary<string, object> SeismicFundamentalPeriodGeneralMethod(double h_n, string SeismicSystemTypeGeneralProcedure, string Code = "ASCE7-10")
{
//Default values
double T_a = 0;
//Calculation logic:
CalcLog log = new CalcLog();
SeismicSystemTypeForApproximateAnalysis SeismicSystemType;
bool IsValidSystemType = Enum.TryParse(SeismicSystemTypeGeneralProcedure, out SeismicSystemType);
if (IsValidSystemType==false)
{
throw new Exception("Lateral system not recognized");
}
Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.Building b = new Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.Building(null,
Wosad.Loads.ASCE7.Entities.SeismicDesignCategory.None, log);
T_a = b.GetApproximatePeriodGeneral(h_n, SeismicSystemType);
return new Dictionary<string, object>
{
{ "T_a", T_a }
};
}
public static Dictionary<string, object> ExternalPressureCoefficientMWFRS(double B, double L, string WindFaceType, string Code = "ASCE7-10")
{
//Default values
double C_p = 0;
//Calculation logic:
WindFace face;
bool IsValidStringFaceType = Enum.TryParse(WindFaceType, true, out face);
if (IsValidStringFaceType == false)
{
throw new Exception("Wind face type is not recognized. Use Windward, Leeward or Side. Check input string.");
}
CalcLog Log = new CalcLog();
Mwfrs Mwfrs = new Mwfrs(Log);
C_p = Mwfrs.GetWallPressureCoefficient(face, B, L);
return new Dictionary<string, object>
{
{ "C_p", C_p }
};
}
public static Dictionary<string, object> SeismicSiteCoefficients(double S_S, double S_1, string SiteClass, string Code = "ASCE7-10")
{
//Default values
double F_a = 0;
double F_v = 0;
//Calculation logic:
SeismicSiteClass _SiteClass;
bool ValidSiteClass = Enum.TryParse(SiteClass, out _SiteClass);
if (ValidSiteClass == false)
{
throw new Exception("Site class is not recognized. Please check input.");
}
else
{
CalcLog log = new CalcLog();
Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.Site s = new Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.Site(_SiteClass, log);
F_a = s.SiteCoefficientFa(S_S);
F_v = s.SiteCoefficientFv(S_1);
}
return new Dictionary<string, object>
{
{ "F_a", F_a }
,{ "F_v", F_v }
};
}
public static Dictionary<string, object> WindVelocityPressure(double K_z, double K_zt, double K_d, double V, string WindVelocityLocation = "Wall", string Code = "ASCE7-10")
{
//public static double WindVelocityPressure(double K_z, double K_zt, double K_d, double V, string WindVelocityLocation = "Wall")
//{
//Default values
double q_z = 0;
//Calculation logic:
WindVelocityLocation Location;
bool IsValidStringLocation = Enum.TryParse(WindVelocityLocation, true, out Location);
if (IsValidStringLocation == false)
{
throw new Exception("Wind pressure location is not recognized. Check input string.");
}
CalcLog Log = new CalcLog();
BuildingDirectionalProcedureElement element = new BuildingDirectionalProcedureElement(Log);
q_z = element.GetVelocityPressure(K_z, K_zt, K_d, V, Location);
return new Dictionary<string, object>
{
{ "q_z", q_z }
};
//return q_z;
}
public void ReturnColumnStabilityFactorDimensionalLumber()
{
CalcLog log = new CalcLog();
DimensionalLumber m = new DimensionalLumber();
double b = 1.5;
double d = 5.5;
double C_F =1.0;
double C_M = 1.0;
double C_t = 1.0;
double C_i = 1.0;
double C_T = 1.0;
double C_D = 1.15;
double E_min =580.0;
double F_c = 1.6;
double l_e = 144.0;
double lambda =0.8;
double C_P = m.GetColumnStabilityFactor(d, F_c, E_min, l_e, C_M, C_M, C_t, C_t,C_F, C_i, C_i, C_T, lambda);
double refValue = 0.342;
double actualTolerance = EvaluateActualTolerance(C_P, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public static Dictionary<string, object> XAxisProperties(string SteelShapeId)
{
//Default values
double x_e = 0;
double x_p = 0;
double I_x = 0;
double Z_x = 0;
double S_x = 0;
double r_x = 0;
//Calculation logic:
CalcLog cl = new CalcLog();
AiscCatalogShape shape = new AiscCatalogShape(SteelShapeId, cl);
x_e = shape.x;
x_p = shape.xp;
I_x = shape.Ix;
Z_x = shape.Zx;
S_x = shape.Sx;
r_x = shape.rx;
return new Dictionary<string, object>
{
{ "x_e", x_e }
,{ "x_p", x_p }
,{ "I_x", I_x }
,{ "Z_x", Z_x }
,{ "S_x", S_x }
,{ "r_x", r_x }
};
}
protected double GetFcrGeneral()
{
SectionRectangular r = new SectionRectangular(t_w, h_o);
SteelMaterial mat = new SteelMaterial(Material.YieldStress);
CalcLog log = new CalcLog();
AffectedElementInFlexure flexuralElement = new AffectedElementInFlexure(r, mat, log);
return flexuralElement.GetPlateBucklingCriticalStress(c);
#region Obsolete
//double lambda = GetLambda();
//double F_y = Material.YieldStress;
//double Q;
//if (lambda<=0.7)
//{
// Q = 1.0;
//}
//else if (lambda<=1.41)
//{
// Q = (1.34 - 0.468 * lambda);
//}
//else
//{
// Q = ((1.3) / (Math.Pow(lambda, 2)));
//}
//double F_cr = F_y * Q;
//return F_cr;
#endregion
}
public static Dictionary<string, object> YAxisProperties(string SteelShapeId)
{
//Default values
double y_e = 0;
double y_p = 0;
double I_y = 0;
double Z_y = 0;
double S_y = 0;
double r_y = 0;
//Calculation logic:
CalcLog cl = new CalcLog();
AiscCatalogShape shape = new AiscCatalogShape(SteelShapeId, cl);
y_e = shape.y;
y_p = shape.yp;
I_y = shape.Iy;
Z_y = shape.Zy;
S_y = shape.Sy;
r_y = shape.ry;
return new Dictionary<string, object>
{
{ "y_e", y_e }
,{ "y_p", y_p }
,{ "I_y", I_y }
,{ "Z_y", Z_y }
,{ "S_y", S_y }
,{ "r_y", r_y }
};
}
public static Dictionary<string, object> WindInternalPressureCoefficient(string WindEnclosureType = "Enclosed", string Code = "ASCE7-10")
{
//Default values
double GC_pi = 0;
//Calculation logic:
WindEnclosureType Enclosure;
bool IsValidStringEnclosure = Enum.TryParse(WindEnclosureType, true, out Enclosure);
if (IsValidStringEnclosure == false)
{
throw new Exception("Wind enclosure type is not recognized. Check input string.");
}
CalcLog Log = new CalcLog();
WindBuilding building = new WindBuilding(Log);
GC_pi = building.GetInternalPressureCoefficient(Enclosure);
return new Dictionary<string, object>
{
{ "GC_pi", GC_pi }
};
}
public void ReturnColumnStabilityFactorTimber()
{
CalcLog log = new CalcLog();
DimensionalLumber m = new DimensionalLumber();
double b = 5.5;
double d = 5.5;
double C_F = 1.0;
double C_M_Fc = 0.91;
double C_M_E = 1.0;
double C_t = 1.0;
double C_i = 1.0;
double C_T = 1.0;
double C_D = 1.15;
double E_min = 470.0;
double F_c =0.85;
double l_e = 15*12*0.5; //with K-factor
double lambda = 0.8;
double C_P = m.GetColumnStabilityFactor(d, F_c, E_min, l_e,C_M_Fc,C_M_E, C_t,C_t, C_F, C_i,C_i, C_T, lambda);
double refValue = 0.827;
double actualTolerance = EvaluateActualTolerance(C_P, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public ISteelCompressionMember GetIshape(ISteelSection Section, bool IsRolled, double L_x, double L_y, double L_z, ICalcLog CalcLog)
{
ISteelCompressionMember column = null;
IShapeCompactness compactnessTop = new ShapeCompactness.IShapeMember(Section, IsRolled, Common.Section.Interfaces.FlexuralCompressionFiberPosition.Top);
IShapeCompactness compactnessBot = new ShapeCompactness.IShapeMember(Section, IsRolled, Common.Section.Interfaces.FlexuralCompressionFiberPosition.Bottom);
ICalcLog Log = new CalcLog();
CompactnessClassAxialCompression flangeCompactnessTop = compactnessTop.GetFlangeCompactnessCompression();
CompactnessClassAxialCompression flangeCompactnessBot = compactnessTop.GetFlangeCompactnessCompression();
CompactnessClassAxialCompression webCompactness = compactnessTop.GetWebCompactnessCompression();
if (flangeCompactnessTop == CompactnessClassAxialCompression.NonSlender && webCompactness == CompactnessClassAxialCompression.NonSlender
&& flangeCompactnessBot == CompactnessClassAxialCompression.NonSlender)
{
column = new IShapeCompact(Section, IsRolled, L_x, L_y, L_z, Log);
//if (IShape.b_fBot == IShape.b_fTop && IShape.t_fBot == IShape.t_fTop)
//{
// return new IShapeCompact(SectionI, IsRolledShape, L_ex, L_ey, L_ez, log);
//}
//else
//{
// throw new NotImplementedException();
//}
}
else
{
column = new IShapeSlenderElements(Section, IsRolled, L_x, L_y, L_z, Log);
}
return column;
}
public static Dictionary<string, object> SeismicImportanceFactor(string BuildingRiskCategory, string Code = "ASCE7-10")
{
//Default values
double I_e = 0;
//Calculation logic:
CalcLog log = new CalcLog();
Wosad.Loads.ASCE7.Entities.BuildingRiskCategory _BuildingRiskCategory;
bool IsValidCat = Enum.TryParse(BuildingRiskCategory, out _BuildingRiskCategory);
if (IsValidCat == false)
{
throw new Exception("Building risk category not recognized. Check input.");
}
//= (BuildingRiskCategory)Enum.Parse(typeof(BuildingRiskCategory), (string)GetParameterValue("RiskCategory", inputData));
Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.General gen = new Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.General(log);
I_e = gen.GetImportanceFactor(_BuildingRiskCategory);
return new Dictionary<string, object>
{
{ "I_e", I_e }
};
}
public static Dictionary<string, object> MaterialMechanicalProperties(string SteelMaterialId, double d_b = 0, string Code = "AISC360-10")
{
//Default values
double F_y = 0;
double F_u = 0;
double E = 0;
double G = 0;
//Calculation logic:
CalcLog cl = new CalcLog();
SteelMaterialCatalog sm = new SteelMaterialCatalog(SteelMaterialId, d_b, cl);
F_y = sm.YieldStress;
F_u = sm.UltimateStress;
E = sm.ModulusOfElasticity;
G = sm.ShearModulus;
return new Dictionary<string, object>
{
{ "F_y", F_y }
,{ "F_u", F_u }
,{ "E", E }
,{ "G", G }
};
}
public ConcreteSectionCompression GetCompressionMember(ConcreteSectionFlexure flexuralSection,
CompressionMemberType CompressionMemberType)
{
CalcLog log = new CalcLog();
ConcreteSectionCompression compSection = new ConcreteSectionCompression(flexuralSection, CompressionMemberType, log);
return compSection;
}
public void ConnectedPlateReturnsFlexuralStrength()
{
ICalcLog log = new CalcLog();
SectionRectangular Section = new SectionRectangular(0.5, 8);
ISteelMaterial Material = new SteelMaterial(50);
AffectedElementInFlexure element = new AffectedElementInFlexure(Section, Material, log);
double phiM_n = element.GetFlexuralStrength();
Assert.AreEqual(360.0, phiM_n);
}
public static Dictionary<string, object> ShapeBasicGeometricProperties(string SteelShapeId)
{
//Default values
double d = 0;
double b= 0;
double b_f = 0;
double t_f = 0;
double t_w = 0;
double k = 0;
double D = 0;
double B = 0;
double H = 0;
double t = 0;
double t_nom = 0;
double t_des = 0;
double A = 0;
//Calculation logic
CalcLog cl = new CalcLog();
AiscCatalogShape shape = new AiscCatalogShape(SteelShapeId, cl);
d = shape.d;
b_f = shape.bf;
t_f = shape.tf;
t_w = shape.tw;
k = shape.kdes;
D = shape.OD;
b = shape.b;
B = shape.B;
H = shape.Ht;
t = shape.t;
t_nom = shape.tnom;
t_des = shape.tdes;
A = shape.A;
return new Dictionary<string, object>
{
{ "d", d }
,{ "b_f", b_f }
,{ "t_f", t_f }
,{ "t_w", t_w }
,{ "k", k }
,{ "D", D }
,{ "B", B }
,{ "H", H }
,{ "t", t }
,{ "t_nom", t_nom }
,{ "t_des", t_des }
,{ "b", b }
,{ "A", A }
};
}
public double GetFlexuralStrength()
{
double phiM_n =0.0;
CalcLog log = new CalcLog();
ISection section = Section.Shape;
if (section is SectionRectangular || section is SectionOfPlateWithHoles || section is SectionI)
{
if (section is SectionOfPlateWithHoles)
{
SectionOfPlateWithHoles plateWithHoles = section as SectionOfPlateWithHoles;
double S_g = plateWithHoles.B * Math.Pow(plateWithHoles.H, 2);
double Z_net = plateWithHoles.Z_x;
double Y = 0.9* this.Section.Material.YieldStress * S_g; //Flexural Yielding
double R = 0.75* this.Section.Material.UltimateStress * Z_net;
phiM_n = Math.Min(Y, R);
}
else if (section is ISectionI )
{
ISectionI IShape = section as ISectionI;
double R = GetTensionFlangeRuptureStrength(IShape);
if (IsCompactDoublySymmetricForFlexure == false)
{
throw new Exception("Noncompact and singly symmetric I-shapes are not supported for connection checks.");
}
else
{
BeamIDoublySymmetricCompact IBeam = new BeamIDoublySymmetricCompact(Section,this.IsRolled, Log);
double Y = 0.9 * IBeam.GetMajorNominalPlasticMoment();
phiM_n = Math.Min(Y, R);
}
}
else //Rectangle
{
SectionRectangular plate = section as SectionRectangular;
if (plate !=null)
{
double Z = plate.Z_x;
double Y =0.9* this.Section.Material.YieldStress * Z;
phiM_n = Y;
}
}
}
else
{
throw new Exception("Wrong section type. Only SectionRectangular, SectionOfPlateWithHoles and SectionI are supported.");
}
return phiM_n;
}
public void DougFirReturnsBendingReferenceValue()
{
CalcLog log = new CalcLog();
VisuallyGradedDimensionLumber dl = new VisuallyGradedDimensionLumber("DOUGLAS FIR-LARCH (NORTH)",
"Stud", "2 in. & wider", log);
double F_b = dl.F_b;
double refValue = 650.0;
double actualTolerance = EvaluateActualTolerance(F_b, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public static Dictionary<string, object> SeismicStoryForces(double T, double C_s, List<double> StoryElevationsFromBase, List<double> StoryWeights, string Code = "ASCE7-10")
{
//Default values
List<double> StoryForces = new List<double>();
//Calculation logic:
CalcLog log = new CalcLog();
SeismicLateralForceResistingStructure structure = new SeismicLateralForceResistingStructure(log);
StoryForces = structure.CalculateSeismicLoads(T, C_s, StoryElevationsFromBase, StoryWeights);
return new Dictionary<string, object>
{
{ "StoryForces", StoryForces }
};
}
public void ReturnsSizeFactorDimensionalLumber()
{
CalcLog log = new CalcLog();
DimensionalLumber m = new DimensionalLumber();
double b = 1.5;
double d = 5.5;
double C_F = m.GetSizeFactor(d, b, Wood.NDS.Entities.SawnLumberType.DimensionLumber, Wood.NDS.Entities.CommercialGrade.No2,
Wood.NDS.Entities.ReferenceDesignValueType.Bending);
double refValue = 1.3;
double actualTolerance = EvaluateActualTolerance(C_F, refValue);
Assert.LessOrEqual(actualTolerance, tolerance);
}
public static Dictionary<string, object> ReferenceValues(string WoodSpeciesId, string CommercialGradeId, string SizeClassId="2 in. & wider",
string WoodMemberType = "SawnDimensionLumber",
string Code = "NDS2015")
{
//Default values
double F_b = 0;
double F_c = 0;
double F_t = 0;
double F_v = 0;
double E = 0;
double E_min = 0;
double F_cPerp = 0;
double G = 0.0;
//Calculation logic:
if (WoodMemberType.Contains("Sawn") && WoodMemberType.Contains("Lumber"))
{
CalcLog log = new CalcLog();
VisuallyGradedDimensionLumber dl = new VisuallyGradedDimensionLumber(WoodSpeciesId,
CommercialGradeId, SizeClassId, log);
F_b = dl.F_b/1000.0; //All Dynamo nodes use ksi units by default
F_c = dl.F_cParal / 1000.0; //All Dynamo nodes use ksi units by default
F_t = dl.F_t / 1000.0; //All Dynamo nodes use ksi units by default
F_v = dl.F_v / 1000.0; //All Dynamo nodes use ksi units by default
E = dl.E / 1000.0; //All Dynamo nodes use ksi units by default
E_min = dl.E_min / 1000.0; //All Dynamo nodes use ksi units by default
F_cPerp = dl.F_cPerp / 1000.0; //All Dynamo nodes use ksi units by default
G = dl.G;
}
else
{
throw new Exception("Wood member type not supported.");
}
return new Dictionary<string, object>
{
{ "F_b", F_b }
,{ "F_c", F_c }
,{ "F_t", F_t }
,{ "F_v", F_v }
,{ "E", E }
,{ "E_min", E_min }
,{ "F_cPerp", F_cPerp }
,{ "G", G }
};
}
public static Dictionary<string, object> WindExposureConstants(string WindExposureCategory, string Code = "ASCE7-10")
{
//Default values
double alpha = 0;
double z_g = 0;
double alpha_ = 0;
double b_ = 0;
double c = 0;
double l = 0;
double epsilon_ = 0;
double z_min = 0;
WindExposureCategory Exposure;
//Calculation logic:
bool IsValidStringExposure = Enum.TryParse(WindExposureCategory, true, out Exposure);
if (IsValidStringExposure == false)
{
throw new Exception("Exposure category is not recognized. Check input string.");
}
CalcLog log = new CalcLog();
WindStructure structure = new WindStructure(new CalcLog());
//structure.GetTerrainExposureConstant(TerrainExposureConstant.alpha, Exposure);
alpha = structure.GetTerrainExposureConstant(TerrainExposureConstant.alpha , Exposure);
z_g = structure.GetTerrainExposureConstant(TerrainExposureConstant.zg , Exposure);
alpha_ = structure.GetTerrainExposureConstant(TerrainExposureConstant.alpha_ob , Exposure);
b_ = structure.GetTerrainExposureConstant(TerrainExposureConstant.b_ob , Exposure);
c = structure.GetTerrainExposureConstant(TerrainExposureConstant.c , Exposure);
l = structure.GetTerrainExposureConstant(TerrainExposureConstant.l , Exposure);
epsilon_ = structure.GetTerrainExposureConstant(TerrainExposureConstant.epsilon_ob , Exposure);
z_min = structure.GetTerrainExposureConstant(TerrainExposureConstant.zmin , Exposure);
return new Dictionary<string, object>
{
{ "alpha", alpha }
,{ "z_g", z_g }
,{ "alpha_", alpha_ }
,{ "b_", b_ }
,{ "c", c }
,{ "l", l }
,{ "epsilon_", epsilon_ }
,{ "z_min", z_min }
};
}
public static Dictionary<string, object> SeismicFundamentalPeriodUpperLimitCoefficient(double S_D1, string Code = "ASCE7-10")
{
//Default values
double C_u = 0;
//Calculation logic:
CalcLog log = new CalcLog();
Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.Building building = new Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.Building(null, log);
C_u = building.GetCoefficientForUpperBoundOnCalculatedPeriod(S_D1);
return new Dictionary<string, object>
{
{ "C_u", C_u }
};
}
public void HssRhsConcentratedForceThroughPlateReturnsValue()
{
SectionTube ch = new SectionTube(null, 8, 8, 0.25,0.93*0.25,1.5*0.25);
SteelMaterial matE = new SteelMaterial(46.0);
SteelRhsSection Element = new SteelRhsSection(ch, matE);
SectionRectangular rec = new SectionRectangular(0.25,8.0);
SteelMaterial matR = new SteelMaterial(36.0);
SteelPlateSection pl = new SteelPlateSection(rec,matR);
CalcLog log = new CalcLog();
RhsLongitudinalThroughPlate concForceConnection = new RhsLongitudinalThroughPlate(Element, pl, log, false,45.0, 148.0, 0.0);
double phiR_n = concForceConnection.GetHssWallPlastificationStrengthUnderAxialLoad().Value;
double refValueSec = 46.2;
double actualToleranceSec = EvaluateActualTolerance(phiR_n, refValueSec);
Assert.LessOrEqual(actualToleranceSec, tolerance);
}
public static Dictionary<string, object> TorsionalProperties(string SteelShapeId)
{
//Default values
double J = 0;
double C = 0;
double C_w = 0;
double W_no = 0;
double S_w1 = 0;
double S_w2 = 0;
double S_w3 = 0;
double Q_fl = 0;
double Q_w = 0;
//Calculation logic:
CalcLog cl = new CalcLog();
AiscCatalogShape shape = new AiscCatalogShape(SteelShapeId, cl);
J = shape.J;
C = shape.C;
C_w = shape.Cw;
C_w =shape.Cw;
W_no =shape.Wno;
S_w1 =shape.Sw1;
S_w2 =shape.Sw2;
S_w3 =shape.Sw3;
Q_fl =shape.Qf;
Q_w = shape.Qw;
return new Dictionary<string, object>
{
{ "J", J }
,{ "C", C }
,{ "C_w", C_w }
,{ "W_no", W_no }
,{ "S_w1", S_w1 }
,{ "S_w2", S_w2 }
,{ "S_w3", S_w3 }
,{ "Q_fl", Q_fl }
,{ "Q_w", Q_w }
};
}
public static Dictionary<string, object> SeismicDesignCategory(string BuildingRiskCategory, double S_DS, double S_D1, double S_1, string Code = "ASCE7-10")
{
//Default values
string SeismicDesignCategory = "";
//Calculation logic:
Wosad.Loads.ASCE7.Entities.BuildingRiskCategory RiskCategory;
bool ValidRiskCategory = Enum.TryParse(BuildingRiskCategory, out RiskCategory);
CalcLog log = new CalcLog();
Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.General gen = new Wosad.Loads.ASCE.ASCE7_10.SeismicLoads.General(log);
SeismicDesignCategory = gen.GetSeismicDesignCategory(RiskCategory, S_DS, S_D1, S_1).ToString();
return new Dictionary<string, object>
{
{ "SeismicDesignCategory", SeismicDesignCategory }
};
}
public ISteelCompressionMember GetRhsShape(ISteelSection Section, double L_ex, double L_ey, double L_ez, ICalcLog CalcLog)
{
ISteelCompressionMember column = null;
IShapeCompactness compactnessX = new ShapeCompactness.HollowMember(Section, Common.Section.Interfaces.FlexuralCompressionFiberPosition.Top, Common.Entities.MomentAxis.XAxis);
IShapeCompactness compactnessY = new ShapeCompactness.HollowMember(Section, Common.Section.Interfaces.FlexuralCompressionFiberPosition.Top, Common.Entities.MomentAxis.YAxis);
ICalcLog Log = new CalcLog();
CompactnessClassAxialCompression webCompactnessX = compactnessX.GetWebCompactnessCompression();
CompactnessClassAxialCompression webCompactnessY = compactnessY.GetWebCompactnessCompression();
if (webCompactnessX == CompactnessClassAxialCompression.NonSlender && webCompactnessY == CompactnessClassAxialCompression.NonSlender )
{
return new RhsNonSlender(Section, L_ex, L_ey, L_ez, CalcLog);
}
else
{
return new RhsSlender(Section, L_ex, L_ey, L_ez, CalcLog);
}
return column;
}
public static Dictionary<string, object> CompressionDevelopmentLengthBasic(Concrete.ACI318.General.Concrete.ConcreteMaterial ConcreteMaterial, double d_b,
RebarMaterial RebarMaterial, bool HasConfiningReinforcement=false, string Code = "ACI318-14")
{
//Default values
double l_dc = 0;
//Calculation logic:
IRebarMaterial mat = RebarMaterial.Material;
Rebar rebar = new Rebar(d_b, false, mat);
CalcLog log = new CalcLog();
DevelopmentCompression cd = new DevelopmentCompression(ConcreteMaterial.Concrete, rebar, log, HasConfiningReinforcement);
l_dc = cd.Length;
return new Dictionary<string, object>
{
{ "l_dc", l_dc }
};
}