Esempio n. 1
0
        /// <summary>
        /// Case 9: Calculation of internal forces in symmetric section for given state of strain with inclined neutral axis
        /// </summary>
        public void Case9()
        {
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.0, 0.0);
            geometry.Add(0.0, 0.6);
            geometry.Add(0.3, 0.6);
            geometry.Add(0.3, 0.0);
            // rebars definition
            List <Rebar> rebars    = new List <Rebar>();
            double       rebarArea = 0.012 * 0.012 * Math.PI / 4.0;

            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.05, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.05, rebarArea));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.SetStrainStressModelBiLinear(25e6, 0.003, 28e9, 0.002);
            // steel parameters
            Steel steel = new Steel();

            steel.SetModelIdealElastoPlastic(550e6, 0.1, 200e9);
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveForces(ResultType.Section, 0.0025, -0.00383423, 0.34906585);
            // result for rebars
            SetOfForces forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            SetOfForces forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Point2D     Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            double      Acc            = solver.GetConcreteStressArea();
            // result for RC section
            SetOfForces forces = solver.GetInternalForces(ResultType.Section);

            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 9: Calculation of internal forces in symmetric section for given state of strain with inclined neutral axis ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
        }
Esempio n. 2
0
        /// <summary>
        /// Case 14: Calculation of capacity state in symmetric section for bidirectional bending with axial force
        /// </summary>
        public void Case14()
        {
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.0, 0.0);
            geometry.Add(0.3, 0.0);
            geometry.Add(0.3, 0.45);
            geometry.Add(0.0, 0.45);
            // rebars definition
            List <Rebar> rebars = new List <Rebar>();

            rebars.Add(new Rebar(0.15, 0.04, 0.025977 * 0.025977 * Math.PI / 4.0));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.SetStrainStressModelRectangular(21.36e6, 0.0035, 35e9, 0.8);
            // steel parameters
            Steel steel = new Steel();

            steel.SetModelIdealElastoPlastic(310e6, 0.01, 200e9);
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistance(200E3, -96E3, -24E3);
            // result for rebars
            SetOfForces forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            SetOfForces forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Point2D     Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            double      Acc            = solver.GetConcreteStressArea();
            // result for RC section
            SetOfForces forces = solver.GetInternalForces(ResultType.Section);
            double      angle  = solver.GetNeutralAxisAngle();
            double      dist   = solver.GetNeutralAxisDistance();

            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 14: Calculation of capacity state in symmetric section for bidirectional bending with axial force ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            sb.AppendLine(FormatOutput("dist", dist, 6));
            sb.AppendLine(FormatOutput("angle", angle, 6));
        }
Esempio n. 3
0
        /// <summary>
        /// Case 4: Calculation of internal forces for given state of strain in the section and bilinear model of concrete
        /// Case 4a, Case 4b and Case 4c - common geometry, concrete and steel parameters different rebars and calculation
        /// </summary>
        public void Case4()
        {
            // Case 4a:
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.0, 0.0);
            geometry.Add(0.0, 0.6);
            geometry.Add(0.3, 0.6);
            geometry.Add(0.3, 0.0);
            // rebars definition
            List <Rebar> rebars    = new List <Rebar>();
            double       rebarArea = 0.016 * 0.016 * Math.PI / 4.0;

            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.05, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.05, rebarArea));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.SetStrainStressModelBiLinear(30e6, 0.0035, 32e9, 0.002);
            // steel parameters
            Steel steel = new Steel();

            steel.SetModelIdealElastoPlastic(400e6, 0.1, 205e9);
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveForces(ResultType.Section, 0.0035, 0.0005);
            // result for rebars
            SetOfForces forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            SetOfForces forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Point2D     Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            double      Acc            = solver.GetConcreteStressArea();
            // result for RC section
            SetOfForces forces = solver.GetInternalForces(ResultType.Section);

            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 4a: Calculation of internal forces for given state of strain in the section and bilinear model of concrete ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            output.Text = output.Text + sb.AppendLine();
            //
            // Case 4b
            rebars.Clear();
            rebarArea = 0.032 * 0.032 * Math.PI / 4.0;
            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.05, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.05, rebarArea));
            solver.SetRebars(rebars);
            //calulation
            solver.SolveForces(ResultType.Section, 0.0035, -0.02936558);
            // result for rebars
            forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            Acc            = solver.GetConcreteStressArea();
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 4b: Calculation of internal forces for given state of strain in the section and bilinear model of concrete ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            output.Text = output.Text + sb.AppendLine();
            //
            // Case 4c
            rebars.Clear();
            rebarArea = 0.032 * 0.032 * Math.PI / 4.0;
            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.25, 0.05, rebarArea));
            solver.SetRebars(rebars);
            //calulation
            solver.SolveForces(ResultType.Section, 0.0015, -0.002);
            // result for rebars
            forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            Acc            = solver.GetConcreteStressArea();
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 4c: Calculation of internal forces for given state of strain in the section and bilinear model of concrete ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            output.Text = output.Text + sb.AppendLine();
        }
