protected IMoveableSection GetCompressedConcreteSection(LinearStrainDistribution StrainDistribution,
FlexuralCompressionFiberPosition compFiberPos, double SlicingPlaneOffset)
{
IMoveableSection compressedPortion = null;
ISliceableSection sec = this.Section.SliceableShape as ISliceableSection;
//if (StrainDistribution.TopFiberStrain >= 0 && StrainDistribution.BottomFiberStrain >= 0)
//{
double SectionHeight = sec.YMax - sec.YMin;
if (SlicingPlaneOffset > SectionHeight)
{
compressedPortion = this.Section.SliceableShape;
}
else
{
switch (compFiberPos)
{
case FlexuralCompressionFiberPosition.Top:
compressedPortion = sec.GetTopSliceSection(SlicingPlaneOffset, SlicingPlaneOffsetType.Top);
break;
case FlexuralCompressionFiberPosition.Bottom:
compressedPortion = sec.GetBottomSliceSection(SlicingPlaneOffset, SlicingPlaneOffsetType.Bottom);
break;
default:
throw new CompressionFiberPositionException();
}
}
return(compressedPortion);
}
protected override TCIterationBound GetSolutionBoundaries(SectionAnalysisResult result,
LinearStrainDistribution ApproximationStrainDistribution)
{
double prestressForce = this.GetPrestressForceEffective();
if (prestressForce == 0)
{
//TODO: add check for prstressing if needed
//throw new NotPrestressedBeamException();
}
//prestressed beam strain iteration is different (from regular RC) from regular concrete because we are assuming that
//the maximum depth of compression zone is 0.6d. Therefore this determines the start of iterations
TCIterationBound bound = new TCIterationBound();
switch (currentCompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
bound.MinStrain = ApproximationStrainDistribution.BottomFiberStrain;
break;
case FlexuralCompressionFiberPosition.Bottom:
bound.MinStrain = ApproximationStrainDistribution.TopFiberStrain;
break;
default:
throw new CompressionFiberPositionException();
}
bound.MaxStrain = CalculateMaximumSteelStrain(currentCompressionFiberPosition);
return(bound);
}
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);
}
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);
}
protected virtual LinearStrainDistribution GetStrainDistributionBasedOn_a(double a, FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double c = a / Section.Material.beta1;
double StrainDistributionHeight = GetStrainDistributionHeight(CompressionFiberPosition);
double epsilon_c = this.MaxConcreteStrain;
double epsilon_s = epsilon_c - (epsilon_c / c) * StrainDistributionHeight;
LinearStrainDistribution strainDistribution = null;
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
strainDistribution = new LinearStrainDistribution(StrainDistributionHeight, epsilon_c, epsilon_s);
break;
case FlexuralCompressionFiberPosition.Bottom:
strainDistribution = new LinearStrainDistribution(StrainDistributionHeight, epsilon_s, epsilon_c);
break;
default:
throw new CompressionFiberPositionException();
}
return(strainDistribution);
}
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);
}
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);
}
private double DeltaTCCalculationFunction(double SteelStrain)
{
LinearStrainDistribution iteratedStrainDistribution = null;
switch (currentCompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
iteratedStrainDistribution = new LinearStrainDistribution(StrainHeight, this.MaxConcreteStrain, SteelStrain);
break;
case FlexuralCompressionFiberPosition.Bottom:
iteratedStrainDistribution = new LinearStrainDistribution(StrainHeight, SteelStrain, this.MaxConcreteStrain);
break;
default:
throw new CompressionFiberPositionException();
}
//2. Calculate result
SectionAnalysisResult iteratedResult = GetSectionResult(iteratedStrainDistribution, currentCompressionFiberPosition);
//3. calculate difference between T and C
double T = iteratedResult.TForce;
double C = iteratedResult.CForce;
return(Math.Abs(T) - Math.Abs(C));
}
protected override LinearStrainDistribution GetInitialStrainEstimate(FlexuralCompressionFiberPosition CompressionFiberPosition)
{
currentCompressionFiberPosition = CompressionFiberPosition; //store this off for getting iteration limits
double StrainDistributionHeight = GetStrainDistributionHeight(CompressionFiberPosition);
double c = StrainDistributionHeight * 0.6;
//this is AASHTO criteria for when it's OK to use assumption that
//mild rebar yields, beyond that need to use strain compatibility
//double epsilon_c = StrainUltimateConcrete.Value;
double epsilon_c = MaxConcreteStrain;
double epsilon_s = epsilon_c - (epsilon_c / c) * StrainDistributionHeight;
LinearStrainDistribution strainDistribution = null;
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
strainDistribution = new LinearStrainDistribution(StrainDistributionHeight, epsilon_c, epsilon_s);
break;
case FlexuralCompressionFiberPosition.Bottom:
strainDistribution = new LinearStrainDistribution(StrainDistributionHeight, epsilon_s, epsilon_c);
break;
default:
throw new CompressionFiberPositionException();
}
return(strainDistribution);
}
public ConcreteSectionIterationData(LinearStrainDistribution StrainDistribution, LinearStrainDistribution PreviousStrainDistribution,
SectionAnalysisResult Result)
{
this.StrainDistribution = StrainDistribution;
this.PreviousStrainDistribution = PreviousStrainDistribution;
this.Result = Result;
}
public virtual List <RebarPointResult> CalculateRebarResults(LinearStrainDistribution StrainDistribution,
FlexuralCompressionFiberPosition p)
{
List <RebarPointResult> ResultList = new List <RebarPointResult>();
double c = StrainDistribution.NeutralAxisTopDistance;
double h = StrainDistribution.Height;
double YMax = Section.SliceableShape.YMax;
double YMin = Section.SliceableShape.YMin;
double sectionHeight = Section.SliceableShape.YMax - Section.SliceableShape.YMin;
double distTopToSecNeutralAxis = sectionHeight - Section.SliceableShape.y_Bar;
foreach (RebarPoint rbrPnt in LongitudinalBars)
{
double BarDistanceToTop;
double BarDistanceToBottom;
double BarDistanceToCentroid;
double Strain;
if (p == FlexuralCompressionFiberPosition.Top)
{
BarDistanceToTop = YMax - rbrPnt.Coordinate.Y;
BarDistanceToCentroid = rbrPnt.Coordinate.Y - TransformedSection.GetElasticCentroidCoordinate().Y;
// BarDistanceToCentroid = TransformedSection.GetElasticCentroidCoordinate().Y - rbrPnt.Coordinate.Y;
Strain = StrainDistribution.GetStrainAtPointOffsetFromTop(BarDistanceToTop);
}
else
{
BarDistanceToBottom = rbrPnt.Coordinate.Y - YMin;
//BarDistanceToCentroid = TransformedSection.GetElasticCentroidCoordinate().Y - rbrPnt.Coordinate.Y;
BarDistanceToCentroid = rbrPnt.Coordinate.Y - TransformedSection.GetElasticCentroidCoordinate().Y;
Strain = StrainDistribution.GetStrainAtPointOffsetFromBottom(BarDistanceToBottom);
}
double Force;
double Stress;
//Disregard bar if it is in compression and it is tension only bar
if (Strain > 0 && rbrPnt.Rebar.IsTensionOnly == true)
{
//add this bar to the results with zero force
Force = 0;
Stress = 0;
//ResultList.Add(new RebarPointResult(Stress, Strain, Force, BarDistanceToNa, rbrPnt));
ResultList.Add(new RebarPointResult(Stress, Strain, Force, BarDistanceToCentroid, rbrPnt));
}
else
{
Force = rbrPnt.Rebar.GetForce(Strain);
Stress = rbrPnt.Rebar.GetStress(Strain);
//ResultList.Add(new RebarPointResult(Stress, Strain, Force, BarDistanceToNa, rbrPnt));
ResultList.Add(new RebarPointResult(Stress, Strain, Force, BarDistanceToCentroid, rbrPnt));
}
}
return(ResultList);
}
protected virtual TCIterationBound GetSolutionBoundaries(SectionAnalysisResult result, LinearStrainDistribution ApproximationStrainDistribution)
{
double t = Math.Abs(result.TForce);
double c = Math.Abs(result.CForce);
SectionAnalysisResult secondResult = new SectionAnalysisResult();
TCIterationBound data = new TCIterationBound();
LinearStrainDistribution secondApproximationStrainDistribution = null;
double MaxSteelStrain = CalculateMaximumSteelStrain(currentCompressionFiberPosition);
//Step 1: create adjusted strain distribution
if (t > c)
{
if (currentCompressionFiberPosition == FlexuralCompressionFiberPosition.Top)
{
secondApproximationStrainDistribution = new LinearStrainDistribution(ApproximationStrainDistribution.Height,
ApproximationStrainDistribution.TopFiberStrain, this.MaxConcreteStrain);
}
else
{
secondApproximationStrainDistribution = new LinearStrainDistribution(ApproximationStrainDistribution.Height,
this.MaxConcreteStrain, ApproximationStrainDistribution.BottomFiberStrain);
}
}
else
{
if (currentCompressionFiberPosition == FlexuralCompressionFiberPosition.Top)
{
secondApproximationStrainDistribution = new LinearStrainDistribution(ApproximationStrainDistribution.Height,
ApproximationStrainDistribution.TopFiberStrain, MaxSteelStrain);
}
else
{
secondApproximationStrainDistribution = new LinearStrainDistribution(ApproximationStrainDistribution.Height,
MaxSteelStrain, ApproximationStrainDistribution.BottomFiberStrain);
}
}
//Step 2: Fill in data for output
if (currentCompressionFiberPosition == FlexuralCompressionFiberPosition.Top)
{
data.MinStrain = -Math.Max(Math.Abs(ApproximationStrainDistribution.BottomFiberStrain), Math.Abs(secondApproximationStrainDistribution.BottomFiberStrain));
data.MaxStrain = -Math.Min(Math.Abs(ApproximationStrainDistribution.BottomFiberStrain), Math.Abs(secondApproximationStrainDistribution.BottomFiberStrain));
}
else
{
data.MinStrain = -Math.Max(Math.Abs(ApproximationStrainDistribution.TopFiberStrain), Math.Abs(secondApproximationStrainDistribution.TopFiberStrain));
data.MaxStrain = -Math.Min(Math.Abs(ApproximationStrainDistribution.TopFiberStrain), Math.Abs(secondApproximationStrainDistribution.TopFiberStrain));
}
return(data);
}
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);
}
protected double GetDistanceToNeutralAxis(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double c;
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
c = StrainDistribution.NeutralAxisTopDistance;
return(c);
case FlexuralCompressionFiberPosition.Bottom:
//return StrainDistribution.Height-c;
c = StrainDistribution.NeutralAxisBottomDistance;
return(c);
default:
throw new CompressionFiberPositionException();
}
return(c);
}
protected virtual SectionAnalysisResult FindMomentResultInPresenceOfAxialForce(FlexuralCompressionFiberPosition CompressionFiberPosition,
double P, double MaxSteelLimitingStrainInTension, double StrainConvergenceTolerance = 0.0000001)
{
currentCompressionFiberPosition = CompressionFiberPosition; //store this off because it will be necessary during iteration
StrainHeight = GetStrainDistributionHeight(CompressionFiberPosition); //store this off because it will be necessary during iteration
double StrainMin = MaxSteelLimitingStrainInTension;
//double StrainMax = StrainUltimateConcrete.Value;
double StrainMax = MaxConcreteStrain;
double targetP = P;
LinearStrainDistribution finalStrainDistribution = null;
double SteelStrain = RootFinding.Brent(new FunctionOfOneVariable(SectionAxialForceResultantFunction), StrainMin, StrainMax,
StrainConvergenceTolerance, targetP);
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
finalStrainDistribution = new LinearStrainDistribution(StrainHeight, this.MaxConcreteStrain, SteelStrain);
break;
case FlexuralCompressionFiberPosition.Bottom:
finalStrainDistribution = new LinearStrainDistribution(StrainHeight, SteelStrain, this.MaxConcreteStrain);
break;
default:
throw new CompressionFiberPositionException();
}
SectionAnalysisResult finalResult = GetSectionResult(finalStrainDistribution, CompressionFiberPosition);
return(finalResult);
}
private void UpdateValuesFromResult(IStrainCompatibilityAnalysisResult nominalResult,
FlexuralCompressionFiberPosition FlexuralCompressionFiberPosition, double beta1)
{
LinearStrainDistribution strainDistribution = nominalResult.StrainDistribution;
double d = strainDistribution.Height;
if (FlexuralCompressionFiberPosition == FlexuralCompressionFiberPosition.Top)
{
this.a = strainDistribution.NeutralAxisTopDistance * beta1;
//epsilon_t = strainDistribution.BottomFiberStrain;
}
else
{
this.a = (d - strainDistribution.NeutralAxisTopDistance) * beta1;
//epsilon_t = strainDistribution.TopFiberStrain;
}
epsilon_t = nominalResult.ControllingTensionBar.Strain;
IRebarMaterial controllingBarMaterial = nominalResult.ControllingTensionBar.Point.Rebar.Material;
epsilon_ty = controllingBarMaterial.YieldStrain;
}
protected virtual SectionAnalysisResult FindPureMomentResult(FlexuralCompressionFiberPosition CompressionFiberPosition,
TCIterationBound bound, double StrainConvergenceTolerance = 0.00001)
{
currentCompressionFiberPosition = CompressionFiberPosition; //store this off because it will be necessary during iteration
StrainHeight = GetStrainDistributionHeight(CompressionFiberPosition); //store this off because it will be necessary during iteration
double SteelStrain = 0;
double StrainMax = bound.MaxStrain;
double StrainMin = bound.MinStrain;
double targetTCDelta = 0;
LinearStrainDistribution finalStrainDistribution = null;
//SteelStrain = RootFinding.Brent(new FunctionOfOneVariable(GetTandCDeltaForSteelStrainIteration), TCDeltaMin, TCDeltaMax, StrainConvergenceTolerance, targetTCDelta);
SteelStrain = RootFinding.Brent(new FunctionOfOneVariable(DeltaTCCalculationFunction), StrainMin, StrainMax, StrainConvergenceTolerance, targetTCDelta);
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
finalStrainDistribution = new LinearStrainDistribution(StrainHeight, this.MaxConcreteStrain, SteelStrain);
break;
case FlexuralCompressionFiberPosition.Bottom:
finalStrainDistribution = new LinearStrainDistribution(StrainHeight, SteelStrain, this.MaxConcreteStrain);
break;
default:
throw new CompressionFiberPositionException();
}
SectionAnalysisResult finalResult = GetSectionResult(finalStrainDistribution, CompressionFiberPosition);
return(finalResult);
}
public double SectionAxialForceResultantFunction(double SteelStrain)
{
//Create trial strain
LinearStrainDistribution iteratedStrainDistribution = null;
switch (currentCompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
iteratedStrainDistribution = new LinearStrainDistribution(StrainHeight, this.MaxConcreteStrain, SteelStrain);
break;
case FlexuralCompressionFiberPosition.Bottom:
iteratedStrainDistribution = new LinearStrainDistribution(StrainHeight, SteelStrain, this.MaxConcreteStrain);
break;
default:
throw new CompressionFiberPositionException();
}
//Calculate result
SectionAnalysisResult iteratedResult = GetSectionResult(iteratedStrainDistribution, currentCompressionFiberPosition);
return(iteratedResult.AxialForce);
}
public IStrainCompatibilityAnalysisResult GetNominalFlexuralCapacity
(FlexuralCompressionFiberPosition CompressionFiberPosition)
{
currentCompressionFiberPosition = CompressionFiberPosition;
//Step 1: Assume strain distribution with all bars below section centroid yielding
LinearStrainDistribution TrialStrainDistribution = GetInitialStrainEstimate(CompressionFiberPosition);
SectionAnalysisResult TrialSectionResult = GetSectionResult(TrialStrainDistribution, CompressionFiberPosition);
double Mn = 0;
//check id T and C force are equal
//if T<>C
if (GetAnalysisResultConverged(TrialSectionResult, ConvergenceToleranceStrain) == false)
{
SectionAnalysisResult IteratedResult = null;
try
{
TCIterationBound bound = GetSolutionBoundaries(TrialSectionResult, TrialStrainDistribution); //make sure solution exists
IteratedResult = FindPureMomentResult(CompressionFiberPosition, bound, ConvergenceToleranceStrain);
RebarPointResult controllingBar = GetMaxSteelStrainPoint(TrialSectionResult.TensionRebarResults);
Mn = IteratedResult.Moment;
return(new ConcreteSectionFlexuralAnalysisResult(Mn, IteratedResult.StrainDistribution, controllingBar));
}
catch (SectionAnalysisFailedToConvergeException)
{
throw new SectionFailedToConvergeException();
}
}
//if T=C
else
{
IStrainCompatibilityAnalysisResult result = GetResult(TrialSectionResult);
return(result);
}
}
protected double GetCompressionBlockDepth(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double c = GetDistanceToNeutralAxis(StrainDistribution, CompressionFiberPosition);
return(this.GetCompressionBlockDepth(c));
}
ForceMomentContribution GetConcreteParabolicStressForceResultant(LinearStrainDistribution StrainDistribution)
{
throw new NotImplementedException();
}
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);
}
protected virtual ForceMomentContribution GetCompressionForceConcreteResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition,
double CompressedRebarArea, double CompressedBarCentroidCoordinate)
{
ForceMomentContribution concreteContrib = GetConcreteForceResultant(StrainDistribution, compFiberPosition, CompressedRebarArea, CompressedBarCentroidCoordinate);
return(concreteContrib);
}
public ConcreteSectionCompressionAnalysisResult(double Moment, LinearStrainDistribution StrainDistribution, RebarPointResult controllingTensionBar)
: base(Moment, StrainDistribution, controllingTensionBar)
{
}
public SectionFlexuralAnalysisResult(double Moment, LinearStrainDistribution StrainDistribution)
{
this.moment = Moment;
this.strainDistribution = StrainDistribution;
}
public ConcreteSectionFlexuralAnalysisResult(double Moment, LinearStrainDistribution StrainDistribution, RebarPointResult controllingTensionBar) : base(Moment, StrainDistribution)
{
this.ControllingTensionBar = controllingTensionBar;
}
protected List <SectionAnalysisResult> GetInteractionResults(FlexuralCompressionFiberPosition CompressionFiberPosition, int NumberOfSteps = 50)
{
List <SectionAnalysisResult> SectionResults = new List <SectionAnalysisResult>();
currentCompressionFiberPosition = CompressionFiberPosition; //store this off because it will be necessary during iteration
StrainHeight = GetStrainDistributionHeight(CompressionFiberPosition); //store this off because it will be necessary during iteration
double StrainMin = CalculateMaximumSteelStrain(CompressionFiberPosition);
double StrainMax = MaxConcreteStrain;
double TotalStrainVariation = StrainMax - StrainMin;
double strainStep = TotalStrainVariation / NumberOfSteps;
int NumberOfStartEndPoints = 10;
int TotalSteps = NumberOfSteps + 2 * NumberOfStartEndPoints;
for (int i = 0; i < TotalSteps; i++)
{
//double SteelStrain = StrainMax -i * strainStep;
double SteelStrain = GetSteelStrain(NumberOfSteps, i, StrainMax, StrainMin, NumberOfStartEndPoints);
LinearStrainDistribution currentStrainDistribution = null;
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
currentStrainDistribution = new LinearStrainDistribution(StrainHeight, this.MaxConcreteStrain, SteelStrain);
break;
case FlexuralCompressionFiberPosition.Bottom:
currentStrainDistribution = new LinearStrainDistribution(StrainHeight, SteelStrain, this.MaxConcreteStrain);
break;
default:
throw new CompressionFiberPositionException();
}
if (i == 2)
{
}
SectionAnalysisResult thisDistibutionResult = GetSectionResult(currentStrainDistribution, CompressionFiberPosition);
#region Dubugging output
StringBuilder sb = new StringBuilder();
sb.AppendLine(string.Format("AxialForce = {0}", Math.Round(thisDistibutionResult.AxialForce / 1000.0, 0)));
sb.AppendLine(string.Format("Moment = {0}", Math.Round(thisDistibutionResult.Moment / 12.0 / 1000.0, 0)));
sb.AppendLine(string.Format("CForce = {0}", Math.Round(thisDistibutionResult.CForce / 1000.0, 0)));
sb.AppendLine(string.Format("TForce = {0}", Math.Round(thisDistibutionResult.TForce / 1000.0, 0)));
sb.AppendLine(string.Format("SteelStrain = {0}", thisDistibutionResult.StrainDistribution.BottomFiberStrain, 0));
sb.AppendLine(string.Format("YNeutral = {0}", Math.Round(thisDistibutionResult.StrainDistribution.NeutralAxisTopDistance, 3)));
#endregion
SectionResults.Add(thisDistibutionResult);
}
//pure tension step
LinearStrainDistribution pureTensionStrainDistribution = new LinearStrainDistribution(StrainHeight, StrainMin, StrainMin);
SectionAnalysisResult pureTensionDistibutionResult = GetSectionResult(pureTensionStrainDistribution, CompressionFiberPosition);
SectionResults.Add(pureTensionDistibutionResult);
return(SectionResults);
}
