void
OrderedTask::GlideSolutionPlanned(const AircraftState &aircraft,
const GlidePolar &glide_polar,
GlideResult &total,
GlideResult &leg,
DistanceStat &total_remaining_effective,
DistanceStat &leg_remaining_effective,
const GlideResult &solution_remaining_total,
const GlideResult &solution_remaining_leg)
{
if (task_points.empty()) {
total.Reset();
leg.Reset();
total_remaining_effective.Reset();
leg_remaining_effective.Reset();
return;
}
TaskMacCreadyTotal tm(task_points.cbegin(), task_points.cend(),
active_task_point,
task_behaviour.glide, glide_polar);
total = tm.glide_solution(aircraft);
leg = tm.get_active_solution();
if (solution_remaining_total.IsOk())
total_remaining_effective.SetDistance(tm.effective_distance(solution_remaining_total.time_elapsed));
else
total_remaining_effective.Reset();
if (solution_remaining_leg.IsOk())
leg_remaining_effective.SetDistance(tm.effective_leg_distance(solution_remaining_leg.time_elapsed));
else
leg_remaining_effective.Reset();
}
void
OrderedTask::GlideSolutionTravelled(const AircraftState &aircraft,
const GlidePolar &glide_polar,
GlideResult &total,
GlideResult &leg)
{
if (!aircraft.location.IsValid() || task_points.empty()) {
total.Reset();
leg.Reset();
return;
}
TaskMacCreadyTravelled tm(task_points.cbegin(), active_task_point,
task_behaviour.glide, glide_polar);
total = tm.glide_solution(aircraft);
leg = tm.get_active_solution();
}
void
OrderedTask::GlideSolutionRemaining(const AircraftState &aircraft,
const GlidePolar &polar,
GlideResult &total,
GlideResult &leg)
{
if (!aircraft.location.IsValid()) {
total.Reset();
leg.Reset();
return;
}
TaskMacCreadyRemaining tm(task_points.cbegin(), task_points.cend(),
active_task_point,
task_behaviour.glide, polar);
total = tm.glide_solution(aircraft);
leg = tm.get_active_solution();
}
void
UnorderedTask::GlideSolutionRemaining(const AircraftState &state,
const GlidePolar &polar,
GlideResult &total,
GlideResult &leg)
{
GlideResult res;
TaskPoint* tp = GetActiveTaskPoint();
if (tp) {
res = TaskSolution::GlideSolutionRemaining(*tp, state, polar);
res.CalcDeferred();
} else
res.Reset();
total = res;
leg = res;
}
void
UnorderedTask::GlideSolutionRemaining(const AircraftState &state,
const GlidePolar &polar,
GlideResult &total,
GlideResult &leg)
{
GlideResult res;
TaskPoint* tp = GetActiveTaskPoint();
if (tp != nullptr && state.location.IsValid()) {
res = TaskSolution::GlideSolutionRemaining(*tp, state,
task_behaviour.glide, polar);
res.CalcDeferred();
} else
res.Reset();
total = res;
leg = res;
}
GlideResult
MacCready::SolveStraight(const GlideState &task) const
{
if (!glide_polar.IsValid()) {
/* can't solve without a valid GlidePolar() */
GlideResult result;
result.Reset();
return result;
}
if (task.vector.distance <= 0)
return SolveVertical(task);
if (glide_polar.GetMC() <= 0)
// whole task must be glide
return OptimiseGlide(task);
return SolveGlide(task, glide_polar.GetVBestLD());
}
GlideResult
MacCready::Solve(const GlideState &task) const
{
if (!glide_polar.IsValid()) {
/* can't solve without a valid GlidePolar() */
GlideResult result;
result.Reset();
return result;
}
if (task.vector.distance <= 0)
return SolveVertical(task);
if (glide_polar.GetMC() <= 0)
// whole task must be glide
return OptimiseGlide(task, false);
if (task.altitude_difference < 0)
// whole task climb-cruise
return SolveCruise(task);
// task partial climb-cruise, partial glide
// calc first final glide part
GlideResult result_fg = SolveGlide(task, glide_polar.GetVBestLD(), true);
if (result_fg.validity == GlideResult::Validity::OK &&
task.vector.distance - result_fg.vector.distance <= 0)
// whole task final glided
return result_fg;
// climb-cruise remainder of way
GlideState sub_task = task;
sub_task.vector.distance -= result_fg.vector.distance;
sub_task.altitude_difference -= result_fg.height_glide;
GlideResult result_cc = SolveCruise(sub_task);
result_fg.Add(result_cc);
return result_fg;
}
Alternate(const Waypoint &_waypoint)
:waypoint(_waypoint)
{
solution.Reset();
}
