protected override LinearStrainDistribution GetInitialStrainEstimate(FlexuralCompressionFiberPosition CompressionFiberPosition) { currentCompressionFiberPosition = CompressionFiberPosition; //store this off for getting iteration limits double StrainDistributionHeight = GetStrainDistributionHeight(CompressionFiberPosition); double c = StrainDistributionHeight * 0.6; //this is AASHTO criteria for when it's OK to use assumption that //mild rebar yields, beyond that need to use strain compatibility double epsilon_c = StrainUltimateConcrete.Value; double epsilon_s = epsilon_c - (epsilon_c / c) * StrainDistributionHeight; LinearStrainDistribution strainDistribution = null; switch (CompressionFiberPosition) { case FlexuralCompressionFiberPosition.Top: strainDistribution = new LinearStrainDistribution(StrainDistributionHeight, epsilon_c, epsilon_s); break; case FlexuralCompressionFiberPosition.Bottom: strainDistribution = new LinearStrainDistribution(StrainDistributionHeight, epsilon_s, epsilon_c); break; default: throw new CompressionFiberPositionException(); } return strainDistribution; }
public virtual SteelLimitStateValue GetFlexuralYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation) { double phiM_n = GetYieldingMomentCapacity(CompressionLocation); SteelLimitStateValue ls = new SteelLimitStateValue(phiM_n, true); return(ls); }
public virtual SteelLimitStateValue GetFlexuralLegOrStemBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation, FlexuralAndTorsionalBracingType BracingType) { SteelLimitStateValue ls = new SteelLimitStateValue(-1, false); return(ls); }
public double GetWebLocalBucklingCapacity(MomentAxis MomentAxis, FlexuralCompressionFiberPosition CompressionLocation) { double M_n = 0.0; double S; double Mp; if (MomentAxis ==MomentAxis.XAxis) { Mp = GetMajorNominalPlasticMoment(); S = Math.Min(Section.Shape.S_yLeft, Section.Shape.S_yRight); } else if (MomentAxis == MomentAxis.YAxis) { Mp = GetMinorNominalPlasticMoment(); S = Math.Min(Section.Shape.S_xTop, Section.Shape.S_xBot); } else { throw new FlexuralBendingAxisException(); } double lambdaWeb = GetLambdaWeb(CompressionLocation,MomentAxis); M_n = Mp - (Mp - Fy * S) * (0.305 * lambdaWeb * Math.Sqrt(Fy / E) - 0.738); //(F7-5) M_n = M_n > Mp ? Mp : M_n; double phiM_n = 0.9 * M_n; 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; }
protected double GetCompressionBlockDepth(double RebarResultant, FlexuralCompressionFiberPosition CompressionFiberPosition) { double fc = Section.Material.SpecifiedCompressiveStrength; double RequiredConcreteArea = 0; IMoveableSection compressedSection = null; switch (CompressionFiberPosition) { case FlexuralCompressionFiberPosition.Top: RequiredConcreteArea = RebarResultant / (0.85 * fc); compressedSection = this.Section.SliceableShape.GetTopSliceOfArea(RequiredConcreteArea); break; case FlexuralCompressionFiberPosition.Bottom: RequiredConcreteArea = RebarResultant / (0.85 * fc); compressedSection = this.Section.SliceableShape.GetBottomSliceOfArea(RequiredConcreteArea); break; default: throw new CompressionFiberPositionException(); } //Get corresponding strain double a = compressedSection.YMax - compressedSection.YMin; return a; }
public SinglySymmetricIBeam(ISteelSection section, bool IsRolledMember, FlexuralCompressionFiberPosition compressionFiberPosition, ICalcLog CalcLog) { this.section = section; this.IsRolledMember = IsRolledMember; this.CalcLog = CalcLog; this.compressionFiberPosition = compressionFiberPosition; }
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); }
protected ForceMomentContribution GetRebarResultant(LinearStrainDistribution StrainDistribution, ResultantType resType , FlexuralCompressionFiberPosition p) { ForceMomentContribution resultant = new ForceMomentContribution(); //tension is negative List <RebarPointResult> RebarResults = CalculateRebarResults(StrainDistribution, p); foreach (var barResult in RebarResults) { if (resType == ResultantType.Tension) { if (barResult.Strain < 0) { resultant.Force += barResult.Force; resultant.Moment += barResult.Force * barResult.DistanceToNeutralAxis; } } else { if (barResult.Strain > 0) { resultant.Force += barResult.Force; resultant.Moment += barResult.Force * barResult.DistanceToNeutralAxis; } } } resultant.RebarResults = RebarResults; return(resultant); }
public PlateProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI, ISectionRectangular plate, FlexuralCompressionFiberPosition compressionFiberPosition) : base(Material, SectionI, compressionFiberPosition) { this.plate = plate; }
private LinearStrainDistribution GetStrainMaxTensionMaxCompression(FlexuralCompressionFiberPosition CompressionFiberPosition) { //Calulate limit strain for the lowest rebar point //Distinguish between top and bottom tension cases double StrainDistributionHeight = 0.0; //double MaxStrain = CalculateMaximumSteelStrain(CompressionFiberPosition); double MaxStrain = this.MaxSteelStrain; LinearStrainDistribution MaxMaxDistribution; StrainDistributionHeight = GetStrainDistributionHeight(CompressionFiberPosition); if (CompressionFiberPosition == FlexuralCompressionFiberPosition.Top) { var LowestPointY = LongitudinalBars.Min(yVal => yVal.Coordinate.Y); var PointsAtLowestY = LongitudinalBars.Where(point => point.Coordinate.Y == LowestPointY).Select(point => point); var LimitStrain = PointsAtLowestY.Min(point => point.Rebar.Material.GetUltimateStrain(point.Rebar.Diameter)); MaxStrain = LimitStrain; MaxMaxDistribution = new LinearStrainDistribution (StrainDistributionHeight, this.MaxConcreteStrain, -MaxStrain); } else { var HighestPointY = LongitudinalBars.Max(yVal => yVal.Coordinate.Y); var PointsAtHighestY = LongitudinalBars.Where(point => point.Coordinate.Y == HighestPointY).Select(point => point); var LimitStrain = PointsAtHighestY.Min(point => point.Rebar.Material.GetUltimateStrain(point.Rebar.Diameter)); MaxStrain = LimitStrain; MaxMaxDistribution = new LinearStrainDistribution (StrainDistributionHeight, -MaxStrain, this.MaxConcreteStrain); } return MaxMaxDistribution; }
public FlangeOfBuiltUpI(ISteelMaterial Material, ISectionI s, FlexuralCompressionFiberPosition compressionFiberPosition) :base(Material) { this.section = s; double bf=0; double tf=0; switch (compressionFiberPosition) { case FlexuralCompressionFiberPosition.Top: bf = s.b_fTop; tf = s.t_fTop; break; case FlexuralCompressionFiberPosition.Bottom: bf = s.b_fTop; tf = s.t_fTop; break; default: throw new Exception("Compression fiber location different from to or bottom is not supported"); } base.Overhang = bf; base.Thickness = tf; }
public double Gethc(FlexuralCompressionFiberPosition compressionFiberPosition) { //hc - Twice the distance from the center of gravity to the following: //the inside face of the compression flange less the fillet or corner //radius, for rolled shapes; the nearest line of fasteners at the //compression flange or the inside faces of the compression flange //when welds are used, for built-up sections, in. (mm) B4.1 (b) double hc = 0.0; double k = Getk(); double dsection = GetHeight(); double yCentroid = Section.Shape.y_Bar; switch (compressionFiberPosition) { case FlexuralCompressionFiberPosition.Top: double tfTop = Get_tfTop(); hc = 2.0 * (dsection - yCentroid - tfTop - k); break; case FlexuralCompressionFiberPosition.Bottom: double tfBot = Get_tfBottom(); hc = 2.0 * (yCentroid - tfBot - k); break; default: throw new Exception("Compression Flange not defined for I-shape and Channel weak axis bending"); } return hc; }
public AngleLegProjectedFromBuiltUpIShape(ISteelMaterial Material, ISectionI SectionI, ISectionAngle angle, FlexuralCompressionFiberPosition compressionFiberPosition) : base(Material, SectionI, compressionFiberPosition) { this.angle = angle; }
public ChannelMember(ISteelSection Section, bool IsRolledShape, FlexuralCompressionFiberPosition compressionFiberPosition) { double b; double tf; if (Section.Shape is ISectionChannel) { ISectionChannel sectChannel = Section.Shape as ISectionChannel; switch (compressionFiberPosition) { case FlexuralCompressionFiberPosition.Top: b = sectChannel.b_f; tf = sectChannel.t_f; break; case FlexuralCompressionFiberPosition.Bottom: b = sectChannel.b_f; tf = sectChannel.t_f; break; default: throw new CompressionFiberPositionException(); } //flange compactness FlangeCompactness = new FlangeOfChannel(Section.Material, b / 2.0, tf); //web compactness WebCompactness = new WebOfChannel(Section.Material, sectChannel); } }
public bool CheckAllowableMoment(FlexuralCompressionFiberPosition CompressionFiberPosition, double ExternalMoment, StageType Stage, LoadType LoadType) { double fct = GetAllowableTension(Stage); double fcc = GetAllowableCompression(Stage, LoadType); double M = Math.Abs(ExternalMoment); double e = GetPrestressingForceEccentricityAtTransfer(); double P = Math.Abs(GetPrestressForceAtTransfer()); double ft = getTopStress(P, e, ExternalMoment, CompressionFiberPosition); double fb = getBottomStress(P, e, ExternalMoment, CompressionFiberPosition); double MaxPosForce = Math.Max(ft, fb); //positive is for compression double MaxNegForce = Math.Min(ft, fb); //positive is for compression if (MaxPosForce <= fcc && MaxNegForce >= -fct) { return(true); } else { return(false); } }
public double GetLambdaCompressionFlange(FlexuralCompressionFiberPosition compressionFiberPosition) { compactness = new ShapeCompactness.IShapeMember (this.Section, this.isRolledMember, compressionFiberPosition); return compactness.GetCompressionFlangeLambda(); }
public double getMaximumAllowableMoment(FlexuralCompressionFiberPosition CompressionFiberPosition, StageType Stage, LoadType LoadType) { double e = GetPrestressingForceEccentricityAtTransfer(); double P = Math.Abs(GetPrestressForceAtTransfer()); double A = this.Section.SliceableShape.A; double Sb = this.Section.SliceableShape.S_xBot; double St = this.Section.SliceableShape.S_xTop; double Mcomp = 0; double Mtens = 0; double fct = GetAllowableTension(Stage); double fcc = GetAllowableCompression(Stage, LoadType); switch (CompressionFiberPosition) { case FlexuralCompressionFiberPosition.Top: Mcomp = (fcc - P / A - (P * e) / St) * St; Mtens = (fct + P / A - (P * e) / Sb) * Sb; break; case FlexuralCompressionFiberPosition.Bottom: Mcomp = (fcc - P / A + (P * e) / Sb) * Sb; Mtens = (fct + P / A + (P * e) / St) * St; break; default: throw new CompressionFiberPositionException(); } return(Math.Min(Mcomp, Mtens)); }
internal double GetCriticalStressFcr(FlexuralCompressionFiberPosition compressionFiberLocation) { double Fcr; Fy = this.Section.Material.YieldStress; double lambdaStem = GetLambdaStem(); if (lambdaStem > 0.84 * SqrtE_Fy()) { if (lambdaStem<1.03*SqrtE_Fy()) { //(F9-10) Fcr = (2.55 - 1.84 * lambdaStem * Math.Sqrt(Fy / E)) * Fy; } else { //(F9-11) Fcr = 0.69 * E / Math.Pow(lambdaStem, 2); } } else { Fcr = Fy; //(F9-9) } return Fcr; }
public double GetWebPlastificationFactorForTensionRpt(FlexuralCompressionFiberPosition compressionFiberPosition) { double Rpt = 0.0; double Mp = GetMajorNominalPlasticMoment(); double Myt = GetTensionFiberYieldMomentMyt(compressionFiberPosition); double hc = Gethc(compressionFiberPosition); double tw = this.Gettw(); ShapeCompactness.IShapeMember compactness = new ShapeCompactness.IShapeMember(Section, IsRolledMember, compressionFiberPosition); double lambdaWeb = compactness.GetWebLambda(); double lambdapw = compactness.GetWebLambda_p(StressType.Flexure); double lambdarw = compactness.GetWebLambda_r(StressType.Flexure); //double lambda = hc / tw; double lambda = compactness.GetWebLambda(); if (lambda <= lambdapw) { Rpt = Mp / Myt; //(F4-16a) } else { Rpt = Mp / Myt - (Mp / Myt - 1) * ((lambda - lambdapw) / (lambdarw - lambdapw)); //(F4-16b) } return Rpt; }
public double GetEffectiveRadiusOfGyration_r_t( FlexuralCompressionFiberPosition compressionFiberPosition) { //todo: add alternative calc // For I-shapes with a channel cap or a cover plate attached to the compression flange are not covered double rt = 0.0; double ho = 0.0; double bfc = 0.0; double tfc = 0.0; double h = 0.0; double hc = 0.0; double aw = 0.0; double tw = 0.0; double d = 0; ho = this.GetFlangeCentroidDistanceho(); bfc = this.GetCompressionFlangeWidthbfc(compressionFiberPosition); h = SectionI.h_web; hc = Gethc(compressionFiberPosition); tfc = GetCompressionFlangeThicknesstfc(compressionFiberPosition); tw = this.Gettw(); aw = Getaw(hc, tw, bfc, tfc); d = this.GetHeight();//confirm .... rt = bfc / (Math.Sqrt(12.0 * (ho / d + 1 / 6.0 * aw * Math.Pow(h, 2) / (ho * d)))); //(F4-11) return rt; }
private double GetYieldingMomentGeometricXCapacity(FlexuralCompressionFiberPosition compressionFiberLocation, FlexuralAndTorsionalBracingType BracingType) { double S_x = GetSectionModulus(compressionFiberLocation, false, BracingType); double Fy = Section.Material.YieldStress; double My = S_x * Fy; return My; }
private double GetFlexuralTorsionalBucklingMomentCapacity(double L_b, double C_b, FlexuralCompressionFiberPosition CompressionLocation, FlexuralAndTorsionalBracingType BracingType, MomentAxis MomentAxis) { double M_n = 0.0; double M_n1 = 0.0; double M_n2 = 0.0; double M_e = GetM_e(L_b, C_b, CompressionLocation, BracingType, MomentAxis); double M_y = GetYieldingMomentGeometricXCapacity(CompressionLocation, BracingType); if (M_e<=M_y) { //F10-2 M_n1=(0.92-((0.17*M_e) / (M_y)))*M_e; } else { //F10-3 M_n1=(1.92-1.17*Math.Sqrt(((M_y) / (M_e))))*M_y; } M_n2 = 1.5*M_y; M_n= Math.Min(M_n1,M_n2); double phiM_n = 0.9 * M_n; return phiM_n; }
public BeamRectangularHss(ISteelSection section, FlexuralCompressionFiberPosition compressionFiberPosition, MomentAxis MomentAxis, ICalcLog CalcLog) : base(section, CalcLog) { GetSectionValues(); this.MomentAxis = MomentAxis; FlangeCompactnessClass = GetFlangeCompactness(compressionFiberPosition, MomentAxis); }
public IStrainCompatibilityAnalysisResult GetNominalMomentResult(double P_u, FlexuralCompressionFiberPosition CompressionFiberPosition) { double MaxSteelStrain = CalculateMaximumSteelStrain(CompressionFiberPosition); SectionAnalysisResult IteratedResult = FindMomentResultInPresenceOfAxialForce(CompressionFiberPosition, P_u, MaxSteelStrain); IStrainCompatibilityAnalysisResult result = GetResult(IteratedResult); return result; }
public WebOfSinglySymI(ISteelMaterial Material, ISectionI SectionI, FlexuralCompressionFiberPosition compressionFiberPosition) :base(Material,SectionI) { this.SectionI = SectionI; this.compressionFiberPosition = compressionFiberPosition; }
private double GetYieldingMoment_My(FlexuralCompressionFiberPosition compressionFiberLocation) { double Sxt = GetSectionModulusTensionSxt(compressionFiberLocation); double Sxc = GetSectionModulusCompressionSxc(compressionFiberLocation); double Sx = Math.Min(Sxc, Sxt); double Fy = Section.Material.YieldStress; double My = Sx * Fy; return My; }
// Compression Flange Yielding F4.1 public double GetCompressionFlangeYieldingCapacity(FlexuralCompressionFiberPosition compressionFiberPosition) { double Mn = 0.0; double Myc = GetCompressionFiberYieldMomentMyc(compressionFiberPosition); double Rpc = GetRpc(compressionFiberPosition); Mn = Rpc * Myc; //(F4-1) double phiM_n = 0.9 * Mn; return phiM_n; }
public override SteelLimitStateValue GetFlexuralYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation) { if (SectionValuesWereCalculated == false) { GetSectionValues(); } double M_n= GetMajorNominalPlasticMoment(); double phiM_n = 0.9 * M_n; return new SteelLimitStateValue(phiM_n, true); }
private double FindCrackedSectionNeutralAxis(FlexuralCompressionFiberPosition compFiberPosition) { double targetDelta = 0.0; double CompressedBlockMin = 0.0; double CompressedBlockMax = this.Section.SliceableShape.YMax - this.Section.SliceableShape.YMin; currentCompressionFiberPosition = compFiberPosition; //store this off because it will be necessary during iteration double ConvergenceTolerance = 0.0001; double kd = RootFinding.Brent(new FunctionOfOneVariable(DeltaA_times_Y), CompressedBlockMin, CompressedBlockMax, ConvergenceTolerance, targetDelta); return kd; }
// Compression Flange Yielding F5.1 public double GetCompressionFlangeYieldingCapacity(FlexuralCompressionFiberPosition compressionFiberPosition) { double Mn = 0.0; double Sxc = compressionFiberPosition == FlexuralCompressionFiberPosition.Top ? Sxtop : Sxbot; Rpg = GetRpg(compressionFiberPosition); Mn = Rpg * Sxc*Fy; //(F5-1) double phiM_n = 0.9 * Mn; return phiM_n; }
public IShapeMember(ISteelSection Section, bool IsRolledShape, FlexuralCompressionFiberPosition compressionFiberPosition) { double b; double tf; if (Section.Shape is ISectionI) { ISectionI sectI = Section.Shape as ISectionI; switch (compressionFiberPosition) { case FlexuralCompressionFiberPosition.Top: b = sectI.b_fTop; tf = sectI.t_fTop; break; case FlexuralCompressionFiberPosition.Bottom: b = sectI.b_fBot; tf = sectI.t_fBot; break; default: throw new CompressionFiberPositionException(); } //flange compactness if (IsRolledShape == true) { this.FlangeCompactness = new FlangeOfRolledIShape(Section.Material, b / 2.0, tf); } else { this.FlangeCompactness = new FlangeOfBuiltUpI(Section.Material, sectI, compressionFiberPosition); } //web compactness bool isDoublySymmetric = ShapeISymmetry.IsDoublySymmetric(Section.Shape); if (isDoublySymmetric == true) { WebCompactness = new WebOfDoublySymI(Section.Material, sectI); } else { WebCompactness = new WebOfSinglySymI(Section.Material, sectI, compressionFiberPosition); } } }
public ConcreteFlexuralStrengthResult GetDesignFlexuralStrength(FlexuralCompressionFiberPosition FlexuralCompressionFiberPosition, ConfinementReinforcementType ConfinementReinforcementType) { IStrainCompatibilityAnalysisResult nominalResult = this.GetNominalFlexuralCapacity(FlexuralCompressionFiberPosition); ConcreteFlexuralStrengthResult result = new ConcreteFlexuralStrengthResult(nominalResult, FlexuralCompressionFiberPosition, this.Section.Material.beta1); StrengthReductionFactorFactory f = new StrengthReductionFactorFactory(); FlexuralFailureModeClassification failureMode = f.GetFlexuralFailureMode(result.epsilon_t, result.epsilon_ty); double phi = f.Get_phiFlexureAndAxial(failureMode, ConfinementReinforcementType, result.epsilon_t, result.epsilon_ty); double phiM_n = phi * nominalResult.Moment; result.phiM_n = phiM_n; result.FlexuralFailureModeClassification = failureMode; return result; }
internal double GetCompressionFiberYieldMomentMyc(FlexuralCompressionFiberPosition compressionFiberPosition) { double Myc = 0.0; double Sxc = 0.0; double Fy = Section.Material.YieldStress; Sxc = GetSectionModulusCompressionSxc( compressionFiberPosition); Myc = Fy * Sxc; return Myc; }
//ICompactnessElement FlangeCompactness; //ICompactnessElement WebCompactness; public HollowMember(ISteelSection section, FlexuralCompressionFiberPosition compressionFiberPosition, MomentAxis MomentAxis) { ISection Section = section.Shape; if (Section is ISectionTube|| Section is ISectionPipe || Section is ISectionBox) { if (Section is ISectionTube) { ISectionTube tube = Section as ISectionTube; if (MomentAxis == MomentAxis.XAxis) { FlangeCompactness = new FlangeOfRhs(section.Material, tube, MomentAxis); WebCompactness = new WebOfRhs(section.Material, tube, MomentAxis); } else { WebCompactness = new FlangeOfRhs(section.Material, tube, MomentAxis); FlangeCompactness = new WebOfRhs(section.Material, tube, MomentAxis); } } if (Section is ISectionPipe) { ISectionPipe pipe = Section as ISectionPipe; FlangeCompactness = new WallOfChs(section.Material, pipe); WebCompactness = new WallOfChs(section.Material, pipe); } if (Section is ISectionBox) { ISectionBox box = Section as ISectionBox; if (MomentAxis == MomentAxis.XAxis) { FlangeCompactness = new FlangeOfBox(section.Material, box); WebCompactness = new WebOfBox(section.Material, box); } else { WebCompactness = new FlangeOfBox(section.Material, box); FlangeCompactness = new WebOfBox(section.Material, box); } } } else { throw new SectionWrongTypeException("ISectionTube, ISectionPipe or ISectionBox"); } }
public double GetCrackingMoment( FlexuralCompressionFiberPosition compFiberPosition) { double f_r = this.Section.Material.ModulusOfRupture; //24.2.3.5b if (compFiberPosition == FlexuralCompressionFiberPosition.Top) { return this.Section.SliceableShape.S_xBot * f_r; } else { return Section.SliceableShape.S_xTop * f_r; } }