Esempio n. 4
0
        RCSolver solver;                     // solver
        /// <summary>
        /// Initializes a new instance of the new RC calculation helper object.
        /// </summary>
        /// <param name="type">The type of the cross-section</param>
        /// <param name="rcGeometry">Set of geometry parameters.</param>
        /// <param name="coverTop">The top cover - to the reinforcement ceneter.</param>
        /// <param name="coverBottom">The top cover - to the reinforcement ceneter.</param>
        private RcVerificationHelperUtility(SectionShapeType type, ref Geometry rcGeometry, double coverTop, double coverBottom)
        {
            double totalHeight = 0;                             // the height of the cross section
            double totalWidth  = 0;                             // the width of the cross section

            noTopBottom      = 5;                               // initial value of the number of bars on top and bottom
            noLeftRight      = noTopBottom - 2;                 // initial value of the number of bars on left and right
            solverGeometry   = new Geometry();                  // initialization of new geometry
            rebars           = new List <Rebar>();              // initialization of rebars list
            rebarsSide       = new List <CrossSectionSide>();   // initialization of bars position list
            crossSectionType = type;                            // set of section type
            rebarCover       = Math.Max(coverTop, coverBottom); // set of maximum cover
            rebarCoverTop    = coverTop;                        // set of top cover
            rebarCoverBottom = coverBottom;                     // set of bottom cover
            // In the input geometry left bottom corner is searched.
            // The maximum and minimum values for x and y coordinates
            int     leftBottomIndex = 0;
            double  x     = Double.MaxValue;
            double  y     = Double.MaxValue;
            double  xMin  = Double.MaxValue;
            double  yMin  = Double.MaxValue;
            double  xMax  = Double.MinValue;
            double  yMax  = Double.MinValue;
            int     i     = 0;
            int     count = rcGeometry.Count;
            Point2D p     = new Point2D(0, 0);

            for (i = 0; i < count; i++)
            {
                p    = rcGeometry.Point(i);
                xMin = Math.Min(xMin, p.X);
                yMin = Math.Min(yMin, p.Y);
                xMax = Math.Max(xMax, p.X);
                yMax = Math.Max(yMax, p.Y);
                if ((p.X - x) < geometryEpsilon)
                {
                    if ((p.Y - y) < geometryEpsilon)
                    {
                        y = p.Y;
                        x = p.X;
                        leftBottomIndex = i;
                    }
                }
            }
            totalHeight = (yMax - yMin);
            totalWidth  = (xMax - xMin);
            // The first point of new geometry will be in the bottom left point of geometry.
            // This is made for easy detailing.
            if (0 != leftBottomIndex)
            {
                solverGeometry.Clear();
                for (i = leftBottomIndex; i < count; i++)
                {
                    p = rcGeometry.Point(i);
                    solverGeometry.Add(p.X, p.Y);
                }
                count = leftBottomIndex;
                for (i = 0; i < count; i++)
                {
                    p = rcGeometry.Point(i);
                    solverGeometry.Add(p.X, p.Y);
                }
            }
            else
            {
                solverGeometry = rcGeometry;
            }
            // The orientation is changed if it is necessary.
            if (solverGeometry.isClockwiseOrientation()) // clockwise direction
            {
                count = solverGeometry.Count - 1;
                Geometry tmpGeometry = new Geometry();
                p = solverGeometry.Point(0);
                tmpGeometry.Add(p.X, p.Y);
                for (i = count; i > 0; i--)
                {
                    p = solverGeometry.Point(i);
                    tmpGeometry.Add(p.X, p.Y);
                }
                solverGeometry = tmpGeometry;
            }
            solver = RCSolver.CreateNewSolver(solverGeometry); // solver with geometry redy to use.
        }
