public virtual SectionAnalysisResult GetSectionResult(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
        {
            double CompressedBarCentroidCoordinate       = 0; //Calculate the Coordinate of rebar resultant
            ForceMomentContribution CForceRebarResultant = GetCompressionForceRebarResultant(StrainDistribution, compFiberPosition);
            double CompressedRebarArea = GetCompressedRebarArea(CForceRebarResultant);
            ForceMomentContribution CForceConcreteResultant = GetCompressionForceConcreteResultant(StrainDistribution, compFiberPosition,
                                                                                                   CompressedRebarArea, CompressedBarCentroidCoordinate);


            ForceMomentContribution CForceResultant = CForceRebarResultant + CForceConcreteResultant;

            ForceMomentContribution TForceResultant = GetTensionForceResultant(StrainDistribution, compFiberPosition);
            SectionAnalysisResult   result          = new SectionAnalysisResult()
            {
                AxialForce              = CForceResultant.Force + TForceResultant.Force,
                CForce                  = CForceResultant.Force,
                TForce                  = TForceResultant.Force,
                Moment                  = CForceResultant.Moment + TForceResultant.Moment,
                Rotation                = 0,
                StrainDistribution      = StrainDistribution,
                CompressionRebarResults = CForceRebarResultant.RebarResults,
                TensionRebarResults     = TForceResultant.RebarResults
            };

            return(result);
        }
        protected virtual ForceMomentContribution GetCompressionForceConcreteResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition,
                                                                                       double CompressedRebarArea, double CompressedBarCentroidCoordinate)
        {
            ForceMomentContribution concreteContrib = GetConcreteForceResultant(StrainDistribution, compFiberPosition, CompressedRebarArea, CompressedBarCentroidCoordinate);

            return(concreteContrib);
        }
Exemple #3
0
        protected ForceMomentContribution GetApproximateRebarResultant(BarCoordinateFilter CoordinateFilter, BarCoordinateLimitFilterType LimitFilterType,
                                                                       double CutoffCoordinate)
        {
            ForceMomentContribution resultant = new ForceMomentContribution();

            double            barLimitForce       = 0;
            double            barLimitForceMoment = 0;
            List <RebarPoint> filteredBars        = GetFilteredBars(CutoffCoordinate, CoordinateFilter, LimitFilterType);

            foreach (var bar in filteredBars)
            {
                if (CoordinateFilter == BarCoordinateFilter.X) // && LimitFilterType == BarCoordinateLimitFilterType.Maximum)
                {
                    barLimitForce       = bar.Rebar.GetDesignForce();
                    barLimitForceMoment = barLimitForce * bar.Coordinate.X;
                }

                else
                {
                    barLimitForce       = bar.Rebar.GetDesignForce();
                    barLimitForceMoment = barLimitForce * bar.Coordinate.Y;
                }



                ForceMomentContribution barResultant = new ForceMomentContribution()
                {
                    Force = barLimitForce, Moment = barLimitForceMoment
                };
                resultant += barResultant;
            }

            return(resultant);
        }
Exemple #4
0
        protected ForceMomentContribution GetRebarResultant(LinearStrainDistribution StrainDistribution, ResultantType resType
                                                            , FlexuralCompressionFiberPosition p)
        {
            ForceMomentContribution resultant = new ForceMomentContribution();
            //tension is negative
            List <RebarPointResult> RebarResults = CalculateRebarResults(StrainDistribution, p);

            foreach (var barResult in RebarResults)
            {
                if (resType == ResultantType.Tension)
                {
                    if (barResult.Strain < 0)
                    {
                        resultant.Force += barResult.Force;

                        resultant.Moment += barResult.Force * barResult.DistanceToNeutralAxis;
                    }
                }
                else
                {
                    if (barResult.Strain > 0)
                    {
                        resultant.Force  += barResult.Force;
                        resultant.Moment += barResult.Force * barResult.DistanceToNeutralAxis;
                    }
                }
            }
            resultant.RebarResults = RebarResults;
            return(resultant);
        }
