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;
        }
Exemple #2
0
        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;
        }
Exemple #3
0
        public override SteelLimitStateValue GetFlexuralBucklingStrength()
        {
            double FcrFlex = CalculateCriticalStress();
            double phiP_n = GetDesignAxialStrength(FcrFlex);

            SteelLimitStateValue ls = new SteelLimitStateValue(phiP_n, true);
            return ls;
        }
Exemple #4
0
        public override SteelLimitStateValue GetFlexuralBucklingStrength()
        {

            double FeFlexuralBuckling = GetFlexuralElasticBucklingStressFe(); 
            double FcrFlexuralBuckling = GetCriticalStressFcr(FeFlexuralBuckling, 1.0);
            double Qflex = GetReductionFactorQ(FcrFlexuralBuckling);
            double FcrFlex = GetCriticalStressFcr(FeFlexuralBuckling, Qflex);

            double phiP_n = GetDesignAxialStrength(FcrFlex);
            SteelLimitStateValue ls = new SteelLimitStateValue(phiP_n, true);
            return ls;
        }
Exemple #5
0
        //Yielding F7.1
        public  SteelLimitStateValue GetMajorPlasticMomentStrength()
        {
            SteelLimitStateValue ls = new SteelLimitStateValue();
            double M_p = GetMajorNominalPlasticMoment();

            double phiM_n = 0.9 * M_p;


            ls.IsApplicable = true;
            ls.Value = phiM_n;
            return ls;
        }
Exemple #6
0
 public override SteelLimitStateValue GetFlexuralLateralTorsionalBucklingStrength(double C_b, double L_b, FlexuralCompressionFiberPosition CompressionLocation,
     FlexuralAndTorsionalBracingType BracingType)
 {
     SteelLimitStateValue ls;
     if (BracingType == FlexuralAndTorsionalBracingType.FullLateralBracing)
     {
         ls = new SteelLimitStateValue(-1, false);
     }
     else
     {
         double phiM_n = GetLateralTorsionalBucklingStrength(CompressionLocation,L_b, C_b);
         ls = new SteelLimitStateValue(phiM_n, true);
     }
     return ls;
 }
Exemple #7
0
        //Yielding
        public  SteelLimitStateValue GetMinorPlasticMomentStrength()
        {
            SteelLimitStateValue ls = new SteelLimitStateValue();
            double phiM_n = 0.0;
            double Mp = GetMinorNominalPlasticMoment();
            double My = 1.6 * Fy * Sy;
            


            double M_n = Math.Min(Mp, My); //(F6-1)
            phiM_n = 0.9*M_n;

            ls.IsApplicable = true;
            ls.Value = M_n;
            return ls;
        }
        public virtual SteelLimitStateValue GetFlexuralFlangeLocalBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation)
        {

            SteelLimitStateValue ls = new SteelLimitStateValue();
            

            if (FlangeCompactnessClass == CompactnessClassFlexure.Compact)
            {
                ls = new SteelLimitStateValue(-1, false);
            }
            else
            {
                double phiM_n = GetCompressionFlangeLocalBucklingCapacity(CompressionLocation, MomentAxis);
                ls = new SteelLimitStateValue(phiM_n, true);
            }


            return ls;
        }
Exemple #9
0
        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 override SteelLimitStateValue GetFlexuralLateralTorsionalBucklingStrength(double C_b, double L_b, FlexuralCompressionFiberPosition CompressionLocation,
            FlexuralAndTorsionalBracingType BracingType)
        {
            if (SectionValuesWereCalculated == false)
            {
                GetSectionValues();
            }

            SteelLimitStateValue ls;
            if (BracingType == FlexuralAndTorsionalBracingType.FullLateralBracing)
            {
                ls = new SteelLimitStateValue(-1, false);
            }
            else
            {
                double phiM_n = GetFlexuralTorsionalBucklingMomentCapacity(L_b, C_b);
                ls = new SteelLimitStateValue(phiM_n, true);
            }
            return ls;
        }
