public static Dictionary<string, object> XAxisProperties(CustomProfile Shape)
        {
            //Default values
            double x_e = 0;
            double x_p = 0;
            double I_x = 0;
            double Z_x = 0;
            double S_xBot = 0;
            double S_xTop = 0;
            double r_x = 0;
            double A = 0;


            x_e = Shape.Section.x_Bar;
            x_p = Shape.Section.x_pBar;
            I_x = Shape.Section.I_x;
            Z_x = Shape.Section.Z_x;
            S_xBot = Shape.Section.S_xBot;
            S_xTop = Shape.Section.S_xTop;
            r_x = Shape.Section.r_x;
            A = Shape.Section.A;

            return new Dictionary<string, object>
            {
            { "x_e", x_e }
            ,{ "x_p", x_p }
            ,{ "I_x", I_x }
            ,{ "Z_x", Z_x }
            ,{ "S_xBot", S_xBot }
            ,{ "S_xTop", S_xTop }
            ,{ "r_x", r_x }
            ,{ "A", A }
            };
            }
        public static Dictionary<string, object> CompositeIBeamWebOpeningShearStrength(CustomProfile IShape,double b_eff,double h_solid,double h_rib,
            double F_y, double fc_prime, double N_anchors, double Q_n, double N_o, double a_o, double h_op, double e_op, double t_r, double b_r, 
            string HeadedAnchorDeckCondition ="Perpendicular", double w_rMin=4.0, double s_r=12.0, bool IsSingleSideReinforcement = true)
        {
            //Default values
            double phiV_n = 0;


            //Calculation logic:
            ISectionI sectionI = IShape.Section as ISectionI;
            if (sectionI == null)
            {
                throw new Exception("Specified shape type is not supported. Provide I-shape object as inputparameter");
            }

            DeckAtBeamCondition deckCondition;
            bool IsValidHeadedAnchorDeckCondition = Enum.TryParse(HeadedAnchorDeckCondition, true, out deckCondition);
            if (IsValidHeadedAnchorDeckCondition == false)
            {

                throw new Exception("Headed anchor position and group factor calculation failed. Invalid string provided for HeadedAnchorDeckCondition.");
            }

            CompositeIBeamWebOpening op = new CompositeIBeamWebOpening(sectionI, b_eff, h_solid, h_rib, F_y, fc_prime, N_anchors, Q_n, N_o, a_o, h_op, e_op, 
                t_r, b_r, deckCondition,w_rMin,s_r, IsSingleSideReinforcement);
            phiV_n = op.GetShearStrength();

            return new Dictionary<string, object>
            {
                { "phiV_n", phiV_n }
 
            };
        }
        public static Dictionary<string, object> FlexuralLateralTorsionalBuckling(CustomProfile Shape,string BendingAxis,string FlexuralCompressionLocation,double F_y,
            double L_b, double C_b = 1.0, string FlexuralBracingCase = "NoLateralBracing", double E = 29000, bool IsRolledMember = true, string Code = "AISC360-10")
        {
            //Default values
            double phiM_n = 0;
            bool IsApplicableLimitState = false;


            //Calculation logic:

            MomentAxis Axis;

            bool IsValidStringAxis = Enum.TryParse(BendingAxis, true, out Axis);
            if (IsValidStringAxis == false)
            {
                throw new Exception("Axis selection not recognized. Check input string.");
            }

            FlexuralCompressionFiberPosition FlexuralCompression;
            //Calculation logic:
            bool IsValidStringCompressionLoc = Enum.TryParse(FlexuralCompressionLocation, true, out FlexuralCompression);
            if (IsValidStringCompressionLoc == false)
            {
                throw new Exception("Flexural compression location selection not recognized. Check input string.");
            }

            FlexuralAndTorsionalBracingType Bracing;
            //Calculation logic:
            bool IsValidStringBracing = Enum.TryParse(FlexuralBracingCase, true, out Bracing);
            if (IsValidStringBracing == false)
            {
                throw new Exception("Flexural bracing case selection not recognized. Check input string.");
            }


            SteelMaterial mat = new SteelMaterial(F_y, E);
            FlexuralMemberFactory factory = new FlexuralMemberFactory();
            ISteelBeamFlexure beam = factory.GetBeam(Shape.Section, mat, null, Axis, FlexuralCompression, IsRolledMember);


            SteelLimitStateValue LTB = beam.GetFlexuralLateralTorsionalBucklingStrength(C_b, L_b, FlexuralCompression, Bracing);
            phiM_n = LTB.Value;

            IsApplicableLimitState = LTB.IsApplicable;

            return new Dictionary<string, object>
            {
                { "phiM_n", phiM_n }
                ,{ "IsApplicableLimitState", IsApplicableLimitState }
 
            };
        }
        public static Dictionary<string, object> LimitingLengthForFlexuralYielding(CustomProfile Shape, double F_y, string BendingAxis="XAxis", string FlexuralCompressionLocation="Top",
            double E = 29000, bool IsRolledMember = true, string Code = "AISC360-10")
        {
            //Default values
            double L_pValue = 0;
            bool IsApplicable = false;


            //Calculation logic:

            MomentAxis Axis;
            //Calculation logic:
            bool IsValidStringAxis = Enum.TryParse(BendingAxis, true, out Axis);
            if (IsValidStringAxis == false)
            {
                throw new Exception("Axis selection not recognized. Check input string.");
            }

            FlexuralCompressionFiberPosition FlexuralCompression;
            //Calculation logic:
            bool IsValidStringCompressionLoc = Enum.TryParse(FlexuralCompressionLocation, true, out FlexuralCompression);
            if (IsValidStringCompressionLoc == false)
            {
                throw new Exception("Flexural compression location selection not recognized. Check input string.");
            }


            SteelMaterial mat = new SteelMaterial(F_y, E);
            FlexuralMemberFactory factory = new FlexuralMemberFactory();
            ISteelBeamFlexure beam = factory.GetBeam(Shape.Section, mat, null, Axis, FlexuralCompression, IsRolledMember);

            SteelLimitStateValue L_p =
            beam.GetLimitingLengthForFullYielding_Lp(FlexuralCompression);
            L_pValue = L_p.Value;

            IsApplicable = L_p.IsApplicable;

            IsApplicable = L_p.IsApplicable;

            return new Dictionary<string, object>
            {
                { "L_p", L_pValue }
                ,{ "IsApplicable", IsApplicable }
 
            };
        }
        public static Dictionary <string, object> TorsionalProperties(CustomProfile Shape)
        {
            //Default values
            double J   = 0;
            double C_w = 0;



            J   = Shape.Section.J;
            C_w = Shape.Section.C_w;


            return(new Dictionary <string, object>
            {
                { "J", J }
                , { "C_w", C_w }
            });
        }
        public static Dictionary<string, object> ConnectedElementStrengthInFlexure(CustomProfile Shape,
            double L_b, double F_y, double F_u, bool HasHolesInTensionFlange = false, double A_fg = 0, double A_fn = 0, bool IsCompactDoublySymmetricForFlexure = true, double C_b = 1,
            string Code = "AISC360-10")
        {
            //Default values
            double phiM_n = 0;


            //Calculation logic:
            ICalcLog log = new CalcLog();
            ISection Isec = Shape.Section as ISection;
            ISteelMaterial Material = new SteelMaterial(F_y, F_u, SteelConstants.ModulusOfElasticity, SteelConstants.ShearModulus);
            AffectedElementInFlexure element = new AffectedElementInFlexure(Isec, F_y, F_u, HasHolesInTensionFlange, A_fg, A_fn, IsCompactDoublySymmetricForFlexure);
            phiM_n = element.GetFlexuralStrength();

            return new Dictionary<string, object>
            {
                { "phiM_n", phiM_n }
 
            };
        }
        public static Dictionary<string, object> TorsionalAndFlexuralTorsionalBucklingStrength(CustomProfile Shape,double L_ex,double L_ey,double L_ez,double F_y,double E,bool IsRolledMember,
            string Code = "AISC360-10")
        {
            //Default values
            double phiP_n = 0;
            bool IsApplicable = true;

            //Calculation logic:
            CompressionMemberFactory f = new CompressionMemberFactory();
            ISteelCompressionMember compMember = f.GetCompressionMember(Shape.Section, L_ex, L_ey, L_ez, F_y, E, IsRolledMember);


            SteelLimitStateValue FlexuralTorsionalBuckling = compMember.GetTorsionalAndFlexuralTorsionalBucklingStrength();
            phiP_n = FlexuralTorsionalBuckling.Value;
            IsApplicable = FlexuralTorsionalBuckling.IsApplicable;

            return new Dictionary<string, object>
            {
                { "phiP_n", phiP_n },
                { "IsApplicable", IsApplicable }
            };
        }
        public static Dictionary<string, object> LowerBoundMomentOfInertia(CustomProfile Shape, double b_eff, double h_solid, double h_rib, double F_y, double fc_prime,
            double SumQ_n, string Code = "AISC360-10")
        {
            //Default values
            double I_LB = 0;


            //Calculation logic:


            if (Shape.Section is ISliceableShapeProvider)
            {
                ISliceableShapeProvider prov = Shape.Section as ISliceableShapeProvider;
                ISliceableSection sec = prov.GetSliceableShape();
                CompositeBeamSection cs = new CompositeBeamSection(sec, b_eff, h_solid, h_rib, F_y, fc_prime);
                I_LB = cs.GetLowerBoundMomentOfInertia(SumQ_n);
            }
            else
            {
                if (Shape.Section is ISliceableSection)
                {
                    ISliceableSection sec = Shape.Section as ISliceableSection;
                    CompositeBeamSection cs = new CompositeBeamSection(sec, b_eff, h_solid, h_rib, F_y, fc_prime);
                    I_LB = cs.GetLowerBoundMomentOfInertia(SumQ_n);
                }
                else
                {
                    throw new Exception("Shape type not supported. Please provide a shape object of standard geometry");
                }

            }

            return new Dictionary<string, object>
            {
                { "I_LB", I_LB }
 
            };
        }
        public static Dictionary <string, object> FirstMomentOfAreaX(CustomProfile Shape, double Y_offset)
        {
            //Default values
            double Q = 0.0;


            if (Shape.Section is IFirstMomentOfAreaCalculatable)
            {
                IFirstMomentOfAreaCalculatable s = Shape.Section as IFirstMomentOfAreaCalculatable;
                Q = s.GetFirstMomentOfAreaX(Y_offset);
            }

            else
            {
                throw new Exception("Provided shape does not support this calculation, or wrong object type is specified.");
            }


            return(new Dictionary <string, object>
            {
                { "Q", Q }
            });
        }
        public static Dictionary<string, object> SteelIBeamWebOpeningShearStrength(CustomProfile IShape,double F_y,double a_o,double h_op,
            double e_op,double t_r,double b_r,bool IsSingleSideReinforcement)
        {
            //Default values
            double phiV_n = 0;


            //Calculation logic:

            ISectionI sectionI = IShape.Section as ISectionI;
            if (sectionI == null)
            {
                throw new Exception("Specified shape type is not supported. Provide I-shape object as inputparameter");
            }
            SteelIBeamWebOpening op = new SteelIBeamWebOpening(sectionI, F_y, a_o, h_op, e_op, t_r, b_r, IsSingleSideReinforcement);
            phiV_n = op.GetShearStrength();

            return new Dictionary<string, object>
            {
                { "phiV_n", phiV_n }
 
            };
        }
        public static Dictionary<string, object> PositiveMomentFlexuralStrength(CustomProfile Shape, double b_eff, double h_solid, double h_rib, double F_y, double fc_prime,
            double SumQ_n, string Code = "AISC360-10")
        {
            //Default values
            double phiM_n = 0;


            //Calculation logic:
            if (Shape.Section is ISliceableShapeProvider)
            {
                ISliceableShapeProvider prov = Shape.Section as ISliceableShapeProvider;
                ISliceableSection sec = prov.GetSliceableShape();
                CompositeBeamSection cs = new CompositeBeamSection(sec, b_eff, h_solid, h_rib, F_y, fc_prime);
                phiM_n = cs.GetFlexuralStrength(SumQ_n);
            }
            else
            {
                if (Shape.Section is ISliceableSection)
                {
                    ISliceableSection sec = Shape.Section as ISliceableSection;
                    CompositeBeamSection cs = new CompositeBeamSection(sec, b_eff, h_solid, h_rib, F_y, fc_prime);
                    phiM_n = cs.GetFlexuralStrength(SumQ_n);
                }
                else
                {
                    throw new Exception("Shape type not supported. Please provide a shape object of standard geometry");
                }
                
            }


            return new Dictionary<string, object>
            {
                { "phiM_n", phiM_n }
 
            };
        }
        public static Dictionary<string, object> ChordSidewallShearStrength(string HssTrussConnectionMemberType, string HssTrussConnectionClassification, CustomProfile MainBranchSection, double theta_main, string AxialForceTypeMain,
            CustomProfile SecondaryBranchSection, double theta_sec, string AxialForceTypeSecondary, double F_yb, CustomProfile ChordSection, double F_yc,
            bool IsTensionChord, double P_uChord, double M_uChord, double O_v, string Code = "AISC360-10")
        {
            //Default values
            double phiP_nMain = -1;
            double phiP_nSec = -1;
            bool IsApplicableMain = false;
            bool IsApplicableSecn = false;


            //Calculation logic:


            //Not implemented

            return new Dictionary<string, object>
            {
                { "phiP_nMain", phiP_nMain }
                ,{ "phiP_nSec", phiP_nSec }
                ,{ "IsApplicableMain", IsApplicableMain }
                ,{ "IsApplicableSecn", IsApplicableSecn }
              };
        }