Esempio n. 5
0
        /// <summary>
        /// Case 16: Calculation of capacity state in symmetric section for fixed axial force
        /// </summary>
        public void Case16()
        {
            // Case 16a
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.0, 0.0);
            geometry.Add(0.0, 0.6);
            geometry.Add(0.3, 0.6);
            geometry.Add(0.3, 0.0);
            // rebars definition
            List <Rebar> rebars    = new List <Rebar>();
            double       rebarArea = 0.040 * 0.040 * Math.PI / 4.0;

            rebars.Add(new Rebar(0.03, 0.03, rebarArea));
            rebars.Add(new Rebar(0.03, 0.57, rebarArea));
            rebars.Add(new Rebar(0.27, 0.57, rebarArea));
            rebars.Add(new Rebar(0.27, 0.03, rebarArea));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.SetStrainStressModelRectangular(17.12e6, 0.0035, 32e9, 0.8);
            // steel parameters
            Steel steel = new Steel();

            steel.SetModelIdealElastoPlastic(310e6, 0.025, 200e9);
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistanceM(678E3, Axis.x, false);
            // result for rebars
            SetOfForces forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            SetOfForces forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Point2D     Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            double      Acc            = solver.GetConcreteStressArea();
            // result for RC section
            SetOfForces forces = solver.GetInternalForces(ResultType.Section);
            double      angle  = solver.GetNeutralAxisAngle();
            double      dist   = solver.GetNeutralAxisDistance();

            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 16a: Calculation of capacity state in symmetric section for fixed axial force");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            sb.AppendLine(FormatOutput("dist", dist, 6));
            sb.AppendLine(FormatOutput("angle", angle, 6));

            // Case 16b
            // geometry definition
            geometry = new Geometry();
            geometry.Add(0.0, 0.0);
            geometry.Add(0.0, 0.3);
            geometry.Add(0.6, 0.3);
            geometry.Add(0.6, 0.0);
            // rebars definition
            rebars.Clear();
            rebarArea = 0.036 * 0.036 * Math.PI / 4.0;
            rebars.Add(new Rebar(0.09, 0.06, rebarArea));
            rebars.Add(new Rebar(0.09, 0.12, rebarArea));
            rebars.Add(new Rebar(0.09, 0.18, rebarArea));
            rebars.Add(new Rebar(0.09, 0.24, rebarArea));
            rebars.Add(new Rebar(0.51, 0.06, rebarArea));
            rebars.Add(new Rebar(0.51, 0.12, rebarArea));
            rebars.Add(new Rebar(0.51, 0.18, rebarArea));
            rebars.Add(new Rebar(0.51, 0.24, rebarArea));
            // steel parameters
            steel = new Steel();
            steel.DesignStrength      = 420e6;
            steel.HardeningFactor     = 1.0;
            steel.ModulusOfElasticity = 200e9;
            steel.StrainUltimateLimit = 0.025;
            // solver creation and parameterization
            solver = RCSolver.CreateNewSolver(geometry);
            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistanceM(1700E3, Axis.y, true);
            // result for rebars
            forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            Acc            = solver.GetConcreteStressArea();
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            angle  = solver.GetNeutralAxisAngle();
            dist   = solver.GetNeutralAxisDistance();
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 16b: Calculation of capacity state in symmetric section for fixed axial force");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            sb.AppendLine(FormatOutput("dist", dist, 6));
            sb.AppendLine(FormatOutput("angle", angle, 6));
        }
