public ConcreteSectionCompression(ConcreteSectionFlexure FlexuralSection, CompressionMemberType CompressionMemberType, ICalcLog log)
            : base(FlexuralSection.Section, FlexuralSection.LongitudinalBars, log)
        {
            this.CompressionMemberType = CompressionMemberType;

            switch (CompressionMemberType)
            {
            case CompressionMemberType.NonPrestressedWithTies:
                ConfinementReinforcementType = ACI.ConfinementReinforcementType.Ties;
                break;

            case CompressionMemberType.NonPrestressedWithSpirals:
                ConfinementReinforcementType = ConfinementReinforcementType.Spiral;
                break;

            case CompressionMemberType.PrestressedWithTies:
                ConfinementReinforcementType = ConfinementReinforcementType.Ties;
                break;

            case CompressionMemberType.PrestressedWithSpirals:
                ConfinementReinforcementType = ConfinementReinforcementType.Spiral;
                break;

            default:
                ConfinementReinforcementType = ACI.ConfinementReinforcementType.Ties;
                break;
            }
        }
        internal RectangularSectionSinglyReinforced(double b, double h, double A_s, double c_cntr,
                                                    ConcreteMaterial ConcreteMaterial, RebarMaterial LongitudinalRebarMaterial, bool hasTies = false)
        {
            KodestructAci.ConfinementReinforcementType ConfinementReinforcementType;
            if (hasTies == true)
            {
                ConfinementReinforcementType = KodestructAci.ConfinementReinforcementType.Ties;
            }
            else
            {
                ConfinementReinforcementType = KodestructAci.ConfinementReinforcementType.NoReinforcement;
            }

            CrossSectionRectangularShape shape = new CrossSectionRectangularShape(ConcreteMaterial.Concrete, null, b, h);

            base.ConcreteMaterial = ConcreteMaterial; //duplicate save of concrete material into base Dynamo class

            List <KodestructAci.RebarPoint> LongitudinalBars = new List <KodestructAci.RebarPoint>();

            KodestructAci.Rebar      thisBar = new KodestructAci.Rebar(A_s, LongitudinalRebarMaterial.Material);
            KodestructAci.RebarPoint point   = new KodestructAci.RebarPoint(thisBar, new KodestructAci.RebarCoordinate()
            {
                X = 0, Y = -h / 2.0 + c_cntr
            });
            LongitudinalBars.Add(point);

            KodestructAci.IConcreteFlexuralMember fs = new KodestructAci14.ConcreteSectionFlexure(shape, LongitudinalBars, new CalcLog(), ConfinementReinforcementType);
            this.FlexuralSection = fs;
        }
        /// <summary>
        /// Concrete generic shape
        /// </summary>
        /// <param name="PolygonPoints">Points representing closed polyline describing the outline of concrete shape</param>
        /// <param name="Concrete">Concrete material</param>
        /// <param name="RebarPoints">Points representing vertical rebar. Rebar points have associated rebar material and location</param>
        /// <param name="b_w">Section width (required for shear strength calculations)</param>
        /// <param name="ConfinementReinforcementType"></param>
        /// <param name="d">Distance from tension rebar centroid to the furthermost compressed point (required for shear strength calculations)</param>
        /// <returns></returns>
        public ConcreteSectionFlexure GetGeneralSection(List <Point2D> PolygonPoints,
                                                        IConcreteMaterial Concrete, List <RebarPoint> RebarPoints, double b_w, double d,
                                                        ConfinementReinforcementType ConfinementReinforcementType = ConfinementReinforcementType.NoReinforcement)
        {
            CalcLog log                      = new CalcLog();
            var     GenericShape             = new PolygonShape(PolygonPoints);
            CrossSectionGeneralShape Section = new CrossSectionGeneralShape(Concrete, null, GenericShape, b_w, d);
            ConcreteSectionFlexure   beam    = new ConcreteSectionFlexure(Section, RebarPoints, log, ConfinementReinforcementType);

            return(beam);
        }
        public ConcreteSectionFlexure GetNonPrestressedDoublyReinforcedRectangularSection(double b, double h,
                                                                                          double A_s1, double A_s2, double c_cntr1, double c_cntr2,
                                                                                          double A_s_prime1, double A_s_prime2, double c_cntr_prime1, double c_cntr_prime2,
                                                                                          ConcreteMaterial concrete, IRebarMaterial rebar, ConfinementReinforcementType ConfinementReinforcementType)
        {
            CrossSectionRectangularShape Section          = new CrossSectionRectangularShape(concrete, null, b, h);
            List <RebarPoint>            LongitudinalBars = new List <RebarPoint>();

            Rebar      bottom1      = new Rebar(A_s1, rebar);
            RebarPoint pointBottom1 = new RebarPoint(bottom1, new RebarCoordinate()
            {
                X = 0, Y = -h / 2.0 + c_cntr1
            });

            LongitudinalBars.Add(pointBottom1);


            if (A_s2 != 0)
            {
                Rebar      bottom2      = new Rebar(A_s2, rebar);
                RebarPoint pointBottom2 = new RebarPoint(bottom2, new RebarCoordinate()
                {
                    X = 0, Y = -h / 2.0 + c_cntr2
                });
                LongitudinalBars.Add(pointBottom2);
            }

            if (A_s_prime1 != 0)
            {
                Rebar      top1      = new Rebar(A_s_prime1, rebar);
                RebarPoint pointTop1 = new RebarPoint(top1, new RebarCoordinate()
                {
                    X = 0, Y = h / 2.0 - c_cntr_prime1
                });
                LongitudinalBars.Add(pointTop1);
            }

            if (A_s_prime2 != 0)
            {
                Rebar      top2      = new Rebar(A_s_prime2, rebar);
                RebarPoint pointTop2 = new RebarPoint(top2, new RebarCoordinate()
                {
                    X = 0, Y = h / 2.0 - c_cntr_prime2
                });
                LongitudinalBars.Add(pointTop2);
            }

            CalcLog log = new CalcLog();
            ConcreteSectionFlexure beam = new ConcreteSectionFlexure(Section, LongitudinalBars, log, ConfinementReinforcementType);

            return(beam);
        }
        public void ShearWallCalculatesPMMDiagram()
        {
            double f_c_prime                         = 6;
            double f_c_prime_psi                     = f_c_prime * 1000;
            RebarMaterialFactory factory             = new RebarMaterialFactory();
            string         RebarSpecificationId      = "A615Grade60";
            IRebarMaterial LongitudinalRebarMaterial = factory.GetMaterial(RebarSpecificationId);
            double         h_total                   = 20 * 12;
            double         t_w                       = 12;
            double         N_curtains                = 2;
            double         s                         = 12;
            double         c_edge                    = 0;

            BoundaryZone BoundaryZoneTop    = new BoundaryZone(3, 3, "No8", 6, 3, 3);
            BoundaryZone BoundaryZoneBottom = new BoundaryZone(3, 3, "No8", 6, 3, 3);
            string       WallRebarSizeId    = "No4";


            FlexuralCompressionFiberPosition p    = FlexuralCompressionFiberPosition.Top;
            ConcreteMaterial             Concrete = new ConcreteMaterial(f_c_prime_psi, ConcreteTypeByWeight.Normalweight, null);
            ConfinementReinforcementType ConfinementReinforcementType = KodestructAci.ConfinementReinforcementType.Ties;

            CrossSectionRectangularShape shape = new CrossSectionRectangularShape(Concrete, null, t_w, h_total);

            List <KodestructAci.RebarPoint> LongitudinalBars = GetLongitudinalBars(shape.SliceableShape as ISectionRectangular, h_total, t_w, WallRebarSizeId, N_curtains, s, c_edge,
                                                                                   BoundaryZoneTop, BoundaryZoneBottom, LongitudinalRebarMaterial);

            KodestructAci.IConcreteFlexuralMember fs = new KodestructAci14.ConcreteSectionFlexure(shape, LongitudinalBars, null, ConfinementReinforcementType);

            IConcreteSectionWithLongitudinalRebar Section = fs as IConcreteSectionWithLongitudinalRebar;
            ConcreteSectionCompression            column  = new ConcreteSectionCompression(Section, ConfinementReinforcementType, null);
            //Convert axial force to pounds
            List <PMPair> Pairs         = column.GetPMPairs(p);
            var           PairsAdjusted = Pairs.Select(pair => new PMPair(pair.P / 1000.0, pair.M / 1000.0 / 12.0));

            string Filename = Path.Combine(Path.GetTempPath(), "PMInteractionShearWall.csv");

            using (CsvFileWriter writer = new CsvFileWriter(Filename))
            {
                foreach (var pair in PairsAdjusted)
                {
                    CsvRow row = new CsvRow();
                    row.Add(pair.M.ToString());
                    row.Add(pair.P.ToString());
                    writer.WriteRow(row);
                }
            }
        }