示例#13
0
        internal Compression(CustomProfile Shape, double L_ex, double L_ey, double L_ez, double F_y, double E, bool IsRolledMember)
        {

        }
        public static Dictionary<string, object> ChordSidewallLocalCripplingStrength(string HssTrussConnectionMemberType, string HssTrussConnectionClassification, CustomProfile MainBranchSection, double theta_main, string AxialForceTypeMain,
            CustomProfile SecondaryBranchSection, double theta_sec, string AxialForceTypeSecondary, double F_yb, CustomProfile ChordSection, double F_yc, bool IsTensionChord,
            double P_uChord, double M_uChord, double O_v, string Code = "AISC360-10")
        {
            //Default values
            double phiP_nMain = 0;
            double phiP_nSec = 0;
            bool IsApplicableMain = false;
            bool IsApplicableSecn = false;


            //Calculation logic:

            #region Evaluate and update input

            HssTrussConnectionMemberType _MemberType;
            HssTrussConnectionClassification _Class;
            AxialForceType _MainBranchForceType;
            AxialForceType _SecondaryBranchForceType;


            ISectionHollow _MainBranchSection;
            ISectionHollow _SecondaryBranchSection;
            ISectionHollow _ChordSection;

            bool IsValidMemType = Enum.TryParse(HssTrussConnectionMemberType, true, out _MemberType);
            if (IsValidMemType == false)
            {
                throw new Exception("Failed to convert string. HssTrussConnectionMemberType must be either RHS (rectanguar HSS) or CHS (circular HSS) . Please check input.");
            }


            bool IsValidIClass = Enum.TryParse(HssTrussConnectionClassification, true, out _Class);
            if (IsValidIClass == false)
            {
                throw new Exception("Failed to convert string. HssTrussConnectionClassification needs to specify T,Y,X, GappedK or Overlapped K connection type. Please check input.");
            }


            bool IsValidMainForce = Enum.TryParse(AxialForceTypeMain, true, out _MainBranchForceType);
            if (IsValidMainForce == false)
            {
                throw new Exception("Failed to convert string. Specify force as Tension, Compression or Reversible. Please check input.");
            }


            bool IsValidSecForce = Enum.TryParse(AxialForceTypeSecondary, true, out _SecondaryBranchForceType);
            if (IsValidSecForce == false)
            {
                throw new Exception("Failed to convert string. Specify force as Tension, Compression or Reversible. Please check input.");
            }

            if (!(MainBranchSection.Section is ISectionHollow) || !(SecondaryBranchSection.Section is ISectionHollow) || !(ChordSection.Section is ISectionHollow))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }

            _MainBranchSection = MainBranchSection.Section as ISectionHollow;
            _SecondaryBranchSection = SecondaryBranchSection.Section as ISectionHollow;
            _ChordSection = ChordSection.Section as ISectionHollow;
            #endregion


            HssTrussConnectionFactory factory = new HssTrussConnectionFactory();

            IHssTrussBranchConnection conMain = factory.GetConnection(_MemberType, _Class, _ChordSection, _MainBranchSection, _SecondaryBranchSection, F_yc,
            F_yb, theta_main, theta_sec, _MainBranchForceType, _SecondaryBranchForceType, IsTensionChord, P_uChord, M_uChord, O_v);

            IHssTrussBranchConnection conSec = factory.GetConnection(_MemberType, _Class, _ChordSection, _SecondaryBranchSection, _MainBranchSection, F_yc,
            F_yb, theta_sec, theta_main, _SecondaryBranchForceType, _MainBranchForceType, IsTensionChord, P_uChord, M_uChord, O_v);


            phiP_nMain = conMain.GetChordSidewallLocalCripplingStrength().Value;

            phiP_nSec = conSec.GetChordSidewallLocalCripplingStrength().Value;


            IsApplicableMain = conMain.GetChordSidewallLocalCripplingStrength().IsApplicable;
            IsApplicableSecn = conSec.GetChordSidewallLocalCripplingStrength().IsApplicable;

            return new Dictionary<string, object>
            {
                { "phiP_nMain", phiP_nMain }
                ,{ "phiP_nSec", phiP_nSec }
                ,{ "IsApplicableMain", IsApplicableMain }
                ,{ "IsApplicableSecn", IsApplicableSecn }
              };
        }
 public Dictionary<string, object> ConnectedElementStrengthInFlexure(CustomProfile Shape, Double L_b, Double F_y, Double F_u, Boolean HasHolesInTensionFlange, Double A_fg = 0, Double A_fn = 0, Boolean IsCompactDoublySymmetricForFlexure = false, Double C_b = 1)
 {
     return WosadSteel.AISC_10.Connection.AffectedElements.ConnectedElementStrengthInFlexure(Shape, L_b, F_y, F_u, HasHolesInTensionFlange, A_fg, A_fn, IsCompactDoublySymmetricForFlexure, C_b);
 }
        public static Dictionary<string, object> ChordWallPlastificationStrength(string HssTrussConnectionMemberType, string HssTrussConnectionClassification, CustomProfile MainBranchSection, double theta_main,
            string AxialForceTypeMain,
            CustomProfile SecondaryBranchSection, double theta_sec, string AxialForceTypeSecondary, double F_yb, CustomProfile ChordSection, double F_yc, bool IsTensionChord,
            double P_uChord, double M_uChord, double O_v, string Code = "AISC360-10")
        {
            //Default values
            double phiP_nMain = 0;
            double phiP_nSec = 0;
            bool IsApplicableMain = false;
            bool IsApplicableSecn = false;


            //Calculation logic:

            #region Evaluate and update input

            HssTrussConnectionMemberType _MemberType;
            HssTrussConnectionClassification _Class;
            AxialForceType _MainBranchForceType;
            AxialForceType _SecondaryBranchForceType;


            ISectionHollow _MainBranchSection;
            ISectionHollow _SecondaryBranchSection;
            ISectionHollow _ChordSection;

            bool IsValidMemType = Enum.TryParse(HssTrussConnectionMemberType, true, out _MemberType);
            if (IsValidMemType == false)
            {
                throw new Exception("Failed to convert string. HssTrussConnectionMemberType must be either RHS (rectanguar HSS) or CHS (circular HSS) . Please check input.");
            }


            bool IsValidIClass = Enum.TryParse(HssTrussConnectionClassification, true, out _Class);
            if (IsValidIClass == false)
            {
                throw new Exception("Failed to convert string. HssTrussConnectionClassification needs to specify T,Y,X, GappedK or Overlapped K connection type. Please check input.");
            }


            bool IsValidMainForce = Enum.TryParse(AxialForceTypeMain, true, out _MainBranchForceType);
            if (IsValidMainForce == false)
            {
                throw new Exception("Failed to convert string. Specify force as Tension, Compression or Reversible. Please check input.");
            }


            bool IsValidSecForce = Enum.TryParse(AxialForceTypeSecondary, true, out _SecondaryBranchForceType);
            if (IsValidSecForce == false)
            {
                throw new Exception("Failed to convert string. Specify force as Tension, Compression or Reversible. Please check input.");
            }

            if (!(MainBranchSection.Section is ISectionHollow) || !(SecondaryBranchSection.Section is ISectionHollow) || !(ChordSection.Section is ISectionHollow))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }

            _MainBranchSection = MainBranchSection.Section as ISectionHollow;
            _SecondaryBranchSection = SecondaryBranchSection.Section as ISectionHollow;
            _ChordSection = ChordSection.Section as ISectionHollow;
            #endregion


            HssTrussConnectionFactory factory = new HssTrussConnectionFactory();


            bool IsKConnection = _Class == Wosad.Steel.AISC.Entities.HssTrussConnectionClassification.GappedK || _Class == Wosad.Steel.AISC.Entities.HssTrussConnectionClassification.OverlappedK ? true : false;

            if (IsKConnection == true && _MemberType == Wosad.Steel.AISC.Entities.HssTrussConnectionMemberType.Chs && _MainBranchForceType == AxialForceType.Reversible && _SecondaryBranchForceType == AxialForceType.Reversible)
            {
                // account for load reversal in branches
                IHssTrussBranchConnection conMain1 = factory.GetConnection(_MemberType, _Class, _ChordSection, _MainBranchSection, _SecondaryBranchSection, F_yc,
                F_yb, theta_main, theta_sec, AxialForceType.Compression, AxialForceType.Tension, IsTensionChord, P_uChord, M_uChord, O_v);

                IHssTrussBranchConnection conMain2 = factory.GetConnection(_MemberType, _Class, _ChordSection, _MainBranchSection, _SecondaryBranchSection, F_yc,
                F_yb, theta_main, theta_sec, AxialForceType.Tension, AxialForceType.Compression, IsTensionChord, P_uChord, M_uChord, O_v);

                IHssTrussBranchConnection conSec1 = factory.GetConnection(_MemberType, _Class, _ChordSection, _SecondaryBranchSection, _MainBranchSection, F_yc,
                F_yb, theta_sec, theta_main, AxialForceType.Compression, AxialForceType.Tension, IsTensionChord, P_uChord, M_uChord, O_v);

                IHssTrussBranchConnection conSec2 = factory.GetConnection(_MemberType, _Class, _ChordSection, _SecondaryBranchSection, _MainBranchSection, F_yc,
                F_yb, theta_sec, theta_main, AxialForceType.Tension, AxialForceType.Compression, IsTensionChord, P_uChord, M_uChord, O_v);

                SteelLimitStateValue main1 = conMain1.GetChordWallPlastificationStrength(true);
                SteelLimitStateValue main2 = conMain2.GetChordWallPlastificationStrength(true);

                SteelLimitStateValue sec1 = conSec1.GetChordWallPlastificationStrength(true);
                SteelLimitStateValue sec2 = conSec2.GetChordWallPlastificationStrength(true);

                phiP_nMain = Math.Min(main1.Value, main2.Value);
                phiP_nMain = Math.Min(sec1.Value, sec2.Value);

                IsApplicableMain = main1.IsApplicable;
                IsApplicableSecn = sec1.IsApplicable;

            }
            else
            {
                IHssTrussBranchConnection conMain = factory.GetConnection(_MemberType, _Class, _ChordSection, _MainBranchSection, _SecondaryBranchSection, F_yc,
                F_yb, theta_main, theta_sec, _MainBranchForceType, _SecondaryBranchForceType, IsTensionChord, P_uChord, M_uChord, O_v);

                IHssTrussBranchConnection conSec = factory.GetConnection(_MemberType, _Class, _ChordSection, _SecondaryBranchSection, _MainBranchSection, F_yc,
                F_yb, theta_sec, theta_main, _SecondaryBranchForceType, _MainBranchForceType, IsTensionChord, P_uChord, M_uChord, O_v);

                SteelLimitStateValue main = conMain.GetChordWallPlastificationStrength(true);
                SteelLimitStateValue sec = conSec.GetChordWallPlastificationStrength(true);
                phiP_nMain = main.Value;
                phiP_nSec = sec.Value;

                IsApplicableMain = main.IsApplicable;
                IsApplicableSecn = sec.IsApplicable;
            }



            return new Dictionary<string, object>
            {
                { "phiP_nMain", phiP_nMain }
                ,{ "phiP_nSec", phiP_nSec }
                ,{ "IsApplicableMain", IsApplicableMain }
                ,{ "IsApplicableSecn", IsApplicableSecn }
              };
        }
        public static Dictionary<string, object> TorsionalProperties(CustomProfile Shape)
        {
            //Default values
            double J = 0;
            double C_w = 0;



            J = Shape.Section.J;
            C_w = Shape.Section.C_w;


            return new Dictionary<string, object>
            {
            { "J", J }
            ,{ "C_w", C_w }

            };
        }
        public static Dictionary<string, object> HssToLongitudinalPlateWallPlastification(CustomProfile HssSection,CustomProfile PlateSection,
            double F_y,double F_yp, double P_uHss,  double M_uHss,double theta=90.0, bool IsTensionHss=false, bool IsThroughPlate=false)
        {
            //Default values
            double phiR_n = 0;
            bool IsApplicableLimitState = false;


            //Calculation logic:
            CalcLog log = new CalcLog();
            SteelLimitStateValue limitState = null;

            //PLATE

            SteelPlateSection pl = null;

            if (!(PlateSection.Section is ISectionRectangular))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }
            else
            {
                SteelMaterial mat = new SteelMaterial(F_y);
                ISectionRectangular rect = PlateSection.Section as ISectionRectangular;
                double t_pl, b_pl = 0.0;
                WosadSection.SectionRectangular rSect;
                if (rect.B <= rect.H)
                {
                    rSect = new WosadSection.SectionRectangular(rect.B, rect.H);
                }
                else
                {
                    rSect = new WosadSection.SectionRectangular(rect.H, rect.B);
                }
                pl = new SteelPlateSection(rSect, mat);

            }


            //HSS

            if (!(HssSection.Section is ISectionHollow))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }
            else
            {
                SteelMaterial mat = new SteelMaterial(F_y);
                if (HssSection.Section is ISectionPipe)
                {
                    SteelChsSection sec = new SteelChsSection(HssSection.Section as ISectionPipe, mat);
                    ChsLongitudinalPlate longitudinalPlateChs = new ChsLongitudinalPlate(sec, pl, log, IsTensionHss,theta, P_uHss, M_uHss);

                    limitState = longitudinalPlateChs.GetHssWallPlastificationStrengthUnderAxialLoad();
                    if (IsThroughPlate == false)
                    {
                        phiR_n = limitState.Value;
                    }
                    else
                    {
                        phiR_n = 2.0* limitState.Value; //analogous to Rectangular HSS provsions
                    }
                    
                    IsApplicableLimitState = limitState.IsApplicable;
                    

                }
                else if (HssSection.Section is ISectionTube)
                {
                    SteelRhsSection sec = new SteelRhsSection(HssSection.Section as ISectionTube, mat);
                    if (IsThroughPlate == false)
                    {
                        RhsLongitudinalPlate longitudinalPlateRhs = new RhsLongitudinalPlate(sec, pl,  log, IsTensionHss,theta, P_uHss, M_uHss);

                        limitState = longitudinalPlateRhs.GetHssWallPlastificationStrengthUnderAxialLoad();
                        phiR_n = limitState.Value;
                        IsApplicableLimitState = limitState.IsApplicable;  
                    }
                    else
                    {
                        RhsLongitudinalThroughPlate longitudinalPlateRhs = new RhsLongitudinalThroughPlate(sec, pl, log, IsTensionHss,theta, P_uHss, M_uHss);

                        limitState = longitudinalPlateRhs.GetHssWallPlastificationStrengthUnderAxialLoad();
                        phiR_n = limitState.Value;
                        IsApplicableLimitState = limitState.IsApplicable;
                    }
                   
                }
                else
                {
                    throw new Exception("Unsupported type of hollow section. Please use Tube or Pipe.");
                }
            }

            return new Dictionary<string, object>
            {
                { "phiR_n", phiR_n }
,{ "IsApplicableLimitState", IsApplicableLimitState }
 
            };
        }
        public static Dictionary<string, object> YAxisProperties(CustomProfile Shape)
        {
            //Default values
            double y_e = 0;
            double y_p = 0;
            double I_y = 0;
            double Z_y = 0;
            double S_yLeft = 0;
            double S_yRight = 0;
            double r_y = 0;
            double A = 0;


            y_e = Shape.Section.y_Bar;
            y_p = Shape.Section.y_pBar;
            I_y = Shape.Section.I_y;
            Z_y = Shape.Section.Z_y;
            S_yLeft = Shape.Section.S_yLeft;
            S_yRight = Shape.Section.S_yRight;
            r_y = Shape.Section.r_y;
            A = Shape.Section.A;

            return new Dictionary<string, object>
            {
            { "y_e", y_e }
            ,{ "y_p", y_p }
            ,{ "I_y", I_y }
            ,{ "Z_y", Z_y }
            ,{ "S_yLeft", S_yLeft }
            ,{ "S_yRight", S_yRight }
            ,{ "r_y", r_y }
            ,{ "A", A }
            };
        }
        public static Dictionary<string, object> HssToLongitudinalPlateMaximumPlateThicknessForShear(CustomProfile HssSection,CustomProfile PlateSection,
            double F_y,double F_yp,bool IsTensionHss,double P_uHss,double M_uHss)
        {
            //Default values
            double t_max = 0;


            //Calculation logic:
            CalcLog log = new CalcLog();
            SteelLimitStateValue limitState = null;

            //PLATE

            SteelPlateSection pl = null;

            if (!(PlateSection.Section is ISectionRectangular))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }
            else
            {
                SteelMaterial mat = new SteelMaterial(F_y);
                ISectionRectangular rect = PlateSection.Section as ISectionRectangular;
                double t_pl, b_pl = 0.0;
                SectionRectangular rSect;
                if (rect.B <= rect.H)
                {
                    rSect = new SectionRectangular(rect.B, rect.H);
                }
                else
                {
                    rSect = new SectionRectangular(rect.H, rect.B);
                }
                pl = new SteelPlateSection(rSect, mat);

            }


            //HSS

            if (!(HssSection.Section is ISectionHollow))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }
            else
            {
                SteelMaterial mat = new SteelMaterial(F_y);
                if (HssSection.Section is ISectionPipe)
                {
                    SteelChsSection sec = new SteelChsSection(HssSection.Section as ISectionPipe, mat);
                    ChsLongitudinalPlate longitudinalPlateChs = new ChsLongitudinalPlate(sec, pl, log, IsTensionHss,90.0, P_uHss, M_uHss);

                    //limitState = longitudinalPlateChs.ge
                    //phiR_n = limitState.Value;
                    //IsApplicableLimitState = limitState.IsApplicable;
                    t_max = longitudinalPlateChs.GetHssMaximumPlateThicknessForShearLoad().Value;

                }
                else if (HssSection.Section is ISectionTube)
                {
                    SteelRhsSection sec = new SteelRhsSection(HssSection.Section as ISectionTube, mat);
                    RhsLongitudinalPlate longitudinalPlateRhs = new RhsLongitudinalPlate(sec, pl, log, IsTensionHss,90.0, P_uHss, M_uHss);

                    //limitState = longitudinalPlateRhs.GetHssYieldingOrCrippling();
                    //phiR_n = limitState.Value;
                    //IsApplicableLimitState = limitState.IsApplicable;
                    t_max = longitudinalPlateRhs.GetHssMaximumPlateThicknessForShearLoad().Value;
                }
                else
                {
                    throw new Exception("Unsupported type of hollow section. Please use Tube or Pipe.");
                }
            }

            return new Dictionary<string, object>
            {
                { "t_max", t_max }
 
            };
        }
        public static Dictionary<string, object> HssToTransversePlateLocalPunchingStrengthOfPlate(CustomProfile HssSection,CustomProfile PlateSection,
            double theta, string HssTransversePlateType, double F_y, double F_yp, bool IsTensionHss, double P_uHss, double M_uHss)
        {
            //Default values
            double phiR_n = 0;
            bool IsApplicableLimitState = false;


            //Calculation logic:
            CalcLog log = new CalcLog();
            SteelLimitStateValue limitState = null;

            //PLATE

            SteelPlateSection pl = null;

            if (!(PlateSection.Section is ISectionRectangular))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }
            else
            {
                SteelMaterial mat = new SteelMaterial(F_y);
                ISectionRectangular rect = PlateSection.Section as ISectionRectangular;
                double t_pl, b_pl = 0.0;
                WosadSection.SectionRectangular rSect;
                if (rect.B <= rect.H)
                {
                    rSect = new WosadSection.SectionRectangular(rect.B, rect.H);
                }
                else
                {
                    rSect = new WosadSection.SectionRectangular(rect.H, rect.B);
                }
                pl = new SteelPlateSection(rSect, mat);

            }

            TransversePlateType transvPlateType;
            bool IsValidTransvPlate = Enum.TryParse(HssTransversePlateType, true, out transvPlateType);
            if (IsValidTransvPlate == false)
            {
                throw new Exception("Failed to convert string. Transverse plate type must be TConnection or XConnection. Please check input");
            }

            //HSS

            if (!(HssSection.Section is ISectionHollow))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }
            else
            {
                SteelMaterial mat = new SteelMaterial(F_y);
                if (HssSection.Section is ISectionPipe)
                {
                    SteelChsSection sec = new SteelChsSection(HssSection.Section as ISectionPipe, mat);
                    ChsTransversePlate transversePlateChs = new ChsTransversePlate(sec, pl, log, IsTensionHss, P_uHss, M_uHss);

                    limitState = transversePlateChs.GetLocalPunchingStrengthOfPlate();
                    phiR_n = limitState.Value;
                    IsApplicableLimitState = limitState.IsApplicable;


                }
                else if (HssSection.Section is ISectionTube)
                {
                    SteelRhsSection sec = new SteelRhsSection(HssSection.Section as ISectionTube, mat);
                    RhsTransversePlate transversePlateRhs = new RhsTransversePlate(sec, pl, log, IsTensionHss, transvPlateType, P_uHss, M_uHss);

                    limitState = transversePlateRhs.GetLocalPunchingStrengthOfPlate();
                    phiR_n = limitState.Value;
                    IsApplicableLimitState = limitState.IsApplicable;

                }
                else
                {
                    throw new Exception("Unsupported type of hollow section. Please use Tube or Pipe.");
                }
            }
          



            return new Dictionary<string, object>
            {
                { "phiR_n", phiR_n }
,{ "IsApplicableLimitState", IsApplicableLimitState }
 
            };
        }