Exemple #11
0
        public SteelLimitStateValue GetPlasticMomentCapacity(MomentAxis MomentAxis)

        {
            SteelLimitStateValue ls = new SteelLimitStateValue();
            double phiM_n;
            double M_n=0.0;
            switch (MomentAxis)
            {
                case MomentAxis.XAxis:
                    M_n = GetMajorNominalPlasticMoment();
                    break;
                case MomentAxis.YAxis:
                    M_n = GetMinorNominalPlasticMoment();
                    break;
                default:
                    throw new FlexuralBendingAxisException();
                    break;
           }
            phiM_n =0.9*M_n;
            ls.Value = phiM_n;
            ls.IsApplicable = true;
            return ls;
        }
Exemple #12
0
 public override SteelLimitStateValue GetLimitingLengthForFullYielding_Lp(FlexuralCompressionFiberPosition CompressionLocation)
 {
     double r_t = GetEffectiveRadiusOfGyration_r_t(CompressionLocation);
     double L_p = GetLp(r_t);
     SteelLimitStateValue ls = new SteelLimitStateValue(L_p, true);
     return ls;
 }
Exemple #13
0
 public virtual SteelLimitStateValue GetLimitingLengthForFullYielding_Lp(FlexuralCompressionFiberPosition CompressionLocation)
 {
     SteelLimitStateValue ls = new SteelLimitStateValue(-1, false);
     return ls;
 }
Exemple #14
0
 public virtual SteelLimitStateValue GetLimitingLengthForInelasticLTB_Lr(FlexuralCompressionFiberPosition CompressionLocation)
 {
     SteelLimitStateValue ls = new SteelLimitStateValue(-1, false);
     return ls;
 }
Exemple #15
0
 public virtual SteelLimitStateValue GetFlexuralLegOrStemBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation, 
     FlexuralAndTorsionalBracingType BracingType)
 {
     SteelLimitStateValue ls = new SteelLimitStateValue(-1, false);
     return ls;
 }
Exemple #16
0
 public virtual SteelLimitStateValue GetFlexuralWebOrWallBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation)
 {
     SteelLimitStateValue ls = new SteelLimitStateValue(-1, false);
     return ls;
 }
Exemple #17
0
 public virtual SteelLimitStateValue GetFlexuralTensionFlangeYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation)
 {
     SteelLimitStateValue ls = new SteelLimitStateValue(-1, false);
     return ls;
 }
        public override SteelLimitStateValue GetLimitingLengthForFullYielding_Lp(FlexuralCompressionFiberPosition CompressionLocation)
        {
            if (SectionValuesWereCalculated == false)
            {
                GetSectionValues();
            }
            double Lp = GetLp(r_y, E, F_y); //(F2-5)
            SteelLimitStateValue ls = new SteelLimitStateValue();
            ls.IsApplicable = true;
            ls.Value = Lp;


            return ls;

        }
 public virtual SteelLimitStateValue GetFlexuralFlangeLocalBucklingStrength(FlexuralCompressionFiberPosition CompressionLocation)
 {
    double phiM_n =GetCompressionFlangeLocalBucklingCapacity();
    SteelLimitStateValue ls = new SteelLimitStateValue(phiM_n, true);
    return ls;
 }
Exemple #20
0
       // This section applies to round HSS





        #region Limit States

        public virtual SteelLimitStateValue GetFlexuralYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation)
        {
            SteelLimitStateValue ls = new SteelLimitStateValue(GetYieldingMomentCapacity(), true);

            return ls;
        }
        public override SteelLimitStateValue GetLimitingLengthForInelasticLTB_Lr(FlexuralCompressionFiberPosition CompressionLocation)
        {
            if (SectionValuesWereCalculated == false)
            {
                GetSectionValues();
            }
            //double rts = Getrts(Iy, Cw, Sx);
            double Lr = GetLr(rts, E, F_y, S_x, J, c, ho);  // (F2-6)
            SteelLimitStateValue ls = new SteelLimitStateValue();
            ls.IsApplicable = true;
            ls.Value = Lr;

            return ls;
        }