Esempio n. 6
0
        /// <summary>
        /// Case 10: Calculation of capacity state in symmetric section for bending moment Mx
        /// </summary>
        public void Case10()
        {
            // Case 10a
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.0, 0.0);
            geometry.Add(0.0, 0.6);
            geometry.Add(0.3, 0.6);
            geometry.Add(0.3, 0.0);
            // rebars definition
            List <Rebar> rebars    = new List <Rebar>();
            double       rebarArea = 0.020 * 0.020 * Math.PI / 4.0;

            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.25, 0.05, rebarArea));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.SetStrainStressModelRectangular(20e6, 0.0035, 30e9, 0.9);
            // steel parameters
            Steel steel = new Steel();

            steel.SetModelIdealElastoPlastic(500e6, 0.075, 200e9);
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistanceM(0, Axis.x, false);
            // result for rebars
            SetOfForces forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            SetOfForces forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Point2D     Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            double      Acc            = solver.GetConcreteStressArea();
            // result for RC section
            SetOfForces forces = solver.GetInternalForces(ResultType.Section);
            double      angle  = solver.GetNeutralAxisAngle();
            double      dist   = solver.GetNeutralAxisDistance();

            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 10a: Calculation of internal forces in symmetric section for given state of strain with inclined neutral axis");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            sb.AppendLine(FormatOutput("dist", dist, 6));
            sb.AppendLine(FormatOutput("angle", angle, 6));
            // Case 10b
            // rebars definition
            rebarArea = 0.032 * 0.032 * Math.PI / 4.0;
            rebars.Clear();
            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.05, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.05, rebarArea));
            // concrete parameters
            concrete.SetStrainStressModelParabolicRectangular(30e6, 0.0035, 32e9, 0.0020);
            // steel parameters
            steel.DesignStrength      = 400e6;
            steel.StrainUltimateLimit = 0.1;
            // solver parameterization
            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistanceM(0, Axis.x, false);
            // result for rebars
            forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            Acc            = solver.GetConcreteStressArea();
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 10b: Calculation of internal forces in symmetric section for given state of strain with inclined neutral axis ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
        }
        /// </structural_toolkit_2015>

        /// <summary>
        /// Initializes a new instance of the new RC calculation helper object.
        /// </summary>
        /// <param name="type">The type of the cross-section</param>
        /// <param name="rcGeometry">Set of geometry parameters.</param>
        /// <param name="coverTop">The top cover - to the reinforcement ceneter.</param>
        /// <param name="coverBottom">The top cover - to the reinforcement ceneter.</param>
        private RcVerificationHelperUtility(SectionShapeType type, ref Geometry rcGeometry, double coverTop, double coverBottom)
        {
            totalHeight      = 0;                               // initial value of the height of the cross section
            totalWidth       = 0;                               // initial value of the width of the cross section
            noTopBottom      = 5;                               // initial value of the number of bars on top and bottom
            noLeftRight      = noTopBottom - 2;                 // initial value of the number of bars on left and right
            solverGeometry   = new Geometry();                  // initialization of new geometry
            rebars           = new List <Rebar>();              // initialization of rebars list
            rebarsSide       = new List <CrossSectionSide>();   // initialization of bars position list
            crossSectionType = type;                            // set of section type
            rebarCover       = Math.Max(coverTop, coverBottom); // set of maximum cover
            rebarCoverTop    = coverTop;                        // set of top cover
            rebarCoverBottom = coverBottom;                     // set of bottom cover
            /// <structural_toolkit_2015>
            edgesForReinforcement = new Dictionary <CrossSectionSide, Tuple <int, int> >();
            geometryMinX          = Double.MaxValue;
            geometryMinY          = Double.MaxValue;
            geometryMaxX          = Double.MinValue;
            geometryMaxY          = Double.MinValue;
            /// </structural_toolkit_2015>
            // Top,bottom, lreft and right edges are searched, based on maximum and minimum values for x and y coordinates
            /// <structural_toolkit_2015>
            solverGeometry = rcGeometry;
            int     count = solverGeometry.Count;
            Point2D p     = new Point2D(0, 0);

            // The orientation is changed if it is necessary.
            if (solverGeometry.isClockwiseOrientation()) // clockwise direction
            {
                Geometry tmpGeometry = new Geometry();
                p = solverGeometry.Point(0);
                tmpGeometry.Add(p.X, p.Y);
                for (int i = count - 1; i > 0; i--)
                {
                    p = solverGeometry.Point(i);
                    tmpGeometry.Add(p.X, p.Y);
                }
                solverGeometry = tmpGeometry;
            }
            foreach (Point2D p2D in solverGeometry)
            {
                geometryMinX = Math.Min(geometryMinX, p2D.X);
                geometryMinY = Math.Min(geometryMinY, p2D.Y);
                geometryMaxX = Math.Max(geometryMaxX, p2D.X);
                geometryMaxY = Math.Max(geometryMaxY, p2D.Y);
            }
            Tuple <int, int> curentTuple = null;

            for (int i = 0; i < count; i++)
            {
                p = solverGeometry.Point(i);
                // Left
                if (CompareGeomety(geometryMinX, p.X) >= 0)
                {
                    if (!edgesForReinforcement.ContainsKey(CrossSectionSide.Left) || CompareGeomety(geometryMinX, p.X) > 0)
                    {
                        curentTuple = new Tuple <int, int>(i, i);
                    }
                    else
                    {
                        if (CompareGeomety(p.Y, solverGeometry.Point(edgesForReinforcement[CrossSectionSide.Left].Item2).Y) > 0)
                        {
                            curentTuple = new Tuple <int, int>(edgesForReinforcement[CrossSectionSide.Left].Item1, i);
                        }
                        else if (CompareGeomety(p.Y, solverGeometry.Point(edgesForReinforcement[CrossSectionSide.Left].Item1).Y) < 0)
                        {
                            curentTuple = new Tuple <int, int>(i, edgesForReinforcement[CrossSectionSide.Left].Item2);
                        }
                    }
                    edgesForReinforcement.Remove(CrossSectionSide.Left);
                    edgesForReinforcement.Add(CrossSectionSide.Left, curentTuple);
                }
                // Right
                if (CompareGeomety(geometryMaxX, p.X) <= 0)
                {
                    if (!edgesForReinforcement.ContainsKey(CrossSectionSide.Right) || CompareGeomety(geometryMaxX, p.X) < 0)
                    {
                        curentTuple = new Tuple <int, int>(i, i);
                    }
                    else
                    {
                        if (CompareGeomety(p.Y, solverGeometry.Point(edgesForReinforcement[CrossSectionSide.Right].Item2).Y) > 0)
                        {
                            curentTuple = new Tuple <int, int>(edgesForReinforcement[CrossSectionSide.Right].Item1, i);
                        }
                        else if (CompareGeomety(p.Y, solverGeometry.Point(edgesForReinforcement[CrossSectionSide.Right].Item1).Y) < 0)
                        {
                            curentTuple = new Tuple <int, int>(i, edgesForReinforcement[CrossSectionSide.Right].Item2);
                        }
                    }
                    edgesForReinforcement.Remove(CrossSectionSide.Right);
                    edgesForReinforcement.Add(CrossSectionSide.Right, curentTuple);
                }
                // Top
                if (CompareGeomety(geometryMaxY, p.Y) <= 0)
                {
                    if (!edgesForReinforcement.ContainsKey(CrossSectionSide.Top) || CompareGeomety(geometryMaxY, p.Y) < 0)
                    {
                        curentTuple = new Tuple <int, int>(i, i);
                    }
                    else
                    {
                        if (CompareGeomety(p.X, solverGeometry.Point(edgesForReinforcement[CrossSectionSide.Top].Item2).X) > 0)
                        {
                            curentTuple = new Tuple <int, int>(edgesForReinforcement[CrossSectionSide.Top].Item1, i);
                        }
                        else if (CompareGeomety(p.X, solverGeometry.Point(edgesForReinforcement[CrossSectionSide.Top].Item1).X) < 0)
                        {
                            curentTuple = new Tuple <int, int>(i, edgesForReinforcement[CrossSectionSide.Top].Item2);
                        }
                    }
                    edgesForReinforcement.Remove(CrossSectionSide.Top);
                    edgesForReinforcement.Add(CrossSectionSide.Top, curentTuple);
                }
                // Bottom
                if (CompareGeomety(geometryMinY, p.Y) >= 0)
                {
                    if (!edgesForReinforcement.ContainsKey(CrossSectionSide.Bottom) || CompareGeomety(geometryMinY, p.Y) > 0)
                    {
                        curentTuple = new Tuple <int, int>(i, i);
                    }
                    else
                    {
                        if (CompareGeomety(p.X, solverGeometry.Point(edgesForReinforcement[CrossSectionSide.Bottom].Item2).X) > 0)
                        {
                            curentTuple = new Tuple <int, int>(edgesForReinforcement[CrossSectionSide.Bottom].Item1, i);
                        }
                        else if (CompareGeomety(p.X, solverGeometry.Point(edgesForReinforcement[CrossSectionSide.Bottom].Item1).X) < 0)
                        {
                            curentTuple = new Tuple <int, int>(i, edgesForReinforcement[CrossSectionSide.Bottom].Item2);
                        }
                    }
                    edgesForReinforcement.Remove(CrossSectionSide.Bottom);
                    edgesForReinforcement.Add(CrossSectionSide.Bottom, curentTuple);
                }
            }
            /// </structural_toolkit_2015>

            totalHeight = (geometryMaxY - geometryMinY);
            totalWidth  = (geometryMaxX - geometryMinX);
            solver      = RCSolver.CreateNewSolver(solverGeometry); // solver with geometry redy to use.
        }