Exemple #5
0
        protected virtual LinearStrainDistribution GetInitialStrainEstimate(FlexuralCompressionFiberPosition CompressionFiberPosition)
        {
            //Find rebar resultant force
            // for initial estimate include only rebar below the centroid line
            // as a reasonable estimate for most regular beams
            double centroidY = Section.SliceableShape.YMin + Section.SliceableShape.y_Bar;
            ForceMomentContribution rebarResultant = null;

            switch (CompressionFiberPosition)
            {
            case FlexuralCompressionFiberPosition.Top:
                rebarResultant = GetApproximateRebarResultant(BarCoordinateFilter.Y, BarCoordinateLimitFilterType.Maximum, centroidY);
                break;

            case FlexuralCompressionFiberPosition.Bottom:
                rebarResultant = GetApproximateRebarResultant(BarCoordinateFilter.Y, BarCoordinateLimitFilterType.Minimum, centroidY);
                break;

            default:
                throw new CompressionFiberPositionException();
            }

            //Get corresponding strain
            double a = GetCompressionBlockDepth(rebarResultant.Force, CompressionFiberPosition);
            LinearStrainDistribution strainDistribution = GetStrainDistributionBasedOn_a(a, CompressionFiberPosition);

            return(strainDistribution);
        }
        public static ForceMomentContribution operator +(ForceMomentContribution a, ForceMomentContribution b)
        {
            ForceMomentContribution forceContrib = new ForceMomentContribution();

            forceContrib.Force = a.Force + b.Force;
            //forceContrib.Moment = Math.Abs(a.Moment) + Math.Abs(b.Moment);
            forceContrib.Moment = a.Moment + b.Moment;
            return(forceContrib);
        }