Exemple #22
0
 public override SteelLimitStateValue GetLimitingLengthForInelasticLTB_Lr(FlexuralCompressionFiberPosition CompressionLocation)
 {
     double r_t = GetEffectiveRadiusOfGyration_r_t(CompressionLocation);
     double L_r = GetLr(r_t);
     SteelLimitStateValue ls = new SteelLimitStateValue(L_r, true);
     return ls;
 }
Exemple #23
0
        public override SteelLimitStateValue GetFlexuralLateralTorsionalBucklingStrength(double C_b, double L_b, FlexuralCompressionFiberPosition CompressionLocation,
            FlexuralAndTorsionalBracingType BracingType)
        {
            SteelLimitStateValue ls = null;
            double b, h;

            if (sectionSolid is ISectionRound)
            {
                ls = new SteelLimitStateValue();
                ls.IsApplicable = false;
                ls.Value = -1;
                return ls;
            }
            else if (sectionSolid is ISectionRectangular)
            {
                ISectionRectangular recangularShape = sectionSolid as ISectionRectangular;

                if (MomentAxis == Common.Entities.MomentAxis.XAxis)
                {
                    
                    b = recangularShape.B ;
                    h = recangularShape.H;


                }
                else if (MomentAxis == Common.Entities.MomentAxis.YAxis)
                {
                    b = recangularShape.H;
                    h = recangularShape.B;
                }

                else
                {
                    throw new FlexuralBendingAxisException();
                }

                
                if (b >= h)
                {
                    ls.IsApplicable = false;
                    ls.Value = -1;
                }
                else
                {
                    ls = GetLateralTorsionalBucklingStrength(L_b, C_b);
                }
            }
            else
            {
                throw new ShapeTypeNotSupportedException(" flexural calculation of solid-shape beam");
            }
            return ls;
        }
Exemple #24
0
    //This section applies to doubly symmetric I-shaped members bent about their major
    //axis with noncompact webs and singly symmetric I-shaped members with webs
    //attached to the mid-width of the flanges, bent about their major axis, with compact
    //or noncompact webs, as defined in Section B4.1 for flexure.


        #region Limit States

        public override SteelLimitStateValue GetFlexuralYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation)
        {
            SteelLimitStateValue ls = new SteelLimitStateValue(-1, false);
            return ls;
        }
Exemple #25
0
 public override SteelLimitStateValue GetFlexuralTensionFlangeYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation)
 {
     SteelLimitStateValue ls = new SteelLimitStateValue();
     ls.IsApplicable = false;
     return ls;
 }
Exemple #26
0
 public override SteelLimitStateValue GetFlexuralCompressionFlangeYieldingStrength(FlexuralCompressionFiberPosition CompressionLocation)
 {
     double phiM_n = GetCompressionFlangeYieldingCapacity(CompressionLocation);
     SteelLimitStateValue ls = new SteelLimitStateValue(phiM_n, true);
     return ls;
 }
Exemple #27
0
        public override SteelLimitStateValue GetLimitingLengthForFullYielding_Lp(FlexuralCompressionFiberPosition CompressionLocation)
        {
            SteelLimitStateValue ls = new SteelLimitStateValue();

            if (this.Section.Shape is ISectionRectangular)
            {
                ISectionRectangular rectSection = this.Section.Shape as ISectionRectangular;
                double E = this.Section.Material.ModulusOfElasticity;
                double Fy = this.Section.Material.YieldStress;
                double d = rectSection.H;
                double t = rectSection.B;
                double Lp = GetL_p();
                ls.IsApplicable = true; ls.Value = Lp;
            }
            else
            {
                ls.Value = double.PositiveInfinity; ls.IsApplicable = false;
            }
            return ls;
        }