Esempio n. 8
0
        /// <summary>
        /// Case 12: Calculation of capacity state in symmetric section for bending moment Mx with axial force
        /// </summary>
        public void Case12()
        {
            // Case 12a
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.0, 0.0);
            geometry.Add(0.3, 0.0);
            geometry.Add(0.3, 0.6);
            geometry.Add(0.0, 0.6);
            // rebars definition
            List <Rebar> rebars    = new List <Rebar>();
            double       rebarArea = 0.012 * 0.012 * Math.PI / 4.0;

            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.05, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.05, rebarArea));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.SetStrainStressModelLinear(20e6, 0.0035, 30e9);
            // steel parameters
            Steel steel = new Steel();

            steel.SetModelIdealElastoPlastic(500e6, 0.075, 200e9);
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistance(43979.98E3, -3465.40E3, 0);
            // result for rebars
            SetOfForces forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            SetOfForces forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Point2D     Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            double      Acc            = solver.GetConcreteStressArea();
            // result for RC section
            SetOfForces forces = solver.GetInternalForces(ResultType.Section);
            double      angle  = solver.GetNeutralAxisAngle();
            double      dist   = solver.GetNeutralAxisDistance();

            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 12a:  Calculation of capacity state in symmetric section for bending moment Mx with axial force ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            sb.AppendLine(FormatOutput("dist", dist, 6));
            sb.AppendLine(FormatOutput("angle", angle, 6));

            // Case 12b
            // rebars definition
            rebars.Clear();
            rebarArea = 0.016 * 0.016 * Math.PI / 4.0;
            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.05, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.55, rebarArea));
            rebars.Add(new Rebar(0.25, 0.05, rebarArea));
            // concrete parameters
            concrete.SetStrainStressModelBiLinear(30e6, 0.0035, 32e9, 0.0020);
            // steel parameters
            steel.DesignStrength      = 400e6;
            steel.HardeningFactor     = 1.0;
            steel.ModulusOfElasticity = 205e9;
            steel.StrainUltimateLimit = 0.1;
            // solver parameterization
            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistance(114.8397E3, -5.634275E3, 0);
            // result for rebars
            forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            Acc            = solver.GetConcreteStressArea();
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 12b:Calculation of capacity state in symmetric section for bending moment Mx with axial force");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));

            // Case 12c
            // concrete parameters
            concrete.SetStrainStressModelPowerRectangular(30e6, 0.0035, 32e9, 0.002, 1.4);
            // steel parameters
            steel.DesignStrength      = 400e6;
            steel.HardeningFactor     = 1.0;
            steel.ModulusOfElasticity = 200e9;
            steel.StrainUltimateLimit = 0.1;
            // solver parameterization
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistance(4.41023E3, -0.1662045455E3, 0);
            // result for rebars
            forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            Acc            = solver.GetConcreteStressArea();
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 12c: Calculation of capacity state in symmetric section for bending moment Mx with axial force ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
        }