Exemple #7
0
        protected ForceMomentContribution GetRebarResultant(BarCoordinateFilter CoordinateFilter, BarCoordinateLimitFilterType LimitFilter, double CutoffCoordinate)
        {
            ForceMomentContribution resultant = new ForceMomentContribution();

            foreach (var bar in longitBars)
            {
                double barLimitForce       = 0;
                double barLimitForceMoment = 0;

                if (CoordinateFilter == BarCoordinateFilter.X && LimitFilter == BarCoordinateLimitFilterType.Maximum)
                {
                    if (bar.Coordinate.X <= CutoffCoordinate)
                    {
                        barLimitForce       = bar.Rebar.GetDesignForce();
                        barLimitForceMoment = barLimitForce * bar.Coordinate.X;
                    }
                }

                if (CoordinateFilter == BarCoordinateFilter.Y && LimitFilter == BarCoordinateLimitFilterType.Maximum)
                {
                    if (bar.Coordinate.Y <= CutoffCoordinate)
                    {
                        barLimitForce       = bar.Rebar.GetDesignForce();
                        barLimitForceMoment = barLimitForce * bar.Coordinate.Y;
                    }
                }

                if (CoordinateFilter == BarCoordinateFilter.X && LimitFilter == BarCoordinateLimitFilterType.Minimum)
                {
                    if (bar.Coordinate.X >= CutoffCoordinate)
                    {
                        barLimitForce       = bar.Rebar.GetDesignForce();
                        barLimitForceMoment = barLimitForce * bar.Coordinate.X;
                    }
                }

                if (CoordinateFilter == BarCoordinateFilter.Y && LimitFilter == BarCoordinateLimitFilterType.Minimum)
                {
                    if (bar.Coordinate.Y >= CutoffCoordinate)
                    {
                        barLimitForce       = bar.Rebar.GetDesignForce();
                        barLimitForceMoment = barLimitForce * bar.Coordinate.Y;
                    }
                }

                ForceMomentContribution barResultant = new ForceMomentContribution()
                {
                    Force = barLimitForce, Moment = barLimitForceMoment
                };
                resultant += barResultant;
            }

            return(resultant);
        }
        private double GetCompressedRebarArea(ForceMomentContribution CForceRebarResultant)
        {
            double A = 0;

            foreach (var bar in CForceRebarResultant.RebarResults)
            {
                if (bar.Stress > 0)
                {
                    A = A + bar.Point.Rebar.Area;
                }
            }
            return(A);
        }
        protected ForceMomentContribution GetConcreteWhitneyForceResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition,
                                                                           double CompressedRebarArea, double CompressedRebarCentroidCoordinate)
        {
            ForceMomentContribution ConcreteCompressionContribution = new ForceMomentContribution();

            // CalculateBeta and compression block height
            double c = GetDistanceToNeutralAxis(StrainDistribution, compFiberPosition);
            double h = Section.SliceableShape.YMax - Section.SliceableShape.YMin;
            double a;

            if (c == double.PositiveInfinity || c == double.NegativeInfinity)
            {
                a = h;
            }
            else
            {
                a = GetCompressionBlockDepth(c);
                if (a > h)
                {
                    a = h;
                }
            }


            //double CentroidYToTopEdge = (Section.SliceableShape.YMax-Section.SliceableShape.YMin)-Section.SliceableShape.y_Bar;
            //double neutralAxisToBottomOfCompressedShapeOffset = CentroidYToTopEdge - a;
            IMoveableSection  compressedPortion = null;
            ISliceableSection sec = this.Section.SliceableShape as ISliceableSection;

            if (sec != null)
            {
                compressedPortion = GetCompressedConcreteSection(StrainDistribution, compFiberPosition, a);
            }
            //this analysis subtracts the area of bars from the section but the location of the centroid of the
            //compressed section is not modified
            double A  = compressedPortion.A - CompressedRebarArea;
            double fc = Section.Material.SpecifiedCompressiveStrength;

            double WhitneyBlockStress     = GetWhitneyBlockStress();
            double ConcreteResultantForce = A * WhitneyBlockStress;

            ConcreteCompressionContribution.Force = ConcreteResultantForce;


            double concreteForceCentroidDistance = compressedPortion.GetElasticCentroidCoordinate().Y - Section.SliceableShape.GetElasticCentroidCoordinate().Y;

            ConcreteCompressionContribution.Moment = concreteForceCentroidDistance * ConcreteResultantForce;

            return(ConcreteCompressionContribution);
        }
        ForceMomentContribution GetConcreteForceResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition,
                                                          double CompressedRebarArea, double CompressedBarCentroidCoordinate)
        {
            ForceMomentContribution concreteForceResultant = null;

            if (compFiberPosition == FlexuralCompressionFiberPosition.Top)
            {
                if (StrainDistribution.TopFiberStrain < this.MaxConcreteStrain && StrainDistribution.TopFiberStrain >= 0)
                {
                    concreteForceResultant = GetConcreteParabolicStressForceResultant(StrainDistribution);
                }
                else
                {
                    if (StrainDistribution.TopFiberStrain == this.MaxConcreteStrain)
                    {
                        concreteForceResultant = GetConcreteWhitneyForceResultant(StrainDistribution, compFiberPosition, CompressedRebarArea, CompressedBarCentroidCoordinate);
                    }
                    else if (StrainDistribution.TopFiberStrain < 0)
                    {
                        concreteForceResultant = new ForceMomentContribution()
                        {
                            Force        = 0,
                            Moment       = 0,
                            RebarResults = new List <RebarPointResult>()
                        };
                    }
                    else
                    {
                        throw new UltimateConcreteStrainExceededException();
                    }
                }
            }
            else
            {
                if (StrainDistribution.BottomFiberStrain < this.MaxConcreteStrain && StrainDistribution.TopFiberStrain >= 0)
                {
                    concreteForceResultant = GetConcreteParabolicStressForceResultant(StrainDistribution);
                }
                else
                {
                    if (StrainDistribution.BottomFiberStrain == this.MaxConcreteStrain)
                    {
                        concreteForceResultant = GetConcreteWhitneyForceResultant(StrainDistribution, compFiberPosition, CompressedRebarArea, CompressedBarCentroidCoordinate);
                    }
                    else if (StrainDistribution.TopFiberStrain < 0)
                    {
                        concreteForceResultant = new ForceMomentContribution()
                        {
                            Force        = 0,
                            Moment       = 0,
                            RebarResults = new List <RebarPointResult>()
                        };
                    }
                    else
                    {
                        throw new UltimateConcreteStrainExceededException();
                    }
                }
            }

            return(concreteForceResultant);
        }
        protected virtual ForceMomentContribution GetTensionForceResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
        {
            ForceMomentContribution rebarContribution = GetRebarResultant(StrainDistribution, ResultantType.Tension, compFiberPosition);

            return(rebarContribution);
        }