Esempio n. 6
0
        internal ShearWallSection(double h_total, double t_w,
                                  string RebarSizeId, double N_curtains, double s, double c_edge,
                                  BoundaryZone BoundaryZoneTop, BoundaryZone BoundaryZoneBottom,
                                  ConcreteMaterial ConcreteMaterial, RebarMaterial LongitudinalRebarMaterial)
        {
            ConfinementReinforcementType ConfinementReinforcementType = KodestructAci.ConfinementReinforcementType.Ties;

            base.ConcreteMaterial = ConcreteMaterial;
            CrossSectionIShape shape = GetIShape(ConcreteMaterial.Concrete, h_total, t_w, BoundaryZoneTop, BoundaryZoneBottom);

            List <KodestructAci.RebarPoint> LongitudinalBars = GetLongitudinalBars(shape.SliceableShape as ISectionI, h_total, t_w, RebarSizeId, N_curtains, s, c_edge,
                                                                                   BoundaryZoneTop, BoundaryZoneBottom, LongitudinalRebarMaterial);

            KodestructAci.IConcreteFlexuralMember fs = new KodestructAci14.ConcreteSectionFlexure(shape, LongitudinalBars, new CalcLog(), ConfinementReinforcementType);
            this.FlexuralSection = fs;
        }
        public void ShearWallCalculatesPMMDiagramMaxIteration()
        {
            double         f_c_prime                 = 6;
            double         f_c_prime_psi             = f_c_prime * 1000;
            IRebarMaterial LongitudinalRebarMaterial = new RebarMaterialGeneral(60000);
            double         l_w = 20 * 12;
            double         h   = 12;


            FlexuralCompressionFiberPosition p    = FlexuralCompressionFiberPosition.Top;
            ConcreteMaterial             Concrete = new ConcreteMaterial(f_c_prime_psi, ConcreteTypeByWeight.Normalweight, null);
            ConfinementReinforcementType ConfinementReinforcementType = KodestructAci.ConfinementReinforcementType.Ties;

            CrossSectionRectangularShape shape = new CrossSectionRectangularShape(Concrete, null, h, l_w);

            List <RebarPoint> LongitudinalBars = GetLongitudinalBarsFromCoordinates(LongitudinalRebarMaterial);

            KodestructAci.IConcreteFlexuralMember fs = new KodestructAci14.ConcreteSectionFlexure(shape, LongitudinalBars, null, ConfinementReinforcementType);

            IConcreteSectionWithLongitudinalRebar Section = fs as IConcreteSectionWithLongitudinalRebar;
            ConcreteSectionCompression            column  = new ConcreteSectionCompression(Section, ConfinementReinforcementType, null);
            //Convert axial force to pounds
            List <PMPair> Pairs         = column.GetPMPairs(p, 50, true);
            var           PairsAdjusted = Pairs.Select(pair => new PMPair(pair.P / 1000.0, pair.M / 1000.0 / 12.0));

            string Filename = Path.Combine(Path.GetTempPath(), "PMInteractionShearWallMaxIteration.csv");

            using (CsvFileWriter writer = new CsvFileWriter(Filename))
            {
                foreach (var pair in PairsAdjusted)
                {
                    CsvRow row = new CsvRow();
                    row.Add(pair.M.ToString());
                    row.Add(pair.P.ToString());
                    writer.WriteRow(row);
                }
            }
        }
//        public ConcreteSectionFlexure GetRectangularSectionWithBoundaryZones(double b, double h,
//double A_sBoundary, double L_Boundary, RebarDesignation curtainBar, double s_curtain, int N_curtains, IConcreteMaterial mat, IRebarMaterial rebarMaterial,
//    ConfinementReinforcementType ConfinementReinforcementType, int NumberOfSubdivisions = 20)
//        {

//            double YTop = h / 2.0 - c_centTopBottom;
//            double YBottom = -h / 2.0 + c_centTopBottom;
//            double XLeft = -b / 2.0 + c_centLeftRight;
//            double XRight = b / 2.0 - c_centLeftRight;

//            Point2D P1 = new Point2D(XLeft, YTop);
//            Point2D P2 = new Point2D(XRight, YTop);
//            Point2D P3 = new Point2D(XRight, YBottom);
//            Point2D P4 = new Point2D(XLeft, YBottom);



//            RebarLine topLine = null;
//            RebarLine bottomLine = null;

//            RebarLine leftLine = null;
//            RebarLine rightLine = null;

//            if (NumberOfSubdivisions == 0)
//            {
//                topLine = new RebarLine(A_sTopBottom, P1, P2, rebarMaterial, false);
//                bottomLine = new RebarLine(A_sTopBottom, P3, P4, rebarMaterial, false);
//                if (A_sLeftRight > 0)
//                {
//                    leftLine = new RebarLine(A_sLeftRight, P2, P3, rebarMaterial, true);
//                    rightLine = new RebarLine(A_sLeftRight, P4, P1, rebarMaterial, true);
//                }

//            }
//            else
//            {
//                topLine = new RebarLine(A_sTopBottom, P1, P2, rebarMaterial, false, false, NumberOfSubdivisions);
//                bottomLine = new RebarLine(A_sTopBottom, P3, P4, rebarMaterial, false, false, NumberOfSubdivisions);
//                if (A_sLeftRight > 0)
//                {
//                    leftLine = new RebarLine(A_sLeftRight, P2, P3, rebarMaterial, true, false, NumberOfSubdivisions);
//                    rightLine = new RebarLine(A_sLeftRight, P4, P1, rebarMaterial, true, false, NumberOfSubdivisions);
//                }
//            }


//            List<RebarPoint> LongitudinalBars = new List<RebarPoint>();


//            if (topLine != null) LongitudinalBars.AddRange(topLine.RebarPoints);
//            if (bottomLine != null) LongitudinalBars.AddRange(bottomLine.RebarPoints);
//            if (leftLine != null) LongitudinalBars.AddRange(leftLine.RebarPoints);
//            if (rightLine != null) LongitudinalBars.AddRange(rightLine.RebarPoints);


//            CrossSectionRectangularShape section = new CrossSectionRectangularShape(mat, null, b, h);
//            CalcLog log = new CalcLog();

//            ConcreteSectionFlexure sectionFlexure = new ConcreteSectionFlexure(section, LongitudinalBars, log, ConfinementReinforcementType);
//            return sectionFlexure;
//        }

        public ConcreteSectionFlexure GetRectangularSectionFourSidesDistributed(double b, double h,
                                                                                double A_sTopBottom, double A_sLeftRight, double c_centTopBottom, double c_centLeftRight, IConcreteMaterial mat, IRebarMaterial rebarMaterial,
                                                                                ConfinementReinforcementType ConfinementReinforcementType, int NumberOfSubdivisions = 0)
        {
            double YTop    = h / 2.0 - c_centTopBottom;
            double YBottom = -h / 2.0 + c_centTopBottom;
            double XLeft   = -b / 2.0 + c_centLeftRight;
            double XRight  = b / 2.0 - c_centLeftRight;

            Point2D P1 = new Point2D(XLeft, YTop);
            Point2D P2 = new Point2D(XRight, YTop);
            Point2D P3 = new Point2D(XRight, YBottom);
            Point2D P4 = new Point2D(XLeft, YBottom);



            RebarLine topLine    = null;
            RebarLine bottomLine = null;

            RebarLine leftLine  = null;
            RebarLine rightLine = null;

            if (NumberOfSubdivisions == 0)
            {
                topLine    = new RebarLine(A_sTopBottom, P1, P2, rebarMaterial, false);
                bottomLine = new RebarLine(A_sTopBottom, P3, P4, rebarMaterial, false);
                if (A_sLeftRight > 0)
                {
                    leftLine  = new RebarLine(A_sLeftRight, P2, P3, rebarMaterial, true);
                    rightLine = new RebarLine(A_sLeftRight, P4, P1, rebarMaterial, true);
                }
            }
            else
            {
                topLine    = new RebarLine(A_sTopBottom, P1, P2, rebarMaterial, false, false, NumberOfSubdivisions);
                bottomLine = new RebarLine(A_sTopBottom, P3, P4, rebarMaterial, false, false, NumberOfSubdivisions);
                if (A_sLeftRight > 0)
                {
                    leftLine  = new RebarLine(A_sLeftRight, P2, P3, rebarMaterial, true, false, NumberOfSubdivisions);
                    rightLine = new RebarLine(A_sLeftRight, P4, P1, rebarMaterial, true, false, NumberOfSubdivisions);
                }
            }


            List <RebarPoint> LongitudinalBars = new List <RebarPoint>();


            if (topLine != null)
            {
                LongitudinalBars.AddRange(topLine.RebarPoints);
            }
            if (bottomLine != null)
            {
                LongitudinalBars.AddRange(bottomLine.RebarPoints);
            }
            if (leftLine != null)
            {
                LongitudinalBars.AddRange(leftLine.RebarPoints);
            }
            if (rightLine != null)
            {
                LongitudinalBars.AddRange(rightLine.RebarPoints);
            }


            CrossSectionRectangularShape section = new CrossSectionRectangularShape(mat, null, b, h);
            CalcLog log = new CalcLog();

            ConcreteSectionFlexure sectionFlexure = new ConcreteSectionFlexure(section, LongitudinalBars, log, ConfinementReinforcementType);

            return(sectionFlexure);
        }
        public ConcreteFlexuralStrengthResult GetFlexuralDesignStrength(List <RebarPoint> LongitudinalBars, FlexuralCompressionFiberPosition CompressionFiber, ConfinementReinforcementType ConfinementReinforcementType)
        {
            ConcreteSectionFlexure s = new ConcreteSectionFlexure(this.ConcreteSection, LongitudinalBars, Log, ConfinementReinforcementType);

            return(s.GetDesignFlexuralStrength(CompressionFiber));
        }