public double GetLambdaCompressionFlange(FlexuralCompressionFiberPosition compressionFiberPosition)
        {

             compactness = new ShapeCompactness.IShapeMember
        (this.Section, this.isRolledMember, compressionFiberPosition);
            return compactness.GetCompressionFlangeLambda();
        }
Exemple #2
0
        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;
        }
Exemple #3
0
        //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;
        }