//this calculates the final elastic tension
//the calculation assumes all plastic elongation has occured prior to the weather condition
//long term plastic elongation (creep) is assumed to be the controlling plastic elongation
//future work needs to be done to calculate the maximum plastic strain due to high tension and then force this calculation to use the higher of the two.
public static double CalculateElasticTension(this Weather weather, Wire wire, Creep creep)
{
double orginalLength = WireExtensions.CalculateOriginalLength(wire, creep);
double StartingWireLength = orginalLength + orginalLength * CreepExtensions.CalculateCreepStrain(creep, wire);
double StartingWireLengthDesignTemp = StartingWireLength + WireExtensions.CalculateWireThermalCoefficient(wire) * StartingWireLength * (weather.Temperature - wire.StartingTemp);
double psi = StartingWireLength + WireExtensions.CalculateWireThermalCoefficient(wire) * StartingWireLength * (weather.Temperature - wire.StartingTemp);
double beta = StartingWireLength / (WireExtensions.CalculateWireElasticity(wire) * wire.TotalCrossSection);
double lengthEstimate = Math.Sqrt(Math.Pow(weather.FinalSpanLength, 2) + Math.Pow(weather.FinalElevation, 2));
double horizontalTension = CalculateFinalLinearForce(weather, wire) * (lengthEstimate * lengthEstimate) / (8 * Math.Sqrt(3 * lengthEstimate * (Math.Abs(StartingWireLengthDesignTemp - lengthEstimate)) / 8));
double difference = 100;
while (Math.Abs(difference) > 0.001d)
{
difference = SolveForDifference(horizontalTension, weather.FinalSpanLength, CalculateFinalLinearForce(weather, wire), weather.FinalElevation, psi, beta);
horizontalTension = (horizontalTension - difference);
}
return(horizontalTension);
}
//this calculates the 'initial' tension from the initial stress strain curve, assumption is that no plastic elongation has occured yet, but the wire does not experience linear elasticity.
//this tension is typically called the 1-hour creep tension,'short' term tension condition, or stringing tensions.
//vaguely this calculation goes like this: 1)estimate length at design case 2) calculate strain for that length 3) calculate stress for that strain 4) calculate the average tension for that stress
//5) find the horizontal tension that results in that average tension 6) calculate the wire length for that horizontal tension from the wire geometry and return to step 2) with the new wire length estimate
//in practice this is accomplished by plugging stress= h/rho and strain = (arclength- originallength)/originallength into the stress strain equation
//this results in an equation that has only one unknown, horizontal tension. this can be solved with a newton-raphson loop.
//our input stress strain equation is in % strain, so the engineering strain must be multiplied by 100
public static double CalculateInitialTensions(this Weather weather, Wire wire, Creep creep)
{
double originalLength = wire.CalculateOriginalLength(creep);
double originalLengthDesignTemp = originalLength + WireExtensions.CalculateWireThermalCoefficient(wire) * originalLength * (weather.Temperature - wire.StartingTemp);
double lengthEstimate = Math.Sqrt(Math.Pow(weather.FinalSpanLength, 2) + Math.Pow(weather.FinalElevation, 2));
double horizontalTension = CalculateFinalLinearForce(weather, wire) * (lengthEstimate * lengthEstimate) / (8 * Math.Sqrt(3 * lengthEstimate * (Math.Abs(originalLengthDesignTemp - lengthEstimate)) / 8));
//refactor this so wireStressStrains are not calculated both here and in the wireExtensions
double wireStressStrainK0 = wire.OuterStressStrainList[0] + wire.CoreStressStrainList[0];
double wireStressStrainK1 = wire.OuterStressStrainList[1] + wire.CoreStressStrainList[1];
double wireStressStrainK2 = wire.OuterStressStrainList[2] + wire.CoreStressStrainList[2];
double wireStressStrainK3 = wire.OuterStressStrainList[3] + wire.CoreStressStrainList[3];
double wireStressStrainK4 = wire.OuterStressStrainList[4] + wire.CoreStressStrainList[4];
double NewtonDiff = 1000;
while (Math.Abs(NewtonDiff) > 0.001d)
{
//standard newton raphson where f(x)=stress-strain equation with x (strain) substituted for (arclength-oglength)/oglength*100. newton raphson to solve for horizontal tension
double arcLength = CalculateArcLength(weather.FinalSpanLength, weather.FinalElevation, horizontalTension / CalculateFinalLinearForce(weather, wire));
double arcLengthPrime = CalculateArcLengthPrime(horizontalTension, weather.FinalSpanLength, CalculateFinalLinearForce(weather, wire), weather.FinalElevation);
double function = -horizontalTension / wire.TotalCrossSection + wireStressStrainK0 + wireStressStrainK1 * (arcLength / originalLengthDesignTemp - 1) * 100 +
wireStressStrainK2 * (10000 * Math.Pow(arcLength, 2) / Math.Pow(originalLengthDesignTemp, 2) - 20000 * arcLength / originalLengthDesignTemp + 10000) +
wireStressStrainK3 * (1000000 * Math.Pow(arcLength, 3) / Math.Pow(originalLengthDesignTemp, 3) - 3000000 * Math.Pow(arcLength, 2) / Math.Pow(originalLengthDesignTemp, 2) + 3000000 * arcLength / originalLengthDesignTemp - 1000000) +
wireStressStrainK4 * (100000000 * Math.Pow(arcLength, 4) / Math.Pow(originalLengthDesignTemp, 4) - 400000000 * Math.Pow(arcLength, 3) / Math.Pow(originalLengthDesignTemp, 3) + 600000000 * Math.Pow(arcLength, 2) / Math.Pow(originalLengthDesignTemp, 2) - 400000000 * arcLength / originalLengthDesignTemp + 100000000);
double functionPrime = -1 / wire.TotalCrossSection + wireStressStrainK1 * arcLengthPrime / originalLengthDesignTemp * 100 +
wireStressStrainK2 * (10000 * 2 * arcLength * arcLengthPrime / Math.Pow(originalLengthDesignTemp, 2) - 20000 * arcLengthPrime / originalLengthDesignTemp) +
wireStressStrainK3 * (1000000 * 3 * Math.Pow(arcLength, 2) * arcLengthPrime / Math.Pow(originalLengthDesignTemp, 3) - 3000000 * 2 * arcLength * arcLengthPrime / Math.Pow(originalLengthDesignTemp, 2) + 3000000 * arcLengthPrime / originalLengthDesignTemp) +
wireStressStrainK4 * (100000000 * 4 * Math.Pow(arcLength, 3) * arcLengthPrime / Math.Pow(originalLengthDesignTemp, 4) - 400000000 * 3 * Math.Pow(arcLength, 2) * arcLengthPrime / Math.Pow(originalLengthDesignTemp, 3) + 600000000 * 2 * arcLength * arcLengthPrime / Math.Pow(originalLengthDesignTemp, 2) - 400000000 * arcLengthPrime / originalLengthDesignTemp);
NewtonDiff = function / functionPrime;
horizontalTension = horizontalTension - NewtonDiff;
}
return(horizontalTension);
}
//this is the creep strain calculations. these are sort of wire properties, but are depenent on the tensioning conditions of the wire, and not depenent on the weather loading conditions, so the are in their own class.
public static double CalculateCreepStrain(this Creep creep, Wire wire)
{
//todo: change this to also calculate the plastic elongation due to high tension with the stress-strain curve and return the higher strain
//calculate the average tension in the wire then find the initial stress
//this also needs to be changed to hand small or zero values for creepRTS percents. currently it returns NAN when modeling zero creep while it should just return 0 strain.
double startingCatenaryCosntant = (creep.CreepRTSPercent / 100) * wire.MaxRatedStrength / wire.FinalWireLinearWeight;
double LeftVerticalForce = -MathUtility.Sinh(WeatherExtensions.CalculateXc(wire.StartingSpanLength, wire.StartingElevation, startingCatenaryCosntant) / startingCatenaryCosntant) * (creep.CreepRTSPercent / 100) * wire.MaxRatedStrength;
double LeftTotalTension = Math.Sqrt(Math.Pow(LeftVerticalForce, 2) + Math.Pow((creep.CreepRTSPercent / 100) * wire.MaxRatedStrength, 2));
double RightVerticalForce = -MathUtility.Sinh(WeatherExtensions.CalculateXc(wire.StartingSpanLength, -wire.StartingElevation, startingCatenaryCosntant) / startingCatenaryCosntant) * (creep.CreepRTSPercent / 100) * wire.MaxRatedStrength;
double RightTotalTension = Math.Sqrt(Math.Pow(RightVerticalForce, 2) + Math.Pow((creep.CreepRTSPercent / 100) * wire.MaxRatedStrength, 2));
double averageTension = (LeftTotalTension + RightTotalTension) / 2 - wire.InitialWireLinearWeight * WeatherExtensions.CalculateSag(startingCatenaryCosntant, wire.StartingSpanLength, wire.StartingElevation) / 2;
//refactor these to be calculated and stored in one place
double wireCreepK0 = wire.OuterCreepList[0] + wire.CoreCreepList[0];
double wireCreepK1 = wire.OuterCreepList[1] + wire.CoreCreepList[1];
double wireCreepK2 = wire.OuterCreepList[2] + wire.CoreCreepList[2];
double wireCreepK3 = wire.OuterCreepList[3] + wire.CoreCreepList[3];
double wireCreepK4 = wire.OuterCreepList[4] + wire.CoreCreepList[4];
double stress = averageTension / wire.TotalCrossSection;
double strainPercent = .03;
double difference = 100;
while (Math.Abs(difference) > 0.001d)
{
double functionX = wireCreepK0 + wireCreepK1 * strainPercent + wireCreepK2 * Math.Pow(strainPercent, 2) + wireCreepK3 * Math.Pow(strainPercent, 3) + wireCreepK4 * Math.Pow(strainPercent, 4) - stress;
double functionPrimeX = wireCreepK1 + 2 * wireCreepK2 * strainPercent + 3 * wireCreepK3 * Math.Pow(strainPercent, 2) + 4 * wireCreepK4 * Math.Pow(strainPercent, 3);
difference = functionX / functionPrimeX;
strainPercent = (strainPercent - difference);
}
//previous 'wrong' calculation: -(stress - WireExtensions.CalculateWireElasticity(wire) * strainPercent) / WireExtensions.CalculateWireElasticity(wire)
//the old calculation was the first back of the envolope equation I derived. Its reasonably accurate but the actual equation is easier to justify/derive and more accurate
double finalCreepStrainPercent = (strainPercent + 1) / (1 + averageTension / (WireExtensions.CalculateWireElasticity(wire) * wire.TotalCrossSection)) - 1;
//the stress strain curves all compare stress and strain percent. for our engineering calculations we need stain in unit length, so divide by 100 before returning the strain.
return(finalCreepStrainPercent / 100);
}
public static double CalculateOriginalLengthFromFinalTension(this Wire wire, Creep creep)
{
double startingCatenaryCosntant = wire.StartingTension / wire.FinalWireLinearWeight;
double startingArcLength = WeatherExtensions.CalculateArcLength(wire.StartingSpanLength, wire.StartingElevation, startingCatenaryCosntant);
double stressFreeLength = startingArcLength - wire.StartingTension * startingArcLength / (wire.TotalCrossSection * WireExtensions.CalculateWireElasticity(wire));
double creepStrain = CreepExtensions.CalculateCreepStrain(creep, wire);
return(stressFreeLength / (1 + creepStrain));
}
