static bool
test_null()
{
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
setup_waypoints(waypoints);
if (verbose)
distance_counts();
TaskEventsPrint default_events(verbose);
TaskManager task_manager(waypoints);
task_manager.SetTaskEvents(default_events);
TaskBehaviour task_behaviour = task_manager.GetTaskBehaviour();
task_behaviour.DisableAll();
task_behaviour.enable_trace = false;
task_manager.SetTaskBehaviour(task_behaviour);
task_manager.SetGlidePolar(glide_polar);
task_report(task_manager, "null");
waypoints.Clear(); // clear waypoints so abort wont do anything
autopilot_parms.goto_target = true;
return run_flight(task_manager, autopilot_parms, 0);
}
static bool
test_goto(int n_wind, unsigned id, bool auto_mc)
{
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
setup_waypoints(waypoints);
if (verbose)
distance_counts();
TaskEventsPrint default_events(verbose);
TaskManager task_manager(waypoints);
task_manager.SetTaskEvents(default_events);
TaskBehaviour task_behaviour = task_manager.GetTaskBehaviour();
task_behaviour.DisableAll();
task_behaviour.auto_mc = auto_mc;
task_behaviour.enable_trace = false;
task_manager.SetTaskBehaviour(task_behaviour);
task_manager.SetGlidePolar(glide_polar);
test_task(task_manager, waypoints, 1);
task_manager.DoGoto(*waypoints.LookupId(id));
task_report(task_manager, "goto");
waypoints.Clear(); // clear waypoints so abort wont do anything
autopilot_parms.goto_target = true;
return run_flight(task_manager, autopilot_parms, n_wind);
}
static bool
test_abort(int n_wind)
{
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
setup_waypoints(waypoints);
if (verbose)
distance_counts();
TaskEventsPrint default_events(verbose);
TaskManager task_manager(waypoints);
task_manager.SetTaskEvents(default_events);
TaskBehaviour task_behaviour = task_manager.GetTaskBehaviour();
task_behaviour.DisableAll();
task_behaviour.enable_trace = false;
task_manager.SetTaskBehaviour(task_behaviour);
task_manager.SetGlidePolar(glide_polar);
test_task(task_manager, waypoints, 1);
task_manager.Abort();
task_report(task_manager, "abort");
autopilot_parms.goto_target = true;
return run_flight(task_manager, autopilot_parms, n_wind);
}
bool
test_flight(int test_num, int n_wind, const double speed_factor,
const bool auto_mc)
{
// multipurpose flight test
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
setup_waypoints(waypoints);
if (verbose)
distance_counts();
TaskEventsPrint default_events(verbose);
TaskManager task_manager(default_events, waypoints);
task_manager.set_glide_polar(glide_polar);
task_manager.get_ordered_task_behaviour().aat_min_time = aat_min_time(test_num);
TaskBehaviour task_behaviour = task_manager.get_task_behaviour();
task_behaviour.enable_trace = false;
task_behaviour.auto_mc = auto_mc;
task_behaviour.calc_glide_required = false;
if ((test_num == 0) || (test_num == 2))
task_behaviour.optimise_targets_bearing = false;
task_manager.set_task_behaviour(task_behaviour);
bool goto_target = false;
switch (test_num) {
case 0:
case 2:
case 7:
goto_target = true;
break;
};
autopilot_parms.goto_target = goto_target;
test_task(task_manager, waypoints, test_num);
waypoints.clear(); // clear waypoints so abort wont do anything
return run_flight(task_manager, autopilot_parms, n_wind,
speed_factor);
}
static bool
test_replay(const OLCRules olc_type)
{
#ifdef DO_PRINT
std::ofstream f("results/res-sample.txt");
#endif
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
AIRCRAFT_STATE state_last;
TaskBehaviour task_behaviour;
TaskEventsPrint default_events(verbose);
TaskManager task_manager(default_events,
waypoints);
task_manager.set_glide_polar(glide_polar);
task_manager.get_task_behaviour().olc_rules = olc_type;
task_manager.get_task_behaviour().enable_olc = true;
ReplayLoggerSim sim;
TCHAR szFilename[MAX_PATH];
ConvertCToT(szFilename, replay_file.c_str());
sim.SetFilename(szFilename);
sim.Start();
bool do_print = verbose;
unsigned print_counter=0;
while (sim.Update() && !sim.started) {
}
state_last = sim.state;
fixed time_last = sim.state.Time;
while (sim.Update()) {
if (sim.state.Time>time_last) {
n_samples++;
if (sim.state.Speed> glide_polar.get_Vtakeoff()) {
sim.state.flying_state_moving(sim.state.Time);
} else {
sim.state.flying_state_stationary(sim.state.Time);
}
task_manager.update(sim.state, state_last);
task_manager.update_idle(sim.state);
task_manager.update_auto_mc(sim.state, fixed_zero);
state_last = sim.state;
#ifdef DO_PRINT
if (verbose) {
sim.print(f);
f.flush();
}
if (do_print) {
task_manager.print(sim.state);
}
#endif
do_print = (++print_counter % output_skip ==0) && verbose;
}
time_last = sim.state.Time;
};
sim.Stop();
const CommonStats& stats = task_manager.get_common_stats();
printf("# OLC dist %g speed %g time %g\n",
(double)stats.olc.distance,
(double)(stats.olc.speed*fixed(3.6)),
(double)stats.olc.time);
if (verbose) {
distance_counts();
}
return true;
}
static bool
test_replay(const Contests olc_type,
const ContestResult &official_score)
{
std::ofstream f("results/res-sample.txt");
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
AIRCRAFT_STATE state_last;
TaskBehaviour task_behaviour;
TaskEventsPrint default_events(verbose);
TaskManager task_manager(default_events,
waypoints);
task_manager.set_glide_polar(glide_polar);
task_manager.set_contest(olc_type);
task_manager.get_task_behaviour().enable_olc = true;
ReplayLoggerSim sim;
TCHAR szFilename[MAX_PATH];
ConvertCToT(szFilename, replay_file.c_str());
sim.SetFilename(szFilename);
load_scores(task_manager.get_task_behaviour().contest_handicap);
if (verbose) {
switch (olc_type) {
case OLC_League:
std::cout << "# OLC-League\n";
break;
case OLC_Sprint:
std::cout << "# OLC-Sprint\n";
break;
case OLC_FAI:
std::cout << "# OLC-FAI\n";
break;
case OLC_Classic:
std::cout << "# OLC-Classic\n";
break;
case OLC_Plus:
std::cout << "# OLC-Plus\n";
break;
default:
std::cout << "# Unknown!\n";
break;
}
}
sim.Start();
bool do_print = verbose;
unsigned print_counter=0;
while (sim.Update() && !sim.started) {
}
state_last = sim.state;
fixed time_last = sim.state.Time;
while (sim.Update()) {
if (sim.state.Time>time_last) {
n_samples++;
if (sim.state.Speed> glide_polar.get_Vtakeoff()) {
sim.state.flying_state_moving(sim.state.Time);
} else {
sim.state.flying_state_stationary(sim.state.Time);
}
task_manager.update(sim.state, state_last);
task_manager.update_idle(sim.state);
state_last = sim.state;
if (verbose>1) {
sim.print(f);
f.flush();
}
if (do_print) {
PrintHelper::taskmanager_print(task_manager, sim.state);
}
do_print = (++print_counter % output_skip ==0) && verbose;
}
time_last = sim.state.Time;
};
sim.Stop();
task_manager.score_exhaustive();
if (verbose) {
distance_counts();
}
return compare_scores(official_score,
task_manager.get_contest_stats().get_contest_result(0));
}
static bool
test_replay()
{
std::ofstream f("results/res-sample.txt");
GlidePolar glide_polar(fixed(4.0));
Waypoints waypoints;
AIRCRAFT_STATE state_last;
TaskBehaviour task_behaviour;
TaskEventsPrint default_events(verbose);
TaskManager task_manager(default_events,
waypoints);
glide_polar.set_ballast(fixed(1.0));
task_manager.set_glide_polar(glide_polar);
task_manager.get_task_behaviour().auto_mc = true;
task_manager.get_task_behaviour().enable_trace = false;
OrderedTask* blank =
new OrderedTask(default_events, task_behaviour, glide_polar);
OrderedTask* t = task_load(blank);
if (t) {
task_manager.commit(*t);
task_manager.resume();
} else {
return false;
}
// task_manager.get_task_advance().get_advance_state() = TaskAdvance::AUTO;
ReplayLoggerSim sim;
sim.state.NettoVario = fixed_zero;
TCHAR szFilename[MAX_PATH];
ConvertCToT(szFilename, replay_file.c_str());
sim.SetFilename(szFilename);
sim.Start();
bool do_print = verbose;
unsigned print_counter=0;
while (sim.Update() && !sim.started) {
}
state_last = sim.state;
sim.state.wind.norm = fixed(7);
sim.state.wind.bearing = Angle::degrees(fixed(330));
fixed time_last = sim.state.Time;
// uncomment this to manually go to first tp
// task_manager.incrementActiveTaskPoint(1);
while (sim.Update()) {
if (sim.state.Time>time_last) {
n_samples++;
if (sim.state.Speed> glide_polar.get_Vtakeoff()) {
sim.state.flying_state_moving(sim.state.Time);
} else {
sim.state.flying_state_stationary(sim.state.Time);
}
task_manager.update(sim.state, state_last);
task_manager.update_idle(sim.state);
task_manager.update_auto_mc(sim.state, fixed_zero);
task_manager.get_task_advance().set_armed(true);
state_last = sim.state;
if (verbose>1) {
sim.print(f);
f.flush();
}
if (do_print) {
PrintHelper::taskmanager_print(task_manager, sim.state);
}
do_print = (++print_counter % output_skip ==0) && verbose;
}
time_last = sim.state.Time;
};
sim.Stop();
if (verbose) {
distance_counts();
printf("# task elapsed %d (s)\n", (int)task_manager.get_stats().total.TimeElapsed);
printf("# task speed %3.1f (kph)\n", (int)task_manager.get_stats().total.travelled.get_speed()*3.6);
printf("# travelled distance %4.1f (km)\n",
(double)task_manager.get_stats().total.travelled.get_distance()/1000.0);
printf("# scored distance %4.1f (km)\n",
(double)task_manager.get_stats().distance_scored/1000.0);
if (task_manager.get_stats().total.TimeElapsed) {
printf("# scored speed %3.1f (kph)\n",
(double)task_manager.get_stats().distance_scored/(double)task_manager.get_stats().total.TimeElapsed*3.6);
}
}
return true;
}
bool run_flight(TaskManager &task_manager,
const AutopilotParameters &parms,
const int n_wind,
const double speed_factor)
{
DirectTaskAccessor ta(task_manager);
PrintTaskAutoPilot autopilot(parms);
AircraftSim aircraft;
autopilot.set_default_location(GeoPoint(Angle::degrees(fixed(1.0)), Angle::degrees(fixed(0.0))));
unsigned print_counter=0;
if (n_wind)
aircraft.set_wind(wind_to_mag(n_wind), wind_to_dir(n_wind));
autopilot.set_speed_factor(fixed(speed_factor));
std::ofstream f4("results/res-sample.txt");
std::ofstream f5("results/res-sample-filtered.txt");
bool do_print = verbose;
bool first = true;
time_elapsed = 0.0;
time_planned = 1.0;
time_remaining = 0;
calc_cruise_efficiency = 1.0;
calc_effective_mc = 1.0;
static const fixed fixed_10(10);
AirspaceAircraftPerformanceGlide perf(task_manager.get_glide_polar());
if (aircraft_filter)
aircraft_filter->Reset(aircraft.get_state());
autopilot.Start(ta);
aircraft.Start(autopilot.location_start, autopilot.location_previous,
parms.start_alt);
if (airspaces) {
airspace_warnings =
new AirspaceWarningManager(*airspaces, task_manager);
airspace_warnings->reset(aircraft.get_state());
}
do {
if ((task_manager.getActiveTaskPointIndex() == 1) &&
first && (task_manager.get_stats().total.time_elapsed > fixed_10)) {
time_remaining = task_manager.get_stats().total.time_remaining;
first = false;
time_planned = task_manager.get_stats().total.time_planned;
if (verbose > 1) {
printf("# time remaining %g\n", time_remaining);
printf("# time planned %g\n", time_planned);
}
}
if (do_print) {
PrintHelper::taskmanager_print(task_manager, aircraft.get_state());
const AircraftState state = aircraft.get_state();
f4 << state.time << " "
<< state.location.Longitude << " "
<< state.location.Latitude << " "
<< state.altitude << "\n";
f4.flush();
if (aircraft_filter) {
f5 << aircraft_filter->GetSpeed() << " "
<< aircraft_filter->GetBearing() << " "
<< aircraft_filter->GetClimbRate() << "\n";
f5.flush();
}
}
if (airspaces) {
scan_airspaces(aircraft.get_state(), *airspaces, perf,
do_print,
autopilot.target(ta));
}
if (airspace_warnings) {
if (verbose > 1) {
bool warnings_updated = airspace_warnings->update(aircraft.get_state(),
false, 1);
if (warnings_updated) {
printf("# airspace warnings updated, size %d\n",
(int)airspace_warnings->size());
print_warnings();
wait_prompt();
}
}
}
n_samples++;
do_print = (++print_counter % output_skip == 0) && verbose;
if (aircraft_filter)
aircraft_filter->Update(aircraft.get_state());
autopilot.update_state(ta, aircraft.get_state());
aircraft.Update(autopilot.heading);
{
const AircraftState state = aircraft.get_state();
const AircraftState state_last = aircraft.get_state_last();
task_manager.update(state, state_last);
task_manager.update_idle(state);
task_manager.update_auto_mc(state, fixed_zero);
}
} while (autopilot.update_autopilot(ta, aircraft.get_state(), aircraft.get_state_last()));
aircraft.Stop();
autopilot.Stop();
if (verbose) {
PrintHelper::taskmanager_print(task_manager, aircraft.get_state());
const AircraftState state = aircraft.get_state();
f4 << state.time << " "
<< state.location.Longitude << " "
<< state.location.Latitude << " "
<< state.altitude << "\n";
f4 << "\n";
f4.flush();
task_report(task_manager, "end of task\n");
}
wait_prompt();
time_elapsed = task_manager.get_stats().total.time_elapsed;
time_planned = task_manager.get_stats().total.time_planned;
calc_cruise_efficiency = task_manager.get_stats().cruise_efficiency;
calc_effective_mc = task_manager.get_stats().effective_mc;
if (verbose)
distance_counts();
if (airspace_warnings)
delete airspace_warnings;
return true;
}
