public void NumberIsNegativeTest()
{
double number = -278.34;
int power = 13;
const double eps = 1e-9;
RootFinding.NewtonRoot(number, power, eps);
}
public void PowerIsNull()
{
double number = 278.34;
int power = 0;
const double eps = 1e-9;
double expected = 1;
double root = RootFinding.NewtonRoot(number, power, eps);
Assert.AreEqual(expected, root, eps, "Root not found correctly");
}
public void PowerIsNegativeTest()
{
double number = 278.34;
int power = -13;
const double eps = 1e-9;
double expected = Math.Pow(number, 1.0 / power);
double root = RootFinding.NewtonRoot(number, power, eps);
Assert.AreEqual(expected, root, eps, "Root not found correctly");
}
public void NewtonRootUsualDateTest()
{
double number = 234.5;
int power = 13;
const double eps = 1e-9;
double expected = Math.Pow(number, 1.0 / power);
double root = RootFinding.NewtonRoot(number, power, eps);
Assert.AreEqual(expected, root, 0.001, "Root not found correctly");
}
private Point2D CalculatePlasticCentroid()
{
double ConvergenceTolerance = 0.0001;
//Find coordinate of Plastic Neutral Axis such that top and bottom areas are the same
double yPNA = RootFinding.Brent(new FunctionOfOneVariable(TopAndBottomAreaDifferenceFunction), YMin, YMax,
ConvergenceTolerance, 0);
//Find coordinate of Plastic Neutral Axis such that top and bottom areas are the same
double xPNA = RootFinding.Brent(new FunctionOfOneVariable(LeftAndRightAreaDifferenceFunction), XMin, XMax,
ConvergenceTolerance, 0);
return(new Point2D(xPNA, yPNA));
}
private double FindCrackedSectionNeutralAxis(FlexuralCompressionFiberPosition compFiberPosition)
{
double targetDelta = 0.0;
double CompressedBlockMin = 0.0;
double CompressedBlockMax = this.Section.SliceableShape.YMax - this.Section.SliceableShape.YMin;
currentCompressionFiberPosition = compFiberPosition; //store this off because it will be necessary during iteration
double ConvergenceTolerance = 0.0001;
double kd = RootFinding.Brent(new FunctionOfOneVariable(DeltaA_times_Y), CompressedBlockMin, CompressedBlockMax, ConvergenceTolerance, targetDelta);
return(kd);
}
static void Main()
{
double root;
int number;
int power;
int guess;
const double e = 1e-8;
number = 278;
power = 4;
guess = 10;
root = RootFinding.NewtonRoot(number, power, guess, e);
Console.WriteLine("Newton Root {0}, System Root {1}", root, Math.Pow(number, 1.0 / power));
}
public ConcreteCompressionStrengthResult GetDesignMomentWithCompressionStrength(double phiP_n,
FlexuralCompressionFiberPosition FlexuralCompressionFiberPosition,
bool CapAxialForceAtMaximum = true)
{
this.phiP_n = phiP_n; //store value for iteration
this.FlexuralCompressionFiberPosition = FlexuralCompressionFiberPosition;
double P_o = GetMaximumForce();
StrengthReductionFactorFactory f = new StrengthReductionFactorFactory();
double phiAxial = f.Get_phiFlexureAndAxial(FlexuralFailureModeClassification.CompressionControlled, ConfinementReinforcementType, 0, 0);
double phiP_nMax = phiAxial * P_o;
if (phiP_n > phiP_nMax)
{
if (CapAxialForceAtMaximum == false)
{
throw new Exception("Axial forces exceeds maximum axial force.");
}
else
{
phiP_n = phiP_n;
}
}
//Estimate resistance factor to adjust from phiP_n to P_n
double phiMin = 0.65;
double phiMax = 0.9;
double ConvergenceTolerance = 0.0001;
double targetPhiFactorDifference = 0.0;
//Find P_n by guessing a phi-factor and calculating the result
double phiIterated = RootFinding.Brent(new FunctionOfOneVariable(phiFactorDifferenceCalculation), phiMax, phiMin, ConvergenceTolerance, targetPhiFactorDifference);
double P_nActual = phiP_n / phiIterated;
//Calculate final results using the estimated value of phi
IStrainCompatibilityAnalysisResult nominalResult = this.GetNominalMomentResult(P_nActual, FlexuralCompressionFiberPosition);
ConcreteCompressionStrengthResult result = new ConcreteCompressionStrengthResult(nominalResult, FlexuralCompressionFiberPosition, this.Section.Material.beta1);
FlexuralFailureModeClassification failureMode = f.GetFlexuralFailureMode(result.epsilon_t, result.epsilon_ty);
double phiFinal = f.Get_phiFlexureAndAxial(failureMode, ConfinementReinforcementType, result.epsilon_t, result.epsilon_ty);
double phiM_n = phiFinal * nominalResult.Moment;
result.phiM_n = phiM_n;
result.FlexuralFailureModeClassification = failureMode;
return(result);
}
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);
}
private IMoveableSection getSliceOfArea(double Area, SLiceType sliceType)
{
double ConvergenceTolerance = this.A * 0.0001;
double targetAreaDelta = 0.0;
double AxisLocationDistanceMin = 0.0;
double AxisLocationDistanceMax = this.YMax - this.YMin;
//Iterate until the slice area is as required
targetArea = Area;
if (sliceType == SLiceType.Bottom)
{
double SliceAxisOffsetFromTop = RootFinding.Brent(new FunctionOfOneVariable(BottomAreaDeltaCalculationFunction),
AxisLocationDistanceMin, AxisLocationDistanceMax,
ConvergenceTolerance, targetAreaDelta);
}
else
{
double SliceAxisOffsetFromTop = RootFinding.Brent(new FunctionOfOneVariable(TopAreaDeltaCalculationFunction),
AxisLocationDistanceMin, AxisLocationDistanceMax,
ConvergenceTolerance, targetAreaDelta);
}
return(cutSection); //the section was stored during the iteration
}
