public double Moment(double X)
        {
            beam.EvaluateX(X);
            double M;

            if (X <= L / 2.0)
            {
                M = 5.0 / 16.0 * P * X;
                BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
                                             new Dictionary <string, double>()
                {
                    { "X", X },
                    { "P", P }
                }, CASE, beam);
            }
            else
            {
                M = P * (L / 2.0 - 11.0 / 16.0 * X);
                BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 2,
                                             new Dictionary <string, double>()
                {
                    { "L", L },
                    { "X", X },
                    { "P", P }
                }, CASE, beam);
            }
            return(M);
        }
Esempio n. 2
0
        public double Moment(double X)
        {
            beam.EvaluateX(X);
            if (ReactionsWereCalculated == false)
            {
                CalculateReactions();
            }
            double M;
            double R1 = V1;

            if (X <= a)
            {
                M = R1 * X;
                BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
                                             new Dictionary <string, double>()
                {
                    { "R1", R1 },
                    { "X", X }
                }, CASE, beam);
            }
            else
            {
                M = R1 * X - P * (X - a);
                BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
                                             new Dictionary <string, double>()
                {
                    { "R1", R1 },
                    { "X", X },
                    { "P", P },
                    { "P", P },
                    { "a", a }
                }, CASE, beam);
            }
            return(M);
        }
        public double Moment(double X)
        {
            beam.EvaluateX(X);
            if (ReactionsWereCalculated == false)
            {
                CalculateReactions();
            }
            if (DimensionsWereCalculated == false)
            {
                CalculateDimensions();
            }

            double M;

            if (X <= a) //left-hand segment
            {
                M = R1 * X;
                BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
                                             new Dictionary <string, double>()
                {
                    { "R1", R1 },
                    { "X", X }
                }, CASE, beam);
            }
            else if (X >= a + b) //right-hand segment
            {
                M = R1 * X - w * b * (X - d);
                BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 3,
                                             new Dictionary <string, double>()
                {
                    { "R1", R1 },
                    { "X", X },
                    { "w", w },
                    { "d", d },
                    { "b", b }
                }, CASE, beam);
            }
            else
            {
                M = R1 * X - w / 2.0 * Math.Pow(X - a, 2);
                BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 2,
                                             new Dictionary <string, double>()
                {
                    { "L", L },
                    { "X", X },
                    { "w", w },
                    { "R1", R1 },
                    { "a", a },
                }, CASE, beam);
            }
            return(M);
        }
        public double Moment(double X)
        {
            beam.EvaluateX(X);
            double M;

            M = Mo / (2.0 * L) * (2.0 * L - 3.0 * X);
            BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
                                         new Dictionary <string, double>()
            {
                { "L", L },
                { "X", X },
                { "Mo", Mo }
            }, CASE, beam);
            return(M);
        }
Esempio n. 5
0
        public double Moment(double X)
        {
            beam.EvaluateX(X);
            if (ReactionsWereCalculated == false)
            {
                CalculateReactions();
            }
            double M = R1 * X - w * X * X / 2.0;

            BeamEntryFactory.CreateEntry("Mx", M, BeamTemplateType.Mx, 1,
                                         new Dictionary <string, double>()
            {
                { "R1", R1 },
                { "w", w },
                { "L", L },
                { "X", X }
            }, CASE, beam);
            return(M);
        }