Ejemplo n.º 1
0
        public List <IMoveableSection> GetTransformedRebarShapes(double YMax, double YMin)
        {
            List <IMoveableSection> barSections = new List <IMoveableSection>();
            double E_c = this.Section.Material.ModulusOfElasticity;
            double E_s = 29000000.0; //Steel modulus of elasticity
            double n   = E_s / E_c;

            List <RebarPoint> filteredBars = LongitudinalBars.Where
                                             (
                b =>

                b.Coordinate.Y >= YMin && b.Coordinate.Y <= YMax

                                             ).ToList();

            foreach (RebarPoint rbrPnt in filteredBars)
            {
                double A_bar = rbrPnt.Rebar.Area * n;
                double d_bar = rbrPnt.Rebar.Diameter;
                if (d_bar == 0)
                {
                    d_bar = (YMax - YMin) / 100.0;
                }
                Point2D thisCentroid = new Point2D(rbrPnt.Coordinate.X, rbrPnt.Coordinate.Y);

                SectionRectangular rect = new SectionRectangular(null, A_bar / d_bar, d_bar, thisCentroid);
                //rect.Centroid = new Point2D(rbrPnt.Coordinate.X, rbrPnt.Coordinate.Y);
                barSections.Add(rect);
            }

            return(barSections);
        }
        private LinearStrainDistribution GetStrainMaxTensionMaxCompression(FlexuralCompressionFiberPosition CompressionFiberPosition)
        {
            //Calulate limit strain for the lowest rebar point
            //Distinguish between top and bottom tension cases
            double StrainDistributionHeight = 0.0;
            //double MaxStrain = CalculateMaximumSteelStrain(CompressionFiberPosition);
            double MaxStrain = this.MaxSteelStrain;

            LinearStrainDistribution MaxMaxDistribution;

            StrainDistributionHeight = GetStrainDistributionHeight(CompressionFiberPosition);

            if (CompressionFiberPosition == FlexuralCompressionFiberPosition.Top)
            {
                var LowestPointY    = LongitudinalBars.Min(yVal => yVal.Coordinate.Y);
                var PointsAtLowestY = LongitudinalBars.Where(point => point.Coordinate.Y == LowestPointY).Select(point => point);
                var LimitStrain     = PointsAtLowestY.Min(point => point.Rebar.Material.GetUltimateStrain(point.Rebar.Diameter));
                MaxStrain          = LimitStrain;
                MaxMaxDistribution = new LinearStrainDistribution
                                         (StrainDistributionHeight, this.MaxConcreteStrain, -MaxStrain);
            }
            else
            {
                var HighestPointY    = LongitudinalBars.Max(yVal => yVal.Coordinate.Y);
                var PointsAtHighestY = LongitudinalBars.Where(point => point.Coordinate.Y == HighestPointY).Select(point => point);
                var LimitStrain      = PointsAtHighestY.Min(point => point.Rebar.Material.GetUltimateStrain(point.Rebar.Diameter));
                MaxStrain          = LimitStrain;
                MaxMaxDistribution = new LinearStrainDistribution
                                         (StrainDistributionHeight, -MaxStrain, this.MaxConcreteStrain);
            }

            return(MaxMaxDistribution);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Pure axial strength. Implementation here is for Non prestressed section
        /// </summary>
        /// <returns></returns>
        protected virtual double GetP_o()
        {
            //22.4.2.2
            double A_g = Section.SliceableShape.A;
            var    compressionLongitudinalBars = LongitudinalBars.Where(r => r.Rebar.IsTensionOnly == false);
            double A_s = compressionLongitudinalBars.Sum(b =>
            {
                if (b.Rebar.IsTensionOnly == false)
                {
                    return(b.Rebar.Area);
                }
                else
                {
                    return(0);
                }
            }

                                                         );
            double f_c    = Section.Material.SpecifiedCompressiveStrength;
            double f_yA_s = LongitudinalBars.Sum(b => b.Rebar.Area * b.Rebar.Material.YieldStress);
            //(22.4.2.2)
            double P_o = 0.85 * f_c * (A_g - A_s) + f_yA_s;

            return(P_o);
        }
        protected virtual double CalculateMaximumSteelStrain(FlexuralCompressionFiberPosition CompressionFiberPosition)
        {
            double MaxStrain = 0.0;

            if (CompressionFiberPosition == FlexuralCompressionFiberPosition.Top)
            {
                var LowestPointY    = LongitudinalBars.Min(yVal => yVal.Coordinate.Y);
                var PointsAtLowestY = LongitudinalBars.Where(point => point.Coordinate.Y == LowestPointY).Select(point => point);
                var LimitStrain     = PointsAtLowestY.Min(point => point.Rebar.Material.GetUltimateStrain(point.Rebar.Diameter));
                MaxStrain = -LimitStrain;
            }
            else
            {
                var HighestPointY    = LongitudinalBars.Max(yVal => yVal.Coordinate.Y);
                var PointsAtHighestY = LongitudinalBars.Where(point => point.Coordinate.Y == HighestPointY).Select(point => point);
                var LimitStrain      = PointsAtHighestY.Min(point => point.Rebar.Material.GetUltimateStrain(point.Rebar.Diameter));
                MaxStrain = -LimitStrain;
            }
            return(MaxStrain);
        }
        protected double GetStrainDistributionHeight(FlexuralCompressionFiberPosition CompressionFiberPosition)
        {
            double StrainDistributionHeight = 0.0;
            double YMax = Section.SliceableShape.YMax;
            double YMin = Section.SliceableShape.YMin;
            double XMax = Section.SliceableShape.XMax;
            double XMin = Section.SliceableShape.XMin;

            if (CompressionFiberPosition == FlexuralCompressionFiberPosition.Top)
            {
                var LowestPointY    = LongitudinalBars.Min(yVal => yVal.Coordinate.Y);
                var PointsAtLowestY = LongitudinalBars.Where(point => point.Coordinate.Y == LowestPointY).Select(point => point);
                StrainDistributionHeight = Math.Abs(YMax - LowestPointY);
            }
            else
            {
                var HighestPointY    = LongitudinalBars.Max(yVal => yVal.Coordinate.Y);
                var PointsAtHighestY = LongitudinalBars.Where(point => point.Coordinate.Y == HighestPointY).Select(point => point);
                StrainDistributionHeight = Math.Abs(YMin - HighestPointY);
            }
            return(StrainDistributionHeight);
        }