public double GetUtilizationRatio(HssKConnectionLoadCaseData LoadCase, out double RequiredAxialStrenghPro, 
            out double RequiredMomentStrengthMro)
        {
            ISteelSection chordSec = Chord as ISteelSection;
            double Umax = 0.0;
            double Fx = 0.0;
            double M = 0.0;

            if (chordSec!=null)
            {
                double D = GetChordDiameter();
                var forces = Chord.Forces.Where(f => f.LoadCaseName == LoadCase.LoadCaseName).ToList();
                foreach (var f in forces)
                {
                    Fx = Math.Abs(f.Fx);
                    M = Math.Sqrt(Math.Pow(f.My,2)+Math.Pow(f.Mz,2));
                    double U = GetUtilizationRatio(chordSec, Fx, M);
                } 
            }
            else
            {
                throw new Exception("Chord Member must implement ISteelSection interface");
            }

            RequiredAxialStrenghPro = Fx;
            RequiredMomentStrengthMro = M;
            return Umax;
        }
        public double GetUtilizationRatio(HssKConnectionLoadCaseData LoadCase, out double RequiredAxialStrenghPro,
                                          out double RequiredMomentStrengthMro)
        {
            ISteelSection chordSec = Chord as ISteelSection;
            double        Umax     = 0.0;
            double        Fx       = 0.0;
            double        M        = 0.0;

            if (chordSec != null)
            {
                double D      = GetChordDiameter();
                var    forces = Chord.Forces.Where(f => f.LoadCaseName == LoadCase.LoadCaseName).ToList();
                foreach (var f in forces)
                {
                    Fx = Math.Abs(f.Fx);
                    M  = Math.Sqrt(Math.Pow(f.My, 2) + Math.Pow(f.Mz, 2));
                    double U = GetUtilizationRatio(chordSec, Fx, M);
                }
            }
            else
            {
                throw new Exception("Chord Member must implement ISteelSection interface");
            }

            RequiredAxialStrenghPro   = Fx;
            RequiredMomentStrengthMro = M;
            return(Umax);
        }
        public double GetUtilizationRatio(HssKConnectionLoadCaseData LoadCase)
        {
            double P = 0.0;
            double M = 0.0;
            double U = GetUtilizationRatio(LoadCase, out P, out M);

            return(U);
        }
        public double GetUtilizationRatio(HssKConnectionLoadCaseData LoadCase)
        {
            double P = 0.0;
            double M = 0.0;
            double U = GetUtilizationRatio(LoadCase,out P, out M);

            return U;
        }
 internal double GetTensionBranchCapacity(HssKConnectionLoadCaseData loadCase, double D, double Qg, double Qf)
 {
     HssTrussConnectionBranch tensionBranch = loadCase.TensionBranch;
     double P_ChordPlastification = CheckChordPlastificationForTensionBranch(loadCase.LoadCaseName, D, Qf, Qg);
     double P =Math.Abs(P_ChordPlastification);
     //add capacity to branch info
     tensionBranch.AddStrengthValue(P, loadCase.LoadCaseName);
     return P;
 }
        internal double GetTensionBranchCapacity(HssKConnectionLoadCaseData loadCase, double D, double Qg, double Qf)
        {
            HssTrussConnectionBranch tensionBranch = loadCase.TensionBranch;
            double P_ChordPlastification           = CheckChordPlastificationForTensionBranch(loadCase.LoadCaseName, D, Qf, Qg);
            double P = Math.Abs(P_ChordPlastification);

            //add capacity to branch info
            tensionBranch.AddStrengthValue(P, loadCase.LoadCaseName);
            return(P);
        }
 internal double GetCompressionBranchCapacity(HssKConnectionLoadCaseData loadCase, double D, double Qg, double Qf)
 {
     HssTrussConnectionBranch compressionBranch = loadCase.CompressionBranch;
     double P_ChordPlastification = CheckChordPlastificationForCompressionBranch(loadCase.LoadCaseName, D, Qf, Qg);
     double P_ShearYielding = GetBranchShearYielding(compressionBranch);
     double P = Math.Min(Math.Abs(P_ChordPlastification), Math.Abs(P_ShearYielding));
     //add capacity to branch info here
     compressionBranch.AddStrengthValue(P, loadCase.LoadCaseName);
     return P;
 }
Example #8
0
        internal double GetCompressionBranchCapacity(HssKConnectionLoadCaseData loadCase, double D, double Qg, double Qf)
        {
            HssTrussConnectionBranch compressionBranch = loadCase.CompressionBranch;
            double P_ChordPlastification = CheckChordPlastificationForCompressionBranch(loadCase.LoadCaseName, D, Qf, Qg);
            double P_ShearYielding       = GetBranchShearYielding(compressionBranch);
            double P = Math.Min(Math.Abs(P_ChordPlastification), Math.Abs(P_ShearYielding));

            //add capacity to branch info here
            compressionBranch.AddStrengthValue(P, loadCase.LoadCaseName);
            return(P);
        }
        internal void DetermineTensionCompressionBranches(List<string> loadCaseList)
        {
            //prior to calculation of connection capacity need to determine
            //which branches are nesion and which are compression

            foreach (var caseName in loadCaseList)
            {
                HssTrussConnectionBranch compBranch = null;
                HssTrussConnectionBranch tensBranch = null;

                foreach (var b in Branches)
                {
                    //chnage this!!!!
                    double Fx = b.Forces.Where(f => f.LoadCaseName == caseName).ToList()[0].Fx; // first item in found forces
                    if (Fx<=0.0)
                    {
                        compBranch = b;
                    }
                    else
                    {
                        tensBranch = b;
                    }
                }

                HssKConnectionLoadCaseData data=null;
                
                if (compBranch!=null && tensBranch!=null)
                {
                     data = new HssKConnectionLoadCaseData(caseName, compBranch, tensBranch);
                }
                else
                {
                    throw new Exception("Failed to identify tension and compression branches in the connection");
                }

                

                if (this.loadCases == null)
	            {
                    loadCases = new Dictionary<string, HssKConnectionLoadCaseData>();
	            }
                loadCases.Add(caseName,data);
            }

        }
        internal void DetermineTensionCompressionBranches(List <string> loadCaseList)
        {
            //prior to calculation of connection capacity need to determine
            //which branches are nesion and which are compression

            foreach (var caseName in loadCaseList)
            {
                HssTrussConnectionBranch compBranch = null;
                HssTrussConnectionBranch tensBranch = null;

                foreach (var b in Branches)
                {
                    //chnage this!!!!
                    double Fx = b.Forces.Where(f => f.LoadCaseName == caseName).ToList()[0].Fx; // first item in found forces
                    if (Fx <= 0.0)
                    {
                        compBranch = b;
                    }
                    else
                    {
                        tensBranch = b;
                    }
                }

                HssKConnectionLoadCaseData data = null;

                if (compBranch != null && tensBranch != null)
                {
                    data = new HssKConnectionLoadCaseData(caseName, compBranch, tensBranch);
                }
                else
                {
                    throw new Exception("Failed to identify tension and compression branches in the connection");
                }



                if (this.loadCases == null)
                {
                    loadCases = new Dictionary <string, HssKConnectionLoadCaseData>();
                }
                loadCases.Add(caseName, data);
            }
        }