internal void GetSectionValues()
{
E = Section.Material.ModulusOfElasticity;
F_y = Section.Material.YieldStress;
ISectionAngle angle = this.Section.Shape as ISectionAngle;
if (angle == null)
{
throw new Exception("ISectionAngle type is required for this calculation.");
}
if (angle.d != angle.b) //unequal leg
{
IsEqualLeg = false;
}
else
{
IsEqualLeg = true;
}
b = angle.b;
d = angle.d;
t = angle.t;
r_z = angle.r_z;
I_z = angle.I_z;
beta_w = angle.beta_w;
Compactness = new ShapeCompactness.AngleMember(angle, Section.Material, this.AngleOrientation);
}
public override double GetReductionFactorForStiffenedElementQa(double Fcr)
{
ISectionAngle ang = this.Section.Shape as ISectionAngle;
double E = this.Section.Material.ModulusOfElasticity;
double F_y = this.Section.Material.YieldStress;
double b = Math.Min(ang.b, ang.d);
double t = ang.t;
double Q_s = 1.0;
//AISC specification page 16.1–42
if (((b) / (t)) <= 0.45 * Math.Sqrt(((E) / (F_y))))
{
Q_s = 1.0;
}
else
{
if (((b) / (t)) > 0.91 * Math.Sqrt(((E) / (F_y))))
{
Q_s = ((0.53 * E) / (F_y * (((b) / (t))) * (((b) / (t)))));
}
else
{
Q_s = 1.34 - 0.76 * (((b) / (t))) * Math.Sqrt(((F_y) / (E)));
}
}
return(Q_s);
}
public AngleLegProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI,
ISectionAngle angle,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI, compressionFiberPosition)
{
this.angle = angle;
}
protected virtual void SetCompactness(ISectionAngle ang, ISteelMaterial Material, AngleOrientation AngleOrientation)
{
double shortLeg;
double longLeg;
if (ang.d >= ang.b)
{
longLeg = ang.d;
shortLeg = ang.b;
}
else
{
longLeg = ang.b;
shortLeg = ang.d;
}
//make differentiation based on angle orientation
if (AngleOrientation == AngleOrientation.LongLegVertical)
{
FlangeCompactness = new LegOfSingleAngle(Material, shortLeg, ang.t);
WebCompactness = new LegOfSingleAngle(Material, longLeg, ang.t);
}
else
{
FlangeCompactness = new LegOfSingleAngle(Material, longLeg, ang.t);
WebCompactness = new LegOfSingleAngle(Material, shortLeg, ang.t);
}
}
protected virtual void SetCompactness(ISectionAngle ang, ISteelMaterial Material, AngleOrientation AngleOrientation)
{
double shortLeg;
double longLeg;
if (ang.d >= ang.b)
{
longLeg = ang.d;
shortLeg = ang.b;
}
else
{
longLeg = ang.b;
shortLeg = ang.d;
}
//make differentiation based on angle orientation
if (AngleOrientation == AngleOrientation.LongLegVertical)
{
FlangeCompactness = new LegOfSingleAngle(Material, shortLeg, ang.t);
WebCompactness = new LegOfSingleAngle(Material, longLeg, ang.t);
}
else
{
FlangeCompactness = new LegOfSingleAngle(Material, longLeg, ang.t);
WebCompactness = new LegOfSingleAngle(Material, shortLeg, ang.t);
}
}
public AngleLegProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI,
ISectionAngle angle,
FlexuralCompressionFiberPosition compressionFiberPosition)
: base(Material, SectionI, compressionFiberPosition)
{
this.angle = angle;
}
public override SteelLimitStateValue GetTorsionalAndFlexuralTorsionalBucklingStrength()
{
SteelLimitStateValue ls;
ISectionAngle a = this.Section.Shape as ISectionAngle;
if (a == null)
{
throw new Exception("Incorrect section type. Section must be of type ISectionAngle.");
}
if (Math.Max(a.b, a.d) / a.t <= 20.0)
{
ls = new SteelLimitStateValue(-1, false);
}
else
{
double FeTorsionalBuckling = GetTorsionalElasticBucklingStressFe();
double FcrTorsionalBuckling = GetCriticalStressFcr(FeTorsionalBuckling, 1.0);
double Qtors = GetReductionFactorQ(FcrTorsionalBuckling);
double FcrTors = GetCriticalStressFcr(FeTorsionalBuckling, Qtors);
double phiP_n = GetDesignAxialStrength(FcrTors);
ls = new SteelLimitStateValue(phiP_n, true);
}
return(ls);
}
public OutstandingLegOfAnglesWithContContact(ISteelMaterial Material, ISectionAngle s)
:base(Material)
{
double bf=s.b;
double tf=s.t;
base.Overhang = bf;
base.Thickness = tf;
}
public OutstandingLegOfAnglesWithContContact(ISteelMaterial Material, ISectionAngle s)
: base(Material)
{
double bf = s.b;
double tf = s.t;
base.Overhang = bf;
base.Thickness = tf;
}
protected override double GetSlendernessKLr(bool IsMajorAxis)
{
double K;
double L;
double r;
double KLrx;
double KLry;
double KLrz;
ISectionAngle a = this.Section.Shape as ISectionAngle;
if (a == null)
{
throw new Exception("Incorrect section type. Section must be of type ISectionAngle.");
}
KLrx = L_ex / a.r_x;
KLry = L_ey / a.r_y;
KLrz = L_ez / a.r_z;
List <double> KLrs = new List <double>()
{
KLrx, KLry, KLrz
};
//for major axis buckling "major" is considered only
//for geometric axis. The second case using r_z is always
//minor. This is because in most practical applications
//it is possible to reduce unbraced length in the angle
//geometric axii, but to ensure that principal axis bracing is
//provided at a skew angle is impractical.
if (IsMajorAxis == true)
{
double KLr1;
if (KLrx >= KLry)
{
return(Math.Min(KLrx, KLrz));
}
else
{
return(Math.Min(KLry, KLrz));
}
}
else
{
if (KLrx <= KLry)
{
return(Math.Min(KLrx, KLrz));
}
else
{
return(Math.Min(KLry, KLrz));
}
}
}
/// <summary>
/// Defines a set of rectangles for analysis with respect to
/// x-axis, each occupying full width of section.
/// </summary>
/// <returns>List of analysis rectangles</returns>
public override List <CompoundShapePart> GetCompoundRectangleXAxisList()
{
ISectionAngle a = angle;
List <CompoundShapePart> rectX = new List <CompoundShapePart>()
{
new CompoundShapePart(2 * a.t, a.d - a.t, new Point2D(a.t / 2.0, (a.d - a.t) / 2)),
new CompoundShapePart(2 * a.b, a.t, new Point2D(a.b / 2, a.t / 2)),
};
return(rectX);
}
/// <summary>
/// Defines a set of rectangles for analysis with respect to
/// y-axis, each occupying full height of section. The rectangles are rotated 90 deg.,
/// because internally the properties are calculated with respect to x-axis.
/// </summary>
/// <returns>List of analysis rectangles</returns>
public override List <CompoundShapePart> GetCompoundRectangleYAxisList()
{
ISectionAngle a = angle;
List <CompoundShapePart> rectY = new List <CompoundShapePart>()
{
new CompoundShapePart(a.t, a.b - a.t, new Point2D(0, (a.b - a.t) / 2 + gap / 2)),
new CompoundShapePart(a.d, a.t, new Point2D(0, a.t / 2.0 + gap / 2)),
new CompoundShapePart(a.d, a.t, new Point2D(0, -(a.t / 2.0 + gap / 2))),
new CompoundShapePart(a.t, a.b - a.t, new Point2D(0, -(a.b - a.t) / 2 + gap / 2)),
};
return(rectY);
}
public FlexuralMemberAngleBase(ISteelSection section, ICalcLog CalcLog, AngleOrientation AngleOrientation)
: base(section, CalcLog)
{
sectionAngle = null;
ISectionAngle s = Section.Shape as ISectionAngle;
if (s == null)
{
throw new SectionWrongTypeException(typeof(ISectionAngle));
}
else
{
sectionAngle = s;
compactness = new ShapeCompactness.AngleMember(s, section.Material, AngleOrientation);
}
}
public LegOfSingleAngle(ISteelMaterial Material, ISectionAngle angle, bool LongLegProjecting)
:base(Material)
{
this.angle = angle;
double VLeg = angle.d;
double HLeg = angle.b;
double LongLeg = Math.Max(VLeg, HLeg);
double ShortLeg = Math.Min(VLeg, HLeg);
if (LongLegProjecting==true)
{
Overhang = LongLeg;
}
else
{
Overhang = ShortLeg;
}
base.Overhang = Overhang;
base.Thickness = angle.t;
}
public LegOfSingleAngle(ISteelMaterial Material, ISectionAngle angle, bool LongLegProjecting)
: base(Material)
{
this.angle = angle;
double VLeg = angle.d;
double HLeg = angle.b;
double LongLeg = Math.Max(VLeg, HLeg);
double ShortLeg = Math.Min(VLeg, HLeg);
if (LongLegProjecting == true)
{
Overhang = LongLeg;
}
else
{
Overhang = ShortLeg;
}
base.Overhang = Overhang;
base.Thickness = angle.t;
}
}
public LegOfDoubleAngleWithSeparation(ISteelMaterial Material, ISectionAngle angle, bool LongLegProjecting)
:base( Material, angle, LongLegProjecting)
public AngleMember(ISectionAngle Section, ISteelMaterial Material, AngleOrientation AngleOrientation)
{
SetCompactness( Section, Material, AngleOrientation);
}
public AngleMember(ISectionAngle Section, ISteelMaterial Material, AngleOrientation AngleOrientation)
{
SetCompactness(Section, Material, AngleOrientation);
}
public SteelAngleSection(ISectionAngle Section, ISteelMaterial Material)
:base(Material)
{
this.section = Section;
}
public LegOfDoubleAngleWithSeparation(ISteelMaterial Material, ISectionAngle angle, bool LongLegProjecting)
: base(Material, angle, LongLegProjecting)
{
}
public SteelAngleSection(ISectionAngle Section, ISteelMaterial Material)
: base(Material)
{
this.section = Section;
}
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);
}