示例#22
0
 public static Compression ByInputParameters(CustomProfile Shape, double L_ex, double L_ey, double L_ez, double F_y, double E, bool IsRolledMember)
 {
     return new Compression(Shape, L_ex, L_ey, L_ez, F_y, E, IsRolledMember);
 }
        public static Dictionary<string, object> HssCapPlateLocalYieldingOrCripplingOfHss(CustomProfile HssSection,CustomProfile PlateSection,double t_pCap,double F_y,double F_yp,bool IsTensionHss,double P_uHss,double M_uHss)
        {
            //Default values
            double phiR_n = 0;
            bool IsApplicableLimitState = false;


            //Calculation logic:
            CalcLog log = new CalcLog();
            SteelLimitStateValue limitState = null;

            //PLATE

            SteelPlateSection pl = null;

            if (!(PlateSection.Section is ISectionRectangular))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }
            else
	        {
                SteelMaterial mat = new SteelMaterial(F_y);
                ISectionRectangular rect = PlateSection.Section as ISectionRectangular;
                double t_pl, b_pl = 0.0;
                SectionRectangular rSect;
                if (rect.B<=rect.H)
                {
                    rSect = new SectionRectangular(rect.B, rect.H);
                }
                else
                {
                    rSect = new SectionRectangular(rect.H, rect.B);
                }
                pl = new SteelPlateSection(rSect, mat);

	        }


            //HSS

            if (!(HssSection.Section is ISectionHollow))
            {
                throw new Exception("Failed to convert section. Section needs to be either a Pipe or a Tube. Please check input.");
            }
            else
            {
                SteelMaterial mat = new SteelMaterial(F_y);
                if (HssSection.Section is ISectionPipe)
                {
                    SteelChsSection sec = new SteelChsSection(HssSection.Section as ISectionPipe, mat);
                    ChsCapPlate capRhs = new ChsCapPlate(sec, pl, t_pCap, log, IsTensionHss, P_uHss, M_uHss);

                    limitState = capRhs.GetHssYieldingOrCrippling();
                    phiR_n = limitState.Value;
                    IsApplicableLimitState = limitState.IsApplicable;

                }
                else if (HssSection.Section is ISectionTube)
                {
                    SteelRhsSection sec = new SteelRhsSection(HssSection.Section as ISectionTube, mat);
                    RhsCapPlate capRhs = new RhsCapPlate(sec, pl, t_pCap, log, IsTensionHss, P_uHss, M_uHss);
                    
                    limitState = capRhs.GetHssYieldingOrCrippling();
                    phiR_n = limitState.Value;
                    IsApplicableLimitState = limitState.IsApplicable;
                }
                else
                {
                    throw new Exception("Unsupported type of hollow section. Please use Tube or Pipe.");
                }
            }



            return new Dictionary<string, object>
            {
                { "phiR_n", phiR_n }
                ,{ "IsApplicableLimitState", IsApplicableLimitState }
 
            };
        }