Esempio n. 9
0
        /// <summary>
        /// Case 7 Calculation of internal forces for given state of strain in the section and inclined branch model of steel
        /// </summary>
        public void Case7()
        {
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.0, 0.0);
            geometry.Add(0.0, 0.6);
            geometry.Add(0.3, 0.6);
            geometry.Add(0.3, 0.0);
            // rebars definition
            List <Rebar> rebars = new List <Rebar>();

            rebars.Add(new Rebar(0.05, 0.05, 0.032 * 0.032 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.15, 0.05, 0.032 * 0.032 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.25, 0.05, 0.032 * 0.032 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.05, 0.15, 0.020 * 0.020 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.25, 0.15, 0.020 * 0.020 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.05, 0.55, 0.012 * 0.012 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.25, 0.55, 0.012 * 0.012 * Math.PI / 4.0));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.SetStrainStressModelLinear(20e6, 0.0035, 30e9);
            // steel parameters
            Steel steel = new Steel();

            steel.SetModelWithHardening(500e6, 0.075, 200e9, 1.05);
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveForces(ResultType.Section, 0.0035, -0.0070);
            // result for rebars
            SetOfForces forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            SetOfForces forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Point2D     Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            double      Acc            = solver.GetConcreteStressArea();
            // result for RC section
            SetOfForces forces = solver.GetInternalForces(ResultType.Section);

            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 7 Calculation of internal forces for given state of strain in the section and inclined branch model of steel ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
        }
Esempio n. 10
0
        /// <summary>
        /// Case 15: Calculation of capacity state in asymmetric section for bidirectional bending with axial force
        /// </summary>
        public void Case15()
        {
            // Case 15a
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.00, 0.00);
            geometry.Add(0.00, 0.60);
            geometry.Add(0.25, 0.60);
            geometry.Add(0.25, 0.25);
            geometry.Add(0.70, 0.25);
            geometry.Add(0.70, 0.00);
            // rebars definition
            List <Rebar> rebars    = new List <Rebar>();
            double       rebarArea = 0.020 * 0.020 * Math.PI / 4.0;

            rebars.Add(new Rebar(0.05, 0.05, rebarArea));
            rebars.Add(new Rebar(0.05, 0.55, rebarArea));
            rebars.Add(new Rebar(0.20, 0.55, rebarArea));
            rebars.Add(new Rebar(0.20, 0.05, rebarArea));
            rebars.Add(new Rebar(0.65, 0.05, rebarArea));
            rebars.Add(new Rebar(0.65, 0.20, rebarArea));
            rebars.Add(new Rebar(0.05, 0.20, rebarArea));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.SetStrainStressModelRectangular(20e6, 0.0035, 35e9, 0.8);
            // steel parameters
            Steel steel = new Steel();

            steel.SetModelIdealElastoPlastic(310e6, 0.075, 200e9);
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            //calulation
            solver.SolveResistance(72.4471E3, -28.9825E3, 2.5743E3);
            // result for rebars
            SetOfForces forcesRebar = solver.GetInternalForces(ResultType.Rebars);
            // result for concrete
            SetOfForces forcesConcrete = solver.GetInternalForces(ResultType.Concrete);
            Point2D     Gcc            = solver.GetStressGravityCenter(ResultType.Concrete);
            double      Acc            = solver.GetConcreteStressArea();
            // result for RC section
            SetOfForces forces = solver.GetInternalForces(ResultType.Section);
            double      angle  = solver.GetNeutralAxisAngle();
            double      dist   = solver.GetNeutralAxisDistance();

            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 15a: Calculation of capacity state in asymmetric section for bidirectional bending with axial force ");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ns", forcesRebar.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxs", forcesRebar.MomentX, 6));
            sb.AppendLine(FormatOutput("Mys", forcesRebar.MomentY, 6));
            sb.AppendLine(FormatOutput("Ac", Acc, 6));
            sb.AppendLine(FormatOutput("Gcx", Gcc.X, 6));
            sb.AppendLine(FormatOutput("Gcy", Gcc.Y, 6));
            sb.AppendLine(FormatOutput("Nc", forcesConcrete.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mxc", forcesConcrete.MomentX, 6));
            sb.AppendLine(FormatOutput("Myc", forcesConcrete.MomentY, 6));
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
            sb.AppendLine(FormatOutput("dist", dist, 6));
            sb.AppendLine(FormatOutput("angle", angle, 6));


            // Case 15b
            // concrete parameters (rectangular)
            concrete.SetStrainStressModelRectangular(20e6, 0.0035, 35e9, 0.8);
            // solver parameterization
            solver.SetConcrete(concrete);
            //calulation
            solver.SolveResistance(72.4471E3, -28.9825E3, 2.5743E3);
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 15b: Calculation of capacity state in asymmetric section for bidirectional bending with axial force (rectangular)");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));

            // concrete parameters(linear)
            concrete.SetStrainStressModelLinear(25e6, 0.0035, 32e9);
            // solver parameterization
            solver.SetConcrete(concrete);
            //calulation
            solver.SolveResistance(72.4471E3, -28.9825E3, 2.5743E3);
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 15b: Calculation of capacity state in asymmetric section for bidirectional bending with axial force (linear)");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));

            // concrete parameters (bilinear)
            concrete.SetStrainStressModelBiLinear(25e6, 0.0035, 32e9, 0.0020);
            // solver parameterization
            solver.SetConcrete(concrete);
            //calulation
            solver.SolveResistance(72.4471E3, -28.9825E3, 2.5743E3);
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 15b: Calculation of capacity state in asymmetric section for bidirectional bending with axial force (bilinear)");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));

            // concrete parameters (parabolic-rectangular)
            concrete.SetStrainStressModelParabolicRectangular(25e6, 0.0035, 32e9, 0.0020);
            // solver parameterization
            solver.SetConcrete(concrete);
            //calulation
            solver.SolveResistance(72.4471E3, -28.9825E3, 2.5743E3);
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 15b: Calculation of capacity state in asymmetric section for bidirectional bending with axial force (parabolic-rectangular)");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));

            // concrete parameters (power-rectangular)
            concrete.SetStrainStressModelPowerRectangular(25e6, 0.0035, 32e9, 0.002, 1.5);
            // solver parameterization
            solver.SetConcrete(concrete);
            //calulation
            solver.SolveResistance(72.4471E3, -28.9825E3, 2.5743E3);
            // result for RC section
            forces = solver.GetInternalForces(ResultType.Section);
            // result presentation
            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 15b: Calculation of capacity state in asymmetric section for bidirectional bending with axial force (parabolic-rectangular)");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("N", forces.AxialForce, 6));
            sb.AppendLine(FormatOutput("Mx", forces.MomentX, 6));
            sb.AppendLine(FormatOutput("My", forces.MomentY, 6));
        }
Esempio n. 11
0
        /// <summary>
        /// Case 1: Cross section characteristics
        /// </summary>
        public void Case1()
        {
            // geometry definition
            Geometry geometry = new Geometry();

            geometry.Add(0.0, 0.0);
            geometry.Add(0.0, 0.2);
            geometry.Add(0.2, 0.2);
            geometry.Add(0.2, 0.6);
            geometry.Add(0.5, 0.6);
            geometry.Add(0.5, 0.3);
            geometry.Add(0.8, 0.3);
            geometry.Add(0.8, 0.0);
            // rebars definition
            List <Rebar> rebars = new List <Rebar>();

            // rebar area A = d*d*pi/4
            rebars.Add(new Rebar(0.05, 0.05, 0.010 * 0.010 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.75, 0.05, 0.012 * 0.012 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.75, 0.25, 0.020 * 0.020 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.45, 0.55, 0.050 * 0.050 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.25, 0.55, 0.020 * 0.020 * Math.PI / 4.0));
            rebars.Add(new Rebar(0.05, 0.15, 0.015 * 0.015 * Math.PI / 4.0));
            // concrete parameters
            Concrete concrete = new Concrete();

            concrete.ModulusOfElasticity = 30e9;
            // steel parameters
            Steel steel = new Steel();

            steel.ModulusOfElasticity = 200e9;
            // solver creation and parameterization
            RCSolver solver = RCSolver.CreateNewSolver(geometry);

            solver.SetRebars(rebars);
            solver.SetConcrete(concrete);
            solver.SetSteel(steel);
            // result for concrete
            double  Ac  = solver.GetArea(ResultType.Concrete);
            Point2D Cc  = solver.GetCenterOfInertia(ResultType.Concrete);
            double  Icx = solver.GetMomentOfInertiaX(ResultType.Concrete);
            double  Icy = solver.GetMomentOfInertiaY(ResultType.Concrete);
            // result for rebars
            double  As  = solver.GetArea(ResultType.Rebars);
            Point2D Cs  = solver.GetCenterOfInertia(ResultType.Rebars);
            double  Isx = solver.GetMomentOfInertiaX(ResultType.Rebars);
            double  Isy = solver.GetMomentOfInertiaY(ResultType.Rebars);
            // result for reduced
            double  Aeff  = solver.GetArea(ResultType.Section);
            Point2D Ceff  = solver.GetCenterOfInertia(ResultType.Section);
            double  Ieffx = solver.GetMomentOfInertiaX(ResultType.Section);

            double Ieffy = solver.GetMomentOfInertiaY(ResultType.Section);

            // result presentation

            sb.AppendLine();
            sb.AppendLine(decoration);
            sb.AppendLine("Case 1: Cross section characteristics");
            sb.AppendLine(decoration);
            sb.AppendLine(FormatOutput("Ac", Ac, 6));
            sb.AppendLine(FormatOutput("Ccx", Cc.X, 6));
            sb.AppendLine(FormatOutput("Ccy", Cc.Y, 6));
            sb.AppendLine(FormatOutput("Icx", Icx, 6));
            sb.AppendLine(FormatOutput("Icy", Icy, 6));
            sb.AppendLine(FormatOutput("As", As, 6));
            sb.AppendLine(FormatOutput("Csx", Cs.X, 6));
            sb.AppendLine(FormatOutput("Csy", Cs.Y, 6));
            sb.AppendLine(FormatOutput("Isx", Isx, 6));
            sb.AppendLine(FormatOutput("Isy", Isy, 6));
            sb.AppendLine(FormatOutput("Aeff", Aeff, 6));
            sb.AppendLine(FormatOutput("Ceffx", Ceff.X, 6));
            sb.AppendLine(FormatOutput("Ceffy", Ceff.Y, 6));
            sb.AppendLine(FormatOutput("Ieffx", Ieffx, 6));
            sb.AppendLine(FormatOutput("Ieffy", Ieffy, 6));
        }