private static IEnumerable <TestCaseData> GetNegativeVelocityTestCases()
{
var random = new Random(21);
AerodynamicsData aerodynamicsData = AerodynamicsDataTestFactory.CreateAerodynamicsData();
Angle angleOfAttack = random.NextAngle();
double liftCoefficient = random.NextDouble();
double density = random.NextDouble();
double invalidVelocity = -random.NextDouble();
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateLift(aerodynamicsData,
angleOfAttack,
density,
invalidVelocity)))
.SetName("CalculateLift"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateDragWithEngineFailure(aerodynamicsData,
liftCoefficient,
density,
invalidVelocity)))
.SetName("CalculateDragWithEngineFailure"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateDragWithoutEngineFailure(aerodynamicsData,
liftCoefficient,
density,
invalidVelocity)))
.SetName("CalculateDragWithoutEngineFailure"));
}
public static void Calculate_WithAirspeedEqualToThresholdAndNoNormalForcePresent_ReturnsExpectedFlightPathAngleRate(AircraftData aircraftData)
{
// Setup
const double heightThreshold = 0.01;
var random = new Random(21);
var aircraftState = new AircraftState(aircraftData.MaximumPitchAngle,
random.NextAngle(),
100,
heightThreshold - random.NextDouble(),
random.NextDouble());
Angle angleOfAttack = aircraftState.PitchAngle - aircraftState.FlightPathAngle;
// Precondition
double lift = AerodynamicsHelper.CalculateLift(aircraftData.AerodynamicsData,
angleOfAttack,
airDensity,
aircraftState.TrueAirspeed);
double takeOffWeightNewton = aircraftData.TakeOffWeight * 1000; // N
Assert.IsTrue(lift > takeOffWeightNewton);
var calculator = new TestTakeOffDynamicsCalculator(aircraftData, airDensity, gravitationalAcceleration);
// Call
AircraftAccelerations accelerations = calculator.Calculate(aircraftState);
// Assert
double expectedRate = (gravitationalAcceleration * (lift - takeOffWeightNewton))
/ (takeOffWeightNewton * aircraftState.TrueAirspeed);
Assert.AreEqual(expectedRate, accelerations.FlightPathRate.Radians, tolerance);
}
private double CalculateLiftForce(AircraftState state)
{
return(AerodynamicsHelper.CalculateLift(AircraftData.AerodynamicsData,
CalculateAngleOfAttack(state),
Density,
state.TrueAirspeed));
}
private static double GetRotationSpeed(AircraftData aircraftData)
{
double stallSpeed = AerodynamicsHelper.CalculateStallSpeed(aircraftData.AerodynamicsData,
aircraftData.TakeOffWeight * 1000,
airDensity);
double rotationSpeed = stallSpeed * 1.2;
return(rotationSpeed);
}
private bool ShouldRotate(AircraftState aircraftState)
{
double rotationSpeed = 1.2 * AerodynamicsHelper.CalculateStallSpeed(AerodynamicsData,
GetNewton(AircraftData.TakeOffWeight),
Density);
return(aircraftState.TrueAirspeed >= rotationSpeed &&
aircraftState.PitchAngle < AircraftData.MaximumPitchAngle);
}
private static IEnumerable <TestCaseData> GetInvalidDensityTestCases()
{
var random = new Random(21);
AerodynamicsData aerodynamicsData = AerodynamicsDataTestFactory.CreateAerodynamicsData();
Angle angleOfAttack = random.NextAngle();
double liftCoefficient = random.NextDouble();
double invalidDensity = -random.NextDouble();
double velocity = random.NextDouble();
double takeOffWeight = random.NextDouble();
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateLift(aerodynamicsData,
angleOfAttack,
invalidDensity,
velocity)))
.SetName("CalculateLift - Negative"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateLift(aerodynamicsData,
angleOfAttack,
0,
velocity)))
.SetName("CalculateLift - Zero"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateDragWithEngineFailure(aerodynamicsData,
liftCoefficient,
invalidDensity,
velocity)))
.SetName("CalculateDragWithEngineFailure - Negative"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateDragWithEngineFailure(aerodynamicsData,
liftCoefficient,
0,
velocity)))
.SetName("CalculateDragWithEngineFailure - Zero"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateDragWithoutEngineFailure(aerodynamicsData,
liftCoefficient,
invalidDensity,
velocity)))
.SetName("CalculateDragWithoutEngineFailure - Negative"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateDragWithoutEngineFailure(aerodynamicsData,
liftCoefficient,
0,
velocity)))
.SetName("CalculateDragWithoutEngineFailure - Zero"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateStallSpeed(aerodynamicsData,
takeOffWeight,
invalidDensity)))
.SetName("CalculateStallSpeed - Negative"));
yield return(new TestCaseData(new Action(() => AerodynamicsHelper.CalculateStallSpeed(aerodynamicsData,
takeOffWeight,
0)))
.SetName("CalculateStallSpeed - Zero"));
}
protected override double CalculateAerodynamicDragForce(AircraftState state)
{
double liftCoefficient = AerodynamicsHelper.CalculateLiftCoefficient(AerodynamicsData,
CalculateAngleOfAttack(state));
return(AerodynamicsHelper.CalculateDragWithEngineFailure(AerodynamicsData,
liftCoefficient,
Density,
state.TrueAirspeed));
}
public static void CalculateStallSpeed_WithValidParametersWithinLimits_ReturnsExpectedValues(AerodynamicsData aerodynamicsData)
{
// Setup
const double weight = 500e3; // N
// Call
double stallSpeed = AerodynamicsHelper.CalculateStallSpeed(aerodynamicsData, weight, airDensity);
// Assert
double expectedStallSpeed = Math.Sqrt(2 * weight / (aerodynamicsData.MaximumLiftCoefficient * airDensity * aerodynamicsData.WingArea));
Assert.AreEqual(expectedStallSpeed, stallSpeed, tolerance);
}
public void CalculateLiftCoefficient_AerodynamicsDataNull_ThrowsArgumentNullException()
{
// Setup
var random = new Random(21);
// Call
TestDelegate call = () => AerodynamicsHelper.CalculateLiftCoefficient(null, random.NextAngle());
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("aerodynamicsData", exception.ParamName);
}
public static void CalculateDragWithoutEngineFailure_WithValidParameters_ReturnsExpectedValues(AerodynamicsData aerodynamicsData)
{
// Setup
var random = new Random(21);
double liftCoefficient = random.NextDouble();
double velocity = random.NextDouble();
// Call
double drag = AerodynamicsHelper.CalculateDragWithoutEngineFailure(aerodynamicsData, liftCoefficient, airDensity, velocity);
// Assert
double expectedDrag = CalculateExpectedDrag(aerodynamicsData, liftCoefficient, airDensity, velocity, false);
Assert.AreEqual(expectedDrag, drag, tolerance);
}
public static void CalculateLift_WithValidParametersAndWithinLimits_ReturnsExpectedValues(AerodynamicsData aerodynamicsData)
{
// Setup
Angle angleOfAttack = Angle.FromDegrees(3.0);
const int velocity = 10; // m/s
// Call
double lift = AerodynamicsHelper.CalculateLift(aerodynamicsData,
angleOfAttack,
airDensity,
velocity);
// Assert
Assert.AreEqual(CalculateExpectedLift(aerodynamicsData, angleOfAttack, airDensity, velocity), lift);
}
public static void CalculateLiftCoefficient_WithAerodynamicsData_ReturnsExpectedLiftCoefficient(AerodynamicsData aerodynamicsData)
{
// Setup
var random = new Random(21);
Angle angleOfAttack = random.NextAngle();
// Call
double liftCoefficient = AerodynamicsHelper.CalculateLiftCoefficient(aerodynamicsData,
angleOfAttack);
// Assert
double expectedLiftCoefficient = CalculateExpectedLiftCoefficient(aerodynamicsData, angleOfAttack);
Assert.AreEqual(expectedLiftCoefficient, liftCoefficient, tolerance);
}
public static void CalculateDragWithEngineFailure_AerodynamicsDataNull_ThrowsArgumentNullException()
{
// Setup
var random = new Random(21);
// Call
TestDelegate call = () => AerodynamicsHelper.CalculateDragWithEngineFailure(null,
random.NextDouble(),
random.NextDouble(),
random.NextDouble());
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("aerodynamicsData", exception.ParamName);
}
public static void CalculateLiftCoefficient_WithInvalidAngleOfAttack_ThrowsInvalidCalculationException(AerodynamicsData aerodynamicsData,
Angle invalidAngleOfAttack,
string expectedExceptionMessage)
{
// Setup
var random = new Random(21);
// Call
TestDelegate call = () => AerodynamicsHelper.CalculateLiftCoefficient(aerodynamicsData,
invalidAngleOfAttack);
// Assert
var exception = Assert.Throws <InvalidCalculationException>(call);
Assert.AreEqual(expectedExceptionMessage, exception.Message);
}
public static void CalculateDragWithoutEngineFailure_InvalidLiftCoefficient_ThrowsInvalidCalculationException(AerodynamicsData aerodynamicsData,
double invalidLiftCoefficient)
{
// Setup
var random = new Random(21);
// Call
TestDelegate call = () => AerodynamicsHelper.CalculateDragWithoutEngineFailure(aerodynamicsData,
invalidLiftCoefficient,
random.NextDouble(),
random.NextDouble());
// Assert
var exception = Assert.Throws <InvalidCalculationException>(call);
Assert.AreEqual("Lift coefficient must be in the range of [0, CLMax].", exception.Message);
}
public static void Calculate_WithAircraftStateHeightSmallerThanThresholdAndLiftSmallerThanTakeOffWeight_ReturnsExpectedTrueAirspeedRate(AircraftData aircraftData)
{
// Setup
const int nrOfFailedEngines = 1;
const double airspeed = 10.0;
const double threshold = 0.01;
var random = new Random(21);
var aircraftState = new AircraftState(aircraftData.MaximumPitchAngle,
random.NextAngle(),
airspeed,
threshold - random.NextDouble(),
random.NextDouble());
Angle angleOfAttack = aircraftState.PitchAngle - aircraftState.FlightPathAngle;
// Precondition
double lift = AerodynamicsHelper.CalculateLift(aircraftData.AerodynamicsData,
angleOfAttack,
airDensity,
airspeed);
double takeOffWeightNewton = aircraftData.TakeOffWeight * 1000; // N
Assert.IsTrue(lift < takeOffWeightNewton);
var calculator = new ContinuedTakeOffDynamicsCalculator(aircraftData, nrOfFailedEngines, airDensity, gravitationalAcceleration);
// Call
AircraftAccelerations accelerations = calculator.Calculate(aircraftState);
// Assert
double liftCoefficient = AerodynamicsHelper.CalculateLiftCoefficient(aircraftData.AerodynamicsData, angleOfAttack);
double normalForce = takeOffWeightNewton - lift;
double dragForce = AerodynamicsHelper.CalculateDragWithEngineFailure(aircraftData.AerodynamicsData,
liftCoefficient,
airDensity,
airspeed) + normalForce * aircraftData.RollingResistanceCoefficient;
double thrustForce = (aircraftData.NrOfEngines - nrOfFailedEngines) * aircraftData.MaximumThrustPerEngine * 1000;
double horizontalWeightComponent = takeOffWeightNewton * Math.Sin(aircraftState.FlightPathAngle.Radians);
double expectedAcceleration = (gravitationalAcceleration * (thrustForce - dragForce - horizontalWeightComponent))
/ takeOffWeightNewton;
Assert.AreEqual(expectedAcceleration, accelerations.TrueAirSpeedRate, tolerance);
}
public static void Calculate_WithAircraftStateHeightSmallerThanThresholdAndLiftSmallerThanTakeOffWeight_ReturnsExpectedTrueAirspeedRate(AircraftData aircraftData)
{
// Setup
const double airspeed = 10.0;
const double threshold = 0.01;
var random = new Random(21);
var aircraftState = new AircraftState(aircraftData.MaximumPitchAngle,
random.NextAngle(),
airspeed,
threshold - random.NextDouble(),
random.NextDouble());
Angle angleOfAttack = aircraftState.PitchAngle - aircraftState.FlightPathAngle;
// Precondition
double lift = AerodynamicsHelper.CalculateLift(aircraftData.AerodynamicsData,
angleOfAttack,
airDensity,
airspeed);
double takeOffWeightNewton = aircraftData.TakeOffWeight * 1000; // N
Assert.IsTrue(lift < takeOffWeightNewton);
double thrust = random.NextDouble() * 1000;
double drag = random.NextDouble() * 100;
double frictionCoefficient = random.NextDouble();
var calculator = new TestTakeOffDynamicsCalculator(aircraftData, airDensity, gravitationalAcceleration)
{
Thrust = thrust,
Drag = drag,
RollDrag = frictionCoefficient
};
// Call
AircraftAccelerations accelerations = calculator.Calculate(aircraftState);
// Assert
double horizontalWeightComponent = takeOffWeightNewton * Math.Sin(aircraftState.FlightPathAngle.Radians);
double groundDrag = frictionCoefficient * (aircraftData.TakeOffWeight * 1000 - lift);
double expectedAcceleration = (gravitationalAcceleration * (thrust - drag - groundDrag - horizontalWeightComponent))
/ takeOffWeightNewton;
Assert.AreEqual(expectedAcceleration, accelerations.TrueAirSpeedRate, tolerance);
}
