public double GetLocalBucklingCapacity()
{
double M_n = 0.0;
if (this.SectionPipe != null)
{
CompactnessClassFlexure cClass = GetCompactnessClass();
if (cClass == CompactnessClassFlexure.Noncompact || cClass == CompactnessClassFlexure.Slender)
{
double Sx = Section.Shape.S_xTop;
if (cClass == CompactnessClassFlexure.Noncompact)
{
//noncompact
M_n = (0.021 * E / (D / t) + F_y) * Sx; //(F8-2)
}
else
{
//slender
double Fcr = 0.33 * E / (D / t); //(F8-4)
M_n = Fcr * Sx; // (F8-3)
}
}
else
{
M_n = double.PositiveInfinity;
}
}
double phiM_n = 0.9 * M_n;
return(phiM_n);
}
//Compression Flange Local Buckling F7.2
public double GetCompressionFlangeLocalBucklingCapacity(FlexuralCompressionFiberPosition CompressionLocation, MomentAxis MomentAxis)
{
double Mn = 0.0;
double phiM_n = 0.0;
if (Section != null)
{
double lambda = this.GetLambdaCompressionFlange(CompressionLocation, MomentAxis);
double lambdapf = this.GetLambdapf(CompressionLocation, MomentAxis);
double lambdarf = this.GetLambdarf(CompressionLocation, MomentAxis);
//note: section is doubly symmetric so top flange is taken
double S = GetSectionModulus(MomentAxis);
double Fy = this.Section.Material.YieldStress;
double E = this.Section.Material.ModulusOfElasticity;
CompactnessClassFlexure cClass = GetFlangeCompactness(CompressionLocation, MomentAxis);
if (cClass == CompactnessClassFlexure.Noncompact)
{
double Mp = this.GetMajorNominalPlasticMoment();
Mn = GetMnNoncompact(Mp, Fy, S, lambda);
}
else
{
double Sxe = GetEffectiveSectionModulusX(MomentAxis);
Mn = GetMnSlender(Sxe, Fy);
}
}
phiM_n = 0.9 * Mn;
return(phiM_n);
}
public override SteelLimitStateValue GetFlexuralLegOrStemBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation,
FlexuralAndTorsionalBracingType BracingType)
{
CompactnessClassFlexure StemCompactness = this.Compactness.GetWebCompactnessFlexure();
// for compact angles this limit state is not applicable
SteelLimitStateValue ls = null;
if (StemCompactness == General.Compactness.CompactnessClassFlexure.Compact)
{
ls = new SteelLimitStateValue(-1, false);
return(ls);
}
else if (StemCompactness == CompactnessClassFlexure.Noncompact)
{
double S_c = GetSectionModulus(CompressionLocation, true, BracingType);
//F10-7
double M_n = F_y * S_c * (2.43 - 1.72 * (((b) / (t))) * Math.Sqrt(((F_y) / (E))));
double phiM_n = 0.9 * M_n;
ls = new SteelLimitStateValue(phiM_n, true);
}
else
{
double F_cr = ((0.71 * E) / (Math.Pow((((b) / (t))), 2)));
double S_c = GetSectionModulus(CompressionLocation, true, BracingType);
//(F10-8)
double M_n = F_cr * S_c;
double phiM_n = 0.9 * M_n;
ls = new SteelLimitStateValue(phiM_n, true);
}
return(ls);
}
private ISteelBeamFlexure CreateRhsBeam(CompactnessClassFlexure FlangeCompactness, FlexuralCompressionFiberPosition compressionFiberPosition,
CompactnessClassFlexure WebCompactness,
ISectionTube RhsSec, ISteelMaterial Material, MomentAxis MomentAxis, ICalcLog Log)
{
SteelRhsSection steelSection = new SteelRhsSection(RhsSec, Material);
ISteelBeamFlexure beam = null;
beam = new BeamRectangularHss(steelSection, compressionFiberPosition, MomentAxis, Log);
return(beam);
}
//Compression Flange Local Buckling F4.3
public double GetCompressionFlangeLocalBucklingCapacity(FlexuralCompressionFiberPosition compressionFiberPosition)
{
double Mn = 0.0;
double bf = GetCompressionFlangeWidthbfc(compressionFiberPosition);
double tf = GetCompressionFlangeThicknesstfc(compressionFiberPosition);
ShapeCompactness.IShapeMember compactness = new ShapeCompactness.IShapeMember(Section, IsRolledMember, compressionFiberPosition);
CompactnessClassFlexure flangeCompactness = compactness.GetFlangeCompactnessFlexure();
double lambda = compactness.GetCompressionFlangeLambda();
double Sxc = GetSectionModulusCompressionSxc(compressionFiberPosition);
switch (flangeCompactness)
{
case CompactnessClassFlexure.Compact:
throw new LimitStateNotApplicableException("Compression Flange Local buckling");
case CompactnessClassFlexure.Noncompact:
double Rpc = GetRpc(compressionFiberPosition);
double Myc = GetCompressionFiberYieldMomentMyc(compressionFiberPosition);
double lambdapf = compactness.GetFlangeLambda_p(StressType.Flexure);
double lambdarf = compactness.GetFlangeLambda_r(StressType.Flexure);
double FL = GetStressFL(compressionFiberPosition);
Mn = Rpc * Myc - (Rpc * Myc - FL * Sxc) * ((lambda - lambdapf) / (lambdarf - lambdapf)); //(F4-13)
break;
case CompactnessClassFlexure.Slender:
double kc = Getkc();
double E = this.Section.Material.ModulusOfElasticity;
Mn = 0.9 * E * kc * Sxc / Math.Pow(lambda, 2);
break;
}
double phiM_n = 0.9 * Mn;
return(phiM_n);
}
protected virtual CompactnessResult GetShapeCompactness()
{
ShapeCompactness.IShapeMember compactnessTop = new ShapeCompactness.IShapeMember(Section, IsRolledMember, FlexuralCompressionFiberPosition.Top);
CompactnessClassFlexure flangeCompactnessTop = compactnessTop.GetFlangeCompactnessFlexure();
ShapeCompactness.IShapeMember compactnessBot = new ShapeCompactness.IShapeMember(Section, IsRolledMember, FlexuralCompressionFiberPosition.Top);
CompactnessClassFlexure flangeCompactnessBot = compactnessTop.GetFlangeCompactnessFlexure();
double lambda = 0.0;
double lambdaTop = compactnessTop.GetCompressionFlangeLambda();
double lambdaBot = compactnessBot.GetCompressionFlangeLambda();
CompactnessClassFlexure flangeCompactness;
ShapeCompactness.IShapeMember thisShapeCompactness;
double b = 0;
double tf = 0.0;
if (lambdaTop > lambdaBot)
{
thisShapeCompactness = compactnessTop;
flangeCompactness = flangeCompactnessTop;
lambda = lambdaTop;
b = GetBfTop();
tf = Get_tfTop();
}
else
{
thisShapeCompactness = compactnessBot;
flangeCompactness = flangeCompactnessBot;
lambda = lambdaBot;
b = GetBfBottom();
tf = Get_tfBottom();
}
return(new CompactnessResult()
{
ShapeCompactness = thisShapeCompactness,
FlangeCompactness = flangeCompactness,
b = b,
tf = tf,
lambda = lambda
});
}
public SteelLimitStateValue GetFlexuralWebOrWallBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation)
{
SteelLimitStateValue ls = new SteelLimitStateValue();
ShapeCompactness.HollowMember Compactness = new ShapeCompactness.HollowMember(Section, CompressionLocation, MomentAxis.XAxis);
CompactnessClassFlexure cClass = Compactness.GetWebCompactnessFlexure();
if (cClass == CompactnessClassFlexure.Compact)
{
ls = new SteelLimitStateValue(-1, false);
}
else
{
double phiM_n = GetLocalBucklingCapacity();
ls = new SteelLimitStateValue(phiM_n, true);
}
return(ls);
}
public ISteelBeamFlexure GetBeamCase()
{
ISteelBeamFlexure beam = null;
IShapeCompactness compactness = new ShapeCompactness.IShapeMember(section, IsRolledMember, compressionFiberPosition);
CompactnessClassFlexure flangeCompactness = compactness.GetFlangeCompactnessFlexure();
CompactnessClassFlexure webCompactness = compactness.GetWebCompactnessFlexure();
if (flangeCompactness == CompactnessClassFlexure.Compact && webCompactness == CompactnessClassFlexure.Compact)
{
return(new BeamIDoublySymmetricCompact(section, IsRolledMember, CalcLog));
}
else
{
if (webCompactness == CompactnessClassFlexure.Compact)
{
return(new BeamIDoublySymmetricCompactWebOnly(section, IsRolledMember, CalcLog));
}
else if (webCompactness == CompactnessClassFlexure.Noncompact)
{
if (flangeCompactness == CompactnessClassFlexure.Compact)
{
return(new BeamINoncompactWebCompactFlange(section, IsRolledMember, CalcLog));
}
else
{
return(new BeamINoncompactWeb(section, IsRolledMember, CalcLog));
}
}
else //slender web
{
if (flangeCompactness == CompactnessClassFlexure.Compact)
{
return(new BeamISlenderWebCompactFlange(section, IsRolledMember, CalcLog));
}
else
{
return(new BeamISlenderWeb(section, IsRolledMember, CalcLog));
}
}
}
return(beam);
}
//Compression Flange Local Buckling F3.2
public double GetCompressionFlangeLocalBucklingCapacity()
{
double M_n = 0.0;
double phiM_n = 0.0;
ISectionI sectionI = Section.Shape as ISectionI;
if (sectionI != null)
{
ShapeCompactness.IShapeMember compactness = new ShapeCompactness.IShapeMember(Section, IsRolledMember, FlexuralCompressionFiberPosition.Top);
CompactnessClassFlexure cClass = compactness.GetFlangeCompactnessFlexure();
if (cClass == CompactnessClassFlexure.Noncompact || cClass == CompactnessClassFlexure.Slender)
{
double lambda = this.GetLambdaCompressionFlange(FlexuralCompressionFiberPosition.Top);
double lambdapf = this.GetLambdapf(FlexuralCompressionFiberPosition.Top);
double lambdarf = this.GetLambdarf(FlexuralCompressionFiberPosition.Top);
//note: section is doubly symmetric so top flange is taken
double Sx = this.Section.Shape.S_xTop;
double Fy = this.Section.Material.YieldStress;
double E = this.Section.Material.ModulusOfElasticity;
//double Zx = Section.SectionBase.Z_x;
if (cClass == CompactnessClassFlexure.Noncompact)
{
double Mp = this.GetMajorNominalPlasticMoment();
M_n = Mp - (Mp - 0.7 * Fy * Sx) * ((lambda - lambdapf) / (lambdarf - lambdapf)); //(F3-1)
}
else
{
double kc = this.Getkc();
M_n = 0.9 * E * kc * Sx / Math.Pow(lambda, 2); //(F3-2)
}
}
else
{
}
if (cClass == CompactnessClassFlexure.Compact)
{
throw new LimitStateNotApplicableException("Flange local buckling");
}
}
phiM_n = 0.9 * M_n;
return(phiM_n);
}
public double GetCompressionFlangeLocalBucklingCapacity()
{
// compactness criteria is selected by the most slender flange
bool LimitStateApplicable = DetermineIfFLBLimitStateIsApplicable();
double Mn = 0;
CompactnessResult compactnessResult = GetShapeCompactness();
IShapeCompactness thisShapeCompactness = compactnessResult.ShapeCompactness;
CompactnessClassFlexure flangeCompactness = compactnessResult.FlangeCompactness;
double b = compactnessResult.b;
double tf = compactnessResult.tf;
double lambda = compactnessResult.lambda;
double Mp = Z_y * F_y;
double lambdapf = thisShapeCompactness.GetFlangeLambda_p(StressType.Flexure);
double lambdarf = thisShapeCompactness.GetFlangeLambda_r(StressType.Flexure);
switch (flangeCompactness)
{
case CompactnessClassFlexure.Compact:
Mn = double.PositiveInfinity;
break;
case CompactnessClassFlexure.Noncompact:
Mn = Mp - (Mp - 0.7 * F_y * S_y) * ((lambda - lambdapf) / (lambdarf - lambdapf)); //(F6-2)
break;
case CompactnessClassFlexure.Slender:
double Fcr = 0.69 * E / Math.Pow(b / tf, 2.0); //(F6-4)
Mn = Fcr * S_y; //(F6-3)
break;
}
double phiM_n = 0.9 * Mn;
return(phiM_n);
}
private ISteelBeamFlexure CreateIBeam(CompactnessClassFlexure FlangeCompactness,
CompactnessClassFlexure WebCompactness, ISectionI Section, ISteelMaterial Material,
ICalcLog Log, bool IsRolled)
{
SteelSectionI steelSection = new SteelSectionI(Section, Material);
ISteelBeamFlexure beam = null;
if (FlangeCompactness == CompactnessClassFlexure.Compact && WebCompactness == CompactnessClassFlexure.Compact)
{
//F2
beam = new BeamIDoublySymmetricCompact(steelSection, IsRolled, Log);
}
else if (WebCompactness == CompactnessClassFlexure.Compact && FlangeCompactness != CompactnessClassFlexure.Compact)
{
//F3
throw new NotImplementedException();
}
return(beam);
}
public double GetCompressionFlangeLocalBucklingCapacity(FlexuralCompressionFiberPosition compressionFiberLocation)
{
double Mn = 0.0;
if (SectionTee != null)
{
CompactnessClassFlexure cClass = GetFlangeCompactnessClass();
if (cClass == CompactnessClassFlexure.Noncompact || cClass == CompactnessClassFlexure.Slender)
{
double lambda = GetLambdaFlange();
double lambdapf = this.GetLambdapf(compressionFiberLocation);
double lambdarf = this.GetLambdarf(compressionFiberLocation);
double Sxc = GetSectionModulusCompressionSxc(compressionFiberLocation);
double Fy = this.Section.Material.YieldStress;
double E = this.Section.Material.ModulusOfElasticity;
double My = GetYieldingMoment_My(compressionFiberLocation);
if (cClass == CompactnessClassFlexure.Noncompact)
{
double Mp = this.GetMajorNominalPlasticMoment();
Mn = GetMnFlbNoncompact(Mp, Sxc, lambda, lambdarf, lambdapf, My);
}
else
{
Mn = GetMnFlbSlender(Sxc, lambda);
}
}
else
{
}
if (cClass == CompactnessClassFlexure.Compact)
{
throw new LimitStateNotApplicableException("Flange local buckling");
}
}
return(Mn);
}
protected override CompactnessResult GetShapeCompactness()
{
//use only top fiber position properties
// it is assumed that Channel shape is symmetrical
ShapeCompactness.ChannelMember compactnessTop = new ShapeCompactness.ChannelMember(Section, IsRolledMember, FlexuralCompressionFiberPosition.Top);
CompactnessClassFlexure flangeCompactnessTop = compactnessTop.GetFlangeCompactnessFlexure();
double lambda = 0.0;
double lambdaTop = compactnessTop.GetCompressionFlangeLambda();
CompactnessClassFlexure flangeCompactness;
ShapeCompactness.ChannelMember thisShapeCompactness;
double b = 0;
double tf = 0.0;
thisShapeCompactness = compactnessTop;
flangeCompactness = flangeCompactnessTop;
lambda = lambdaTop;
b = SectionChannel.b_f;
tf = SectionChannel.t_f;
return(new CompactnessResult()
{
ShapeCompactness = thisShapeCompactness,
FlangeCompactness = flangeCompactness,
b = b,
tf = tf,
lambda = lambda
});
}
private ISteelBeamFlexure CreateIBeam(CompactnessClassFlexure FlangeCompactness,
CompactnessClassFlexure WebCompactness, ISectionI Section, ISteelMaterial Material,
ICalcLog Log, bool IsRolled)
{
SteelSectionI steelSection = new SteelSectionI(Section, Material);
ISteelBeamFlexure beam = null;
if (FlangeCompactness== CompactnessClassFlexure.Compact && WebCompactness == CompactnessClassFlexure.Compact)
{
//F2
beam = new BeamIDoublySymmetricCompact(steelSection, IsRolled, Log);
}
else if (WebCompactness == CompactnessClassFlexure.Compact && FlangeCompactness!= CompactnessClassFlexure.Compact)
{
//F3
throw new NotImplementedException();
}
return beam;
}
private ISteelBeamFlexure CreateRhsBeam(CompactnessClassFlexure FlangeCompactness, FlexuralCompressionFiberPosition compressionFiberPosition,
CompactnessClassFlexure WebCompactness,
ISectionTube RhsSec, ISteelMaterial Material, MomentAxis MomentAxis, ICalcLog Log)
{
SteelRhsSection steelSection = new SteelRhsSection(RhsSec, Material);
ISteelBeamFlexure beam = null;
beam = new BeamRectangularHss(steelSection,compressionFiberPosition, MomentAxis, Log);
return beam;
}
public ISteelBeamFlexure GetBeam(ISection Shape, ISteelMaterial Material, ICalcLog Log, MomentAxis MomentAxis,
FlexuralCompressionFiberPosition compressionFiberPosition, bool IsRolledMember = true)
{
ISteelBeamFlexure beam = null;
if (MomentAxis == Common.Entities.MomentAxis.XAxis)
{
if (Shape is ISectionI)
{
ISectionI IShape = Shape as ISectionI;
SteelSectionI SectionI = new SteelSectionI(IShape, Material);
if (IShape.b_fBot == IShape.b_fTop && IShape.t_fBot == IShape.t_fTop) // doubly symmetric
{
DoublySymmetricIBeam dsBeam = new DoublySymmetricIBeam(SectionI, Log, compressionFiberPosition, IsRolledMember);
beam = dsBeam.GetBeamCase();
}
else
{
SinglySymmetricIBeam ssBeam = new SinglySymmetricIBeam(SectionI, IsRolledMember, compressionFiberPosition, Log);
beam = ssBeam.GetBeamCase();
}
}
else if (Shape is ISolidShape)
{
ISolidShape solidShape = Shape as ISolidShape;
SteelSolidSection SectionSolid = new SteelSolidSection(solidShape, Material);
beam = new BeamSolid(SectionSolid, Log, MomentAxis);
}
else if (Shape is ISectionChannel)
{
ISectionChannel ChannelShape = Shape as ISectionChannel;
SteelChannelSection ChannelSection = new SteelChannelSection(ChannelShape, Material);
beam = new BeamChannel(ChannelSection, IsRolledMember, Log);
IShapeCompactness compactness = new ShapeCompactness.ChannelMember(ChannelSection, IsRolledMember, compressionFiberPosition);
CompactnessClassFlexure flangeCompactness = compactness.GetFlangeCompactnessFlexure();
CompactnessClassFlexure webCompactness = compactness.GetWebCompactnessFlexure();
if (flangeCompactness != CompactnessClassFlexure.Compact || webCompactness != CompactnessClassFlexure.Compact)
{
throw new Exception("Channels with non-compact and slender flanges or webs are not supported. Revise input.");
}
}
else if (Shape is ISectionPipe)
{
ISectionPipe SectionPipe = Shape as ISectionPipe;
SteelPipeSection PipeSection = new SteelPipeSection(SectionPipe, Material);
beam = new BeamCircularHss(PipeSection, Log);
}
else if (Shape is ISectionTube)
{
ISectionTube TubeShape = Shape as ISectionTube;
SteelRhsSection RectHSS_Section = new SteelRhsSection(TubeShape, Material);
beam = new BeamRectangularHss(RectHSS_Section, compressionFiberPosition, MomentAxis, Log);
}
else if (Shape is ISectionBox)
{
ISectionBox BoxShape = Shape as ISectionBox;
SteelBoxSection BoxSection = new SteelBoxSection(BoxShape, Material);
beam = new BeamRectangularHss(BoxSection, compressionFiberPosition, MomentAxis, Log);
}
else if (Shape is ISectionTee)
{
ISectionTee TeeShape = Shape as ISectionTee;
SteelTeeSection TeeSection = new SteelTeeSection(TeeShape, Material);
beam = new BeamTee(TeeSection, Log);
}
else if (Shape is ISectionAngle)
{
ISectionAngle Angle = Shape as ISectionAngle;
SteelAngleSection AngleSection = new SteelAngleSection(Angle, Material);
beam = new BeamAngle(AngleSection, Log, Angle.AngleRotation, MomentAxis, Angle.AngleOrientation);
}
else if (Shape is ISolidShape)
{
ISolidShape SolidShape = Shape as ISolidShape;
SteelSolidSection SolidSection = new SteelSolidSection(SolidShape, Material);
beam = new BeamSolid(SolidSection, Log, MomentAxis);
}
else
{
throw new Exception("Specified section type is not supported for this node.");
}
}
else // weak axis
{
if (Shape is ISectionI)
{
ISectionI IShape = Shape as ISectionI;
SteelSectionI SectionI = new SteelSectionI(IShape, Material);
beam = new BeamIWeakAxis(SectionI, IsRolledMember, Log);
}
else
{
throw new NotImplementedException();
}
}
return(beam);
}
public double GetCompressionFlangeLocalBucklingCapacity()
{
// compactness criteria is selected by the most slender flange
double Mn = 0;
ShapeCompactness.IShapeMember compactnessTop = new ShapeCompactness.IShapeMember(Section, IsRolledMember, FlexuralCompressionFiberPosition.Top);
CompactnessClassFlexure flangeCompactnessTop = compactnessTop.GetFlangeCompactnessFlexure();
ShapeCompactness.IShapeMember compactnessBot = new ShapeCompactness.IShapeMember(Section, IsRolledMember, FlexuralCompressionFiberPosition.Top);
CompactnessClassFlexure flangeCompactnessBot = compactnessTop.GetFlangeCompactnessFlexure();
double lambda = 0.0;
double lambdaTop = compactnessTop.GetCompressionFlangeLambda();
double lambdaBot = compactnessBot.GetCompressionFlangeLambda();
CompactnessClassFlexure flangeCompactness;
ShapeCompactness.IShapeMember compactness;
double b = 0;
double tf = 0.0;
if (lambdaTop > lambdaBot)
{
compactness = compactnessTop;
flangeCompactness = flangeCompactnessTop;
lambda = lambdaTop;
b = GetBfTop();
tf = Get_tfTop();
}
else
{
compactness = compactnessBot;
flangeCompactness = flangeCompactnessBot;
lambda = lambdaBot;
b = GetBfBottom();
tf = Get_tfBottom();
}
double Mp = Zy * Fy;
double lambdapf = compactness.GetFlangeLambda_p(StressType.Flexure);
double lambdarf = compactness.GetFlangeLambda_r(StressType.Flexure);
switch (flangeCompactness)
{
case CompactnessClassFlexure.Compact:
Mn = double.PositiveInfinity;
break;
case CompactnessClassFlexure.Noncompact:
Mn = Mp - (Mp - 0.7 * Fy * Sy) * ((lambda - lambdapf) / (lambdarf - lambdapf)); //(F6-2)
break;
case CompactnessClassFlexure.Slender:
double Fcr = 0.69 * E / Math.Pow(b / tf, 2.0); //(F6-4)
Mn = Fcr * Sy; //(F6-3)
break;
}
double phiM_n = 0.9 * Mn;
return(phiM_n);
}
