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));
}
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 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 IStrainCompatibilityAnalysisResult GetResult(SectionAnalysisResult SectionResult)
{
RebarPointResult controllingBar = GetMaxSteelStrainPoint(SectionResult.TensionRebarResults);
double MaxSteelTensionStrain = controllingBar.Strain;
double Mn = SectionResult.Moment;
IStrainCompatibilityAnalysisResult result = new ConcreteSectionFlexuralAnalysisResult(Mn, SectionResult.StrainDistribution, controllingBar);
return(result);
}
public IStrainCompatibilityAnalysisResult GetNominalMomentResult(double P_nominal,
FlexuralCompressionFiberPosition CompressionFiberPosition)
{
double MaxSteelLimitingStrainInTension = CalculateMaximumSteelStrain(CompressionFiberPosition);
SectionAnalysisResult IteratedResult = FindMomentResultInPresenceOfAxialForce(CompressionFiberPosition, P_nominal, MaxSteelLimitingStrainInTension);
IStrainCompatibilityAnalysisResult result = GetResult(IteratedResult);
return(result);
}
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 bool GetAnalysisResultConverged(SectionAnalysisResult sectionResult, double ConvergenceTolerance)
{
double C = Math.Abs(sectionResult.CForce);
double T = Math.Abs(sectionResult.TForce);
double MinForce = Math.Min(C, T);
double ConvergenceToleranceDifference = ConvergenceTolerance * MinForce;
if (Math.Abs(C - T) <= ConvergenceToleranceDifference)
{
return(true);
}
else
{
return(false);
}
}
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);
}
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 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);
}
