static void
CheckLeg(const TaskWaypoint &tp, const AircraftState &aircraft,
const TaskStats &stats)
{
const GeoPoint destination = tp.GetWaypoint().location;
const fixed safety_height = GetSafetyHeight(tp);
const fixed min_arrival_alt = tp.GetWaypoint().elevation + safety_height;
const GeoVector vector = aircraft.location.DistanceBearing(destination);
const fixed ld = glide_polar.GetBestLD();
const fixed height_above_min = aircraft.altitude - min_arrival_alt;
const fixed height_consumption = vector.distance / ld;
const ElementStat &leg = stats.current_leg;
const GlideResult &solution_remaining = leg.solution_remaining;
ok1(leg.vector_remaining.IsValid());
ok1(equals(leg.vector_remaining.distance, vector.distance));
ok1(equals(leg.vector_remaining.bearing, vector.bearing));
ok1(solution_remaining.IsOk());
ok1(solution_remaining.vector.IsValid());
ok1(equals(solution_remaining.vector.distance, vector.distance));
ok1(equals(solution_remaining.vector.bearing, vector.bearing));
ok1(equals(solution_remaining.height_glide, height_consumption));
ok1(equals(solution_remaining.altitude_difference,
height_above_min - height_consumption));
ok1(equals(solution_remaining.GetRequiredAltitudeWithDrift(),
min_arrival_alt + height_consumption));
if (height_above_min >= height_consumption) {
/* straight glide */
ok1(equals(solution_remaining.height_climb, 0));
} else if (positive(glide_polar.GetMC())) {
/* climb required */
ok1(equals(solution_remaining.height_climb,
height_consumption - height_above_min));
} else {
/* climb required, but not possible (MC=0) */
ok1(equals(solution_remaining.height_climb, 0));
}
}
static void
CheckTotal(const AircraftState &aircraft, const TaskStats &stats,
const TaskWaypoint &start, const TaskWaypoint &tp1,
const TaskWaypoint &finish)
{
const fixed min_arrival_alt1 = tp1.GetWaypoint().elevation +
task_behaviour.safety_height_arrival;
const fixed min_arrival_alt2 = finish.GetWaypoint().elevation +
task_behaviour.safety_height_arrival;
const GeoVector vector0 =
start.GetWaypoint().location.DistanceBearing(tp1.GetWaypoint().location);
const GeoVector vector1 =
aircraft.location.DistanceBearing(tp1.GetWaypoint().location);
const GeoVector vector2 =
tp1.GetWaypoint().location.DistanceBearing(finish.GetWaypoint().location);
const fixed ld = glide_polar.GetBestLD();
const fixed height_consumption1 = vector1.distance / ld;
const fixed height_consumption2 = vector2.distance / ld;
const ElementStat &total = stats.total;
const GlideResult &solution_remaining = total.solution_remaining;
const fixed distance_nominal = vector0.distance + vector2.distance;
const fixed distance_ahead = vector1.distance + vector2.distance;
ok1(equals(stats.distance_nominal, distance_nominal));
ok1(equals(stats.distance_min, distance_nominal));
ok1(equals(stats.distance_max, distance_nominal));
ok1(!total.vector_remaining.IsValid());
ok1(solution_remaining.IsOk());
ok1(equals(solution_remaining.vector.distance, distance_ahead));
ok1(equals(solution_remaining.height_glide, distance_ahead / ld));
fixed alt_required_at_1 = std::max(min_arrival_alt1,
min_arrival_alt2 + height_consumption2);
fixed alt_required_at_aircraft = alt_required_at_1 + height_consumption1;
ok1(equals(solution_remaining.GetRequiredAltitudeWithDrift(),
alt_required_at_aircraft));
ok1(equals(solution_remaining.altitude_difference,
aircraft.altitude - alt_required_at_aircraft));
ok1(equals(solution_remaining.height_climb,
positive(glide_polar.GetMC())
? alt_required_at_aircraft - aircraft.altitude
: fixed(0)));
}
void
TaskEventsPrint::ActiveChanged(const TaskWaypoint &tp)
{
if (verbose)
printf("#- active changed to wp %d\n", tp.GetWaypoint().id);
}
