public ConcreteSectionIterationData(LinearStrainDistribution StrainDistribution, LinearStrainDistribution PreviousStrainDistribution,
SectionAnalysisResult Result)
{
this.StrainDistribution = StrainDistribution;
this.PreviousStrainDistribution = PreviousStrainDistribution;
this.Result = 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;
}
public IStrainCompatibilityAnalysisResult GetNominalFlexuralCapacity
(FlexuralCompressionFiberPosition 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 ForceMomentContribution GetRebarResultant(LinearStrainDistribution StrainDistribution, ResultantType resType)
{
ForceMomentContribution resultant = new ForceMomentContribution();
//tension is negative
List <RebarPointResult> RebarResults = CalculateRebarResults(StrainDistribution);
foreach (var barResult in RebarResults)
{
if (resType == ResultantType.Tension)
{
if (barResult.Strain < 0)
{
resultant.Force += barResult.Force;
resultant.Moment += Math.Abs(barResult.Force * barResult.DistanceToNeutralAxis);
}
}
else
{
if (barResult.Strain > 0)
{
resultant.Force += barResult.Force;
resultant.Moment += Math.Abs(barResult.Force * barResult.DistanceToNeutralAxis);
}
}
}
resultant.RebarResults = RebarResults;
return(resultant);
}
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);
}
protected virtual List <RebarPointResult> CalculateRebarResults(LinearStrainDistribution StrainDistribution)
{
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 XMax = Section.SliceableShape.XMax;
double XMin = Section.SliceableShape.XMin;
double sectionHeight = Section.SliceableShape.YMax - Section.SliceableShape.YMin;
double distTopToSecNeutralAxis = sectionHeight - Section.SliceableShape.y_Bar;
foreach (RebarPoint rbrPnt in LongitudinalBars)
{
double BarDistanceToTop = YMax - rbrPnt.Coordinate.Y;
double BarDistanceToNa = BarDistanceToTop - distTopToSecNeutralAxis;
double Strain = StrainDistribution.GetStrainAtPointOffsetFromTop(BarDistanceToTop);
double Force;
double Stress;
Force = rbrPnt.Rebar.GetForce(Strain);
Stress = rbrPnt.Rebar.GetStress(Strain);
ResultList.Add(new RebarPointResult(Stress, Strain, Force, BarDistanceToNa, rbrPnt));
}
return(ResultList);
}
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);
}
public ConcreteSectionIterationData(LinearStrainDistribution StrainDistribution, LinearStrainDistribution PreviousStrainDistribution,
SectionAnalysisResult Result)
{
this.StrainDistribution = StrainDistribution;
this.PreviousStrainDistribution = PreviousStrainDistribution;
this.Result = Result;
}
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_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;
}
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);
}
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 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)
{
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;
}
private double DeltaTCCalculationFunction(double SteelStrain)
{
//function of CurrentCompressionFiberPosition
//1. 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();
}
//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 virtual List<RebarPointResult> CalculateRebarResults(LinearStrainDistribution StrainDistribution )
{
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 XMax = Section.SliceableShape.XMax;
double XMin = Section.SliceableShape.XMin;
double sectionHeight = Section.SliceableShape.YMax - Section.SliceableShape.YMin;
double distTopToSecNeutralAxis = sectionHeight - Section.SliceableShape.y_Bar;
foreach (RebarPoint rbrPnt in LongitudinalBars)
{
double BarDistanceToTop = YMax - rbrPnt.Coordinate.Y;
double BarDistanceToNa = BarDistanceToTop - distTopToSecNeutralAxis;
double Strain = StrainDistribution.GetStrainAtPointOffsetFromTop(BarDistanceToTop);
double Force;
double Stress;
Force = rbrPnt.Rebar.GetForce(Strain);
Stress = rbrPnt.Rebar.GetStress(Strain);
ResultList.Add(new RebarPointResult(Stress, Strain, Force, BarDistanceToNa, rbrPnt));
}
return ResultList;
}
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_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);
}
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 double GetDistanceToNeutralAxis(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double c = StrainDistribution.NeutralAxisTopDistance;
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
return c;
break;
case FlexuralCompressionFiberPosition.Bottom:
return StrainDistribution.Height-c;
break;
default:
throw new CompressionFiberPositionException();
}
return c;
}
protected ForceMomentContribution GetConcreteWhitneyForceResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
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)
{
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);
}
double A = compressedPortion.A;
double fc = Section.Material.SpecifiedCompressiveStrength;
double ConcreteResultantForce = A * 0.85 * fc;
ConcreteCompressionContribution.Force = ConcreteResultantForce;
double concreteForceCentroidDistance = compressedPortion.GetElasticCentroidCoordinate().Y;
ConcreteCompressionContribution.Moment = concreteForceCentroidDistance * ConcreteResultantForce;
return(ConcreteCompressionContribution);
}
ForceMomentContribution GetConcreteForceResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
ForceMomentContribution concreteForceResultant = null;
if (compFiberPosition == FlexuralCompressionFiberPosition.Top)
{
if (StrainDistribution.TopFiberStrain< this.MaxConcreteStrain)
{
concreteForceResultant = GetConcreteParabolicStressForceResultant(StrainDistribution);
}
else
{
if (StrainDistribution.TopFiberStrain == this.MaxConcreteStrain)
{
concreteForceResultant = GetConcreteWhitneyForceResultant(StrainDistribution, compFiberPosition);
}
else
{
throw new UltimateConcreteStrainExceededException();
}
}
}
else
{
if (StrainDistribution.BottomFiberStrain < this.MaxConcreteStrain)
{
concreteForceResultant = GetConcreteParabolicStressForceResultant(StrainDistribution);
}
else
{
if (StrainDistribution.BottomFiberStrain == this.MaxConcreteStrain)
{
concreteForceResultant = GetConcreteWhitneyForceResultant(StrainDistribution,compFiberPosition);
}
else
{
throw new UltimateConcreteStrainExceededException();
}
}
}
return concreteForceResultant;
}
ForceMomentContribution GetConcreteForceResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
ForceMomentContribution concreteForceResultant = null;
if (compFiberPosition == FlexuralCompressionFiberPosition.Top)
{
if (StrainDistribution.TopFiberStrain < this.MaxConcreteStrain)
{
concreteForceResultant = GetConcreteParabolicStressForceResultant(StrainDistribution);
}
else
{
if (StrainDistribution.TopFiberStrain == this.MaxConcreteStrain)
{
concreteForceResultant = GetConcreteWhitneyForceResultant(StrainDistribution, compFiberPosition);
}
else
{
throw new UltimateConcreteStrainExceededException();
}
}
}
else
{
if (StrainDistribution.BottomFiberStrain < this.MaxConcreteStrain)
{
concreteForceResultant = GetConcreteParabolicStressForceResultant(StrainDistribution);
}
else
{
if (StrainDistribution.BottomFiberStrain == this.MaxConcreteStrain)
{
concreteForceResultant = GetConcreteWhitneyForceResultant(StrainDistribution, compFiberPosition);
}
else
{
throw new UltimateConcreteStrainExceededException();
}
}
}
return(concreteForceResultant);
}
protected double GetDistanceToNeutralAxis(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double c = StrainDistribution.NeutralAxisTopDistance;
switch (CompressionFiberPosition)
{
case FlexuralCompressionFiberPosition.Top:
return(c);
break;
case FlexuralCompressionFiberPosition.Bottom:
return(StrainDistribution.Height - c);
break;
default:
throw new CompressionFiberPositionException();
}
return(c);
}
protected virtual SectionAnalysisResult GetSectionResult(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
ForceMomentContribution CForceRebarResultant = GetCompressionForceConcreteResultant(StrainDistribution, compFiberPosition);
ForceMomentContribution CForceConcreteResultant = GetCompressionForceRebarResultant(StrainDistribution, compFiberPosition);
ForceMomentContribution CForceResultant = CForceRebarResultant + CForceConcreteResultant;
ForceMomentContribution TForceResultant = GetTensionForceResultant(StrainDistribution);
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 SectionAnalysisResult GetSectionResult(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
ForceMomentContribution CForceRebarResultant = GetCompressionForceConcreteResultant(StrainDistribution, compFiberPosition);
ForceMomentContribution CForceConcreteResultant = GetCompressionForceRebarResultant(StrainDistribution, compFiberPosition);
ForceMomentContribution CForceResultant = CForceRebarResultant + CForceConcreteResultant;
ForceMomentContribution TForceResultant = GetTensionForceResultant(StrainDistribution);
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 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;
}
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);
}
private 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);
}
protected virtual SectionAnalysisResult FindMomentResultInPresenceOfAxialForce(FlexuralCompressionFiberPosition CompressionFiberPosition,
double P, double MaxSteelStrain, 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 StrainMin = MaxSteelStrain;
double StrainMax = StrainUltimateConcrete.Value;
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);
}
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 ConcreteSectionCompressionAnalysisResult(double Moment, LinearStrainDistribution StrainDistribution, RebarPointResult controllingTensionBar)
: base(Moment, StrainDistribution, controllingTensionBar)
{
}
protected virtual ForceMomentContribution GetTensionForceResultant(LinearStrainDistribution StrainDistribution)
{
ForceMomentContribution rebarContribution = GetRebarResultant(StrainDistribution, ResultantType.Tension);
return rebarContribution;
}
protected virtual ForceMomentContribution GetCompressionForceConcreteResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
ForceMomentContribution concreteContrib = GetConcreteForceResultant(StrainDistribution, compFiberPosition);
return concreteContrib;
}
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)
{
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 ForceMomentContribution GetRebarResultant(LinearStrainDistribution StrainDistribution, ResultantType resType )
{
ForceMomentContribution resultant = new ForceMomentContribution();
//tension is negative
List<RebarPointResult> RebarResults = CalculateRebarResults(StrainDistribution);
foreach (var barResult in RebarResults)
{
if (resType == ResultantType.Tension)
{
if (barResult.Strain < 0)
{
resultant.Force += barResult.Force;
resultant.Moment += Math.Abs(barResult.Force * barResult.DistanceToNeutralAxis);
}
}
else
{
if (barResult.Strain > 0)
{
resultant.Force += barResult.Force;
resultant.Moment += Math.Abs(barResult.Force * barResult.DistanceToNeutralAxis);
}
}
}
resultant.RebarResults = RebarResults;
return resultant;
}
public ConcreteSectionFlexuralAnalysisResult(double Moment, LinearStrainDistribution StrainDistribution, RebarPointResult controllingTensionBar) : base(Moment, StrainDistribution)
{
this.ControllingTensionBar = controllingTensionBar;
}
public ConcreteSectionCompressionAnalysisResult(double Moment, LinearStrainDistribution StrainDistribution, RebarPointResult controllingTensionBar)
: base( Moment, StrainDistribution, controllingTensionBar)
{
}
private double DeltaTCCalculationFunction(double SteelStrain)
{
//function of CurrentCompressionFiberPosition
//1. 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();
}
//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);
}
private 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;
}
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 virtual ForceMomentContribution GetCompressionForceRebarResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
ForceMomentContribution steelContrib = GetRebarResultant(StrainDistribution, ResultantType.Compression);
return(steelContrib);
}
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;
}
protected virtual ForceMomentContribution GetCompressionForceConcreteResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
ForceMomentContribution concreteContrib = GetConcreteForceResultant(StrainDistribution, compFiberPosition);
return(concreteContrib);
}
protected virtual SectionAnalysisResult FindMomentResultInPresenceOfAxialForce(FlexuralCompressionFiberPosition CompressionFiberPosition,
double P, double MaxSteelStrain, 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 StrainMin = MaxSteelStrain;
double StrainMax = StrainUltimateConcrete.Value;
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;
}
protected ForceMomentContribution GetConcreteWhitneyForceResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
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)
{
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);
}
double A = compressedPortion.A;
double fc = Section.Material.SpecifiedCompressiveStrength;
double ConcreteResultantForce = A * 0.85 * fc;
ConcreteCompressionContribution.Force = ConcreteResultantForce;
double concreteForceCentroidDistance = compressedPortion.GetElasticCentroidCoordinate().Y;
ConcreteCompressionContribution.Moment = concreteForceCentroidDistance * ConcreteResultantForce;
return ConcreteCompressionContribution;
}
public SectionFlexuralAnalysisResult(double Moment, LinearStrainDistribution StrainDistribution)
{
this.moment = Moment;
this.strainDistribution = StrainDistribution;
}
protected double GetCompressionBlockDepth(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double c = GetDistanceToNeutralAxis(StrainDistribution, CompressionFiberPosition);
return this.GetCompressionBlockDepth(c);
}
public SectionFlexuralAnalysisResult( double Moment, LinearStrainDistribution StrainDistribution)
{
this.moment = Moment;
this.strainDistribution = StrainDistribution;
}
protected virtual ForceMomentContribution GetCompressionForceRebarResultant(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition compFiberPosition)
{
ForceMomentContribution steelContrib = GetRebarResultant(StrainDistribution, ResultantType.Compression);
return steelContrib;
}
protected virtual ForceMomentContribution GetTensionForceResultant(LinearStrainDistribution StrainDistribution)
{
ForceMomentContribution rebarContribution = GetRebarResultant(StrainDistribution, ResultantType.Tension);
return(rebarContribution);
}
ForceMomentContribution GetConcreteParabolicStressForceResultant(LinearStrainDistribution StrainDistribution)
{
throw new NotImplementedException();
}
public ConcreteSectionFlexuralAnalysisResult(double Moment, LinearStrainDistribution StrainDistribution, RebarPointResult controllingTensionBar): base(Moment,StrainDistribution)
{
this.ControllingTensionBar = controllingTensionBar;
}
ForceMomentContribution GetConcreteParabolicStressForceResultant(LinearStrainDistribution StrainDistribution)
{
throw new NotImplementedException();
}
protected double GetCompressionBlockDepth(LinearStrainDistribution StrainDistribution, FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double c = GetDistanceToNeutralAxis(StrainDistribution, CompressionFiberPosition);
return(this.GetCompressionBlockDepth(c));
}
