double GetBearingLengthY(double P_u, double M_u, BendingAxis Axis, double f_anchor)
        {
            CalculateBasePlateCommonParameters(P_u, M_u, Axis);
            double Y = 0.0;

            double e_critical = Get_e_critical(P_u, M_u, Axis);

            if (e <= e_critical)
            {
                //Small moment base plate
                Y = N_bp - 2.0 * e;
            }
            else
            {
                //Large moment base plate
                //DG01  3.4.3
                double        Y1             = (f_anchor + ((N_bp) / (2))) + Math.Sqrt(Math.Pow((f_anchor + ((N_bp) / (2))), 2) - ((2 * P_u * (e + f_anchor)) / q_pMax));
                double        Y2             = (f_anchor + ((N_bp) / (2))) - Math.Sqrt(Math.Pow((f_anchor + ((N_bp) / (2))), 2) - ((2 * P_u * (e + f_anchor)) / q_pMax));
                List <double> BearingLengths = new List <double>()
                {
                    Y1, Y2
                };
                Y = BearingLengths.Where(y => y > 0 && y < N_bp).Max();
            }


            return(Y);
        }
        private double Get_e_critical(double P_u, double M_u, BendingAxis Axis)
        {
            CalculateBasePlateCommonParameters(P_u, M_u, Axis);
            double e_crit = ((N_bp) / (2)) - ((P_u) / (2 * q_pMax));

            return(e_crit);
        }
 private void CalculateBasePlateCommonParameters(double P_u, double M_u, BendingAxis Axis)
 {
     double phi_c = 0.65;
     A_1 = Plate.B_bp * Plate.N_bp;
     A_2 = Plate.A_2;
     q_pMax = Get_q_pMax(f_c, Axis, A_1, A_2);
     f_pMax = Get_f_pMax(f_c, A_1, A_2);
     e = M_u / P_u;
 }
        private void CalculateBasePlateCommonParameters(double P_u, double M_u, BendingAxis Axis)
        {
            double phi_c = 0.65;

            A_1    = Plate.B_bp * Plate.N_bp;
            A_2    = Plate.A_2;
            q_pMax = Get_q_pMax(f_c, Axis, A_1, A_2);
            f_pMax = Get_f_pMax(f_c, A_1, A_2);
            e      = M_u / P_u;
        }
        //double P_u;

        public override double Get_l_tension(BendingAxis Axis)
        {
            if (Axis == BendingAxis.Major)
            {
                return(f_anchor - d_c / 2.0 + t_f / 2.0);
            }
            else
            {
                return(f_anchor - b_f / 4.0);
            }
        }
        double Get_q_pMax(double f_c, BendingAxis Axis, double A_1, double A_2)
        {
            double f_pMax = Get_f_pMax(f_c, A_1, A_2);
            double q_pMax = 0.0;

            if (Axis == BendingAxis.Major)
            {
                q_pMax = f_pMax * B_bp;
            }
            else
            {
                q_pMax = f_pMax * N_bp;
            }

            return(q_pMax);
        }
        private bool GetIsLargeMoment(double P_u, double M_u, double Y, BendingAxis Axis)
        {
            double f_p;
            double e_critical = Get_e_critical(P_u, M_u, Axis);

            if (e <= e_critical)
            {
                //Small moment base plate
                return(false);
            }
            else
            {
                //Large moment base plate
                return(true);
            }
        }
        private double Get_f_p(double P_u, double M_u, double Y, BendingAxis Axis)
        {
            double f_p;
            double e_critical = Get_e_critical(P_u, M_u, Axis);

            if (e <= e_critical)
            {
                //Small moment base plate
                f_p = P_u / (B_bp * Y);
            }
            else
            {
                //Large moment base plate
                f_p = Get_f_pMax(f_c, A_1, A_2);
            }

            return(f_p);
        }
        private double Get_f_p(double P_u, double M_u, double Y, BendingAxis Axis)
        {
            double f_p;
            //double e_critical = Get_e_critical(P_u, M_u, Axis);
            bool IsLargeMoment = GetIsLargeMoment(P_u, M_u, Y, Axis);

            if (IsLargeMoment == false)
            {
                //Small moment base plate
                f_p = P_u / (B_bp * Y);
            }
            else
            {
                //Large moment base plate
                f_p = Get_f_pMax(f_c, A_1, A_2);
            }

            return(f_p);
        }
        public virtual double GetMinimumThicknessEccentricLoadStrongAxis(double P_u, double M_u, BendingAxis Axis, double f_anchor)
        {

            double F_y = Plate.F_y;
           // double Y = GetBearingLengthY(P_u, M_u, Axis, f_anchor);

            bool meetsMinimumSize = DetermineIfBasePlateMeetsMinimumSizeLimits(P_u, M_u, Axis, f_anchor);
            if (meetsMinimumSize == false)
            {
                throw new Exception("Base plate does not meet minimum size requirements. Please revise.");
            }

            double Y = GetBearingLengthY(P_u, M_u, Axis, f_anchor);
            CalculateBasePlateCommonParameters(P_u, M_u,Axis);


            // calculate m
            double m = Plate.Get_m();
            double n = Plate.Get_n();

            double f_pMax = Get_f_pMax(f_c, A_1, A_2);
            
            double f_p = Get_f_p(P_u, M_u,Y,Axis);


            double t_p;

            if (Y>=m) 
            {
                //DG01 3.3.14a-2
                double l = Math.Max(m, n);
                t_p = 1.49 * l * Math.Sqrt(((f_p) / F_y));
            }
            else
            {
                //DG01 3.3.15a-2
                t_p = 2.11 * Math.Sqrt(((f_p * Y * (m - (Y / 2.0))) / F_y));
            }

            return t_p;


        }
        public virtual double GetMinimumThicknessEccentricLoadStrongAxis(double P_u, double M_u, BendingAxis Axis, double f_anchor)
        {
            double F_y = Plate.F_y;
            // double Y = GetBearingLengthY(P_u, M_u, Axis, f_anchor);

            bool meetsMinimumSize = DetermineIfBasePlateMeetsMinimumSizeLimits(P_u, M_u, Axis, f_anchor);

            if (meetsMinimumSize == false)
            {
                throw new Exception("Base plate does not meet minimum size requirements. Please revise.");
            }

            double Y = GetBearingLengthY(P_u, M_u, Axis, f_anchor);

            CalculateBasePlateCommonParameters(P_u, M_u, Axis);


            // calculate m
            double m = Plate.Get_m();
            double n = Plate.Get_n();

            double f_pMax = Get_f_pMax(f_c, A_1, A_2);

            double f_p = Get_f_p(P_u, M_u, Y, Axis);


            double t_p;

            if (Y >= m)
            {
                //DG01 3.3.14a-2
                double l = Math.Max(m, n);
                t_p = 1.49 * l * Math.Sqrt(((f_p) / F_y));
            }
            else
            {
                //DG01 3.3.15a-2
                t_p = 2.11 * Math.Sqrt(((f_p * Y * (m - (Y / 2.0))) / F_y));
            }

            return(t_p);
        }
        public virtual double GetMinimumThicknessEccentricLoadStrongAxis(double P_u, double M_u, BendingAxis Axis, double f_anchor)
        {
            double F_y = Plate.F_y;
            // double Y = GetBearingLengthY(P_u, M_u, Axis, f_anchor);

            bool meetsMinimumSize = DetermineIfBasePlateMeetsMinimumSizeLimits(P_u, M_u, Axis, f_anchor);

            if (meetsMinimumSize == false)
            {
                throw new Exception("Base plate does not meet minimum size requirements. Please revise.");
            }

            double Y = GetBearingLengthY(P_u, M_u, Axis, f_anchor);

            CalculateBasePlateCommonParameters(P_u, M_u, Axis);


            // calculate m
            double m = Plate.Get_m();
            double n = Plate.Get_n();

            double f_pMax = Get_f_pMax(f_c, A_1, A_2);

            double f_p = Get_f_p(P_u, M_u, Y, Axis);


            double t_p;

            //Check on the bearing side
            if (Y >= m)
            {
                //DG01 3.3.14a-2
                double l = Math.Max(m, n);
                t_p = 1.49 * l * Math.Sqrt(((f_p) / F_y));
            }
            else
            {
                //DG01 3.3.15a-2
                t_p = 2.11 * Math.Sqrt(((f_p * Y * (m - (Y / 2.0))) / F_y));
            }

            //Check on the tension side
            double t_p_tension   = 0;
            bool   IsLargeMoment = GetIsLargeMoment(P_u, M_u, Y, Axis);

            if (IsLargeMoment == true)
            {
                double T_u    = GetTensionForceEccentricLoadStrongAxis(P_u, M_u, Axis, f_anchor);
                double l_tens = this.Plate.Get_l_tension(BendingAxis.Major);

                t_p_tension = 2.11 * Math.Sqrt((T_u * l_tens) / (B_bp * F_y));  // DG01(3.4.7a)
            }


            //Return larger of tension and bearing interfaces
            return(Math.Max(t_p, t_p_tension));
        }
Exemple #13
0
 public override double Get_l_tension(BendingAxis Axis)
 {
     return(f_anchor / 2.0 - D / 4.0);
 }
 public abstract double Get_l_tension(BendingAxis Axis);
        public bool DetermineIfBasePlateMeetsMinimumSizeLimits(double P_u, double M_u, BendingAxis Axis, double f_anchor)
        {
            CalculateBasePlateCommonParameters(P_u, M_u, Axis);

            double Cr1 = Math.Pow((f_anchor + N_bp / 2.0), 2);
            double Cr2 = (2.0 * P_u * (e + f_anchor)) / q_pMax;

            if (Cr1 < Cr2)
            {
                return(false);
            }
            else
            {
                return(true);
            }
        }
        public virtual double GetTensionForceEccentricLoadStrongAxis(double P_u, double M_u, BendingAxis Axis, double f_anchor)
        {
            double Y = GetBearingLengthY(P_u, M_u, Axis, f_anchor);
            CalculateBasePlateCommonParameters(P_u, M_u, Axis);
            double T = q_pMax * Y - P_u;

            return T;


        }
        public virtual double GetTensionForceEccentricLoadStrongAxis(double P_u, double M_u, BendingAxis Axis, double f_anchor)
        {
            double Y = GetBearingLengthY(P_u, M_u, Axis, f_anchor);

            CalculateBasePlateCommonParameters(P_u, M_u, Axis);
            double T = q_pMax * Y - P_u;

            return(T);
        }
        private double Get_f_p(double P_u, double M_u, double Y, BendingAxis Axis)
        {

            double f_p;  
            double e_critical = Get_e_critical(P_u, M_u, Axis);
            if (e <= e_critical)
            {
                //Small moment base plate
               f_p= P_u / (B_bp * Y);
            }
            else
            {
                //Large moment base plate
                f_p = Get_f_pMax(f_c, A_1, A_2);
            }

            return f_p;
        }
 private double Get_e_critical(double P_u, double M_u, BendingAxis Axis)
 {
     CalculateBasePlateCommonParameters(P_u, M_u, Axis);
     double e_crit = ((N_bp) / (2)) - ((P_u) / (2 * q_pMax));
     return e_crit;
 }
        double Get_q_pMax(double f_c, BendingAxis Axis,double A_1, double A_2)
        {
            double f_pMax = Get_f_pMax(f_c,A_1, A_2);
            double q_pMax = 0.0;

            if (Axis == BendingAxis.Major)
            {
                q_pMax = f_pMax * B_bp;
            }
            else
            {
                q_pMax = f_pMax * N_bp;
            }

            return q_pMax;
        }
        double GetBearingLengthY(double P_u, double M_u, BendingAxis Axis, double f_anchor)
        {
            CalculateBasePlateCommonParameters(P_u, M_u, Axis);
            double Y = 0.0;

            double e_critical = Get_e_critical(P_u, M_u, Axis);
            if (e <= e_critical)
            {
                //Small moment base plate
                Y = N_bp - 2.0 * e;
            }
            else
            {
                //Large moment base plate
                //DG01  3.4.3
                double Y1 = (f_anchor + ((N_bp) / (2))) + Math.Sqrt(Math.Pow((f_anchor + ((N_bp) / (2))), 2) - ((2 * P_u * (e + f_anchor)) / q_pMax));
                double Y2 = (f_anchor + ((N_bp) / (2))) - Math.Sqrt(Math.Pow((f_anchor + ((N_bp) / (2))), 2) - ((2 * P_u * (e + f_anchor)) / q_pMax));
                List<double> BearingLengths = new List<double>() { Y1, Y2 };
                Y = BearingLengths.Where(y => y > 0 && y < N_bp).Max();
            }


            return Y;
        }
        public bool DetermineIfBasePlateMeetsMinimumSizeLimits(double P_u, double M_u,  BendingAxis Axis, double f_anchor)
        {
            CalculateBasePlateCommonParameters(P_u, M_u, Axis);

            double Cr1 = Math.Pow((f_anchor+N_bp / 2.0), 2);
            double Cr2 =(2.0*P_u*(e+f_anchor)) / q_pMax;
             if (Cr1<Cr2)
	        {
		         return false;
	        }
             else
	        {
                 return true;
	        }
           
        }