static bool
test_goto(int n_wind, unsigned id, bool auto_mc)
{
GlidePolar glide_polar(fixed(2));
Waypoints waypoints;
SetupWaypoints(waypoints);
if (verbose)
PrintDistanceCounts();
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
task_behaviour.DisableAll();
task_behaviour.auto_mc = auto_mc;
task_behaviour.enable_trace = false;
TaskManager task_manager(task_behaviour, waypoints);
TaskEventsPrint default_events(verbose);
task_manager.SetTaskEvents(default_events);
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_olc(int n_wind, Contest olc_type)
{
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
SetupWaypoints(waypoints);
if (verbose)
PrintDistanceCounts();
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
task_behaviour.DisableAll();
if (!verbose)
task_behaviour.enable_trace = false;
TaskManager task_manager(task_behaviour, waypoints);
TaskEventsPrint default_events(verbose);
task_manager.SetTaskEvents(default_events);
task_manager.SetGlidePolar(glide_polar);
test_task(task_manager, waypoints, 1);
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_null()
{
GlidePolar glide_polar(fixed(2));
Waypoints waypoints;
SetupWaypoints(waypoints);
if (verbose)
PrintDistanceCounts();
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
task_behaviour.DisableAll();
task_behaviour.enable_trace = false;
TaskManager task_manager(task_behaviour, waypoints);
TaskEventsPrint default_events(verbose);
task_manager.SetTaskEvents(default_events);
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_abort(int n_wind)
{
GlidePolar glide_polar(fixed(2));
Waypoints waypoints;
SetupWaypoints(waypoints);
if (verbose)
PrintDistanceCounts();
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
task_behaviour.DisableAll();
task_behaviour.enable_trace = false;
TaskManager task_manager(task_behaviour, waypoints);
TaskEventsPrint default_events(verbose);
task_manager.SetTaskEvents(default_events);
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);
}
static task_edit_result
remove_from_task(const Waypoint &wp)
{
ProtectedTaskManager::ExclusiveLease task_manager(protected_task_manager);
TaskEvents task_events;
GlidePolar glide_polar(task_manager->get_glide_polar());
std::auto_ptr<OrderedTask> task(task_manager->clone(task_events,
XCSoarInterface::SettingsComputer(),
glide_polar));
task->check_duplicate_waypoints(way_points);
bool modified = false;
for (unsigned i = task->task_size(); i--;) {
const OrderedTaskPoint *tp = task->get_tp(i);
assert(tp != NULL);
if (tp->get_waypoint() == wp) {
task->remove(i);
modified = true;
}
}
if (!modified)
return UNMODIFIED;
if (!task->check_task())
return INVALID;
task_manager->commit(*task);
return SUCCESS;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
printf("# time wind_bearing (deg) wind_speed (m/s)\n");
GlidePolar glide_polar(fixed(0));
CirclingSettings circling_settings;
WindSettings wind_settings;
wind_settings.SetDefaults();
CirclingComputer circling_computer;
circling_computer.Reset();
WindComputer wind_computer;
wind_computer.Reset();
Validity last;
last.Clear();
while (replay->Next()) {
const MoreData &basic = replay->Basic();
const DerivedInfo &calculated = replay->Calculated();
circling_computer.TurnRate(replay->SetCalculated(),
basic, calculated.flight);
circling_computer.Turning(replay->SetCalculated(),
basic,
calculated.flight,
circling_settings);
wind_computer.Compute(wind_settings, glide_polar, basic,
replay->SetCalculated());
if (calculated.estimated_wind_available.Modified(last)) {
TCHAR time_buffer[32];
FormatTime(time_buffer, replay->Basic().time);
_tprintf(_T("%s %d %g\n"),
time_buffer, (int)calculated.estimated_wind.bearing.Degrees(),
(double)calculated.estimated_wind.norm);
}
last = calculated.estimated_wind_available;
}
delete replay;
}
TestFlightResult
test_flight(TestFlightComponents components, int test_num, int n_wind,
const double speed_factor, const bool auto_mc)
{
// multipurpose flight test
GlidePolar glide_polar(fixed(2));
Waypoints waypoints;
SetupWaypoints(waypoints);
if (verbose)
PrintDistanceCounts();
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
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;
TaskManager task_manager(task_behaviour, waypoints);
TaskEventsPrint default_events(verbose);
task_manager.SetTaskEvents(default_events);
task_manager.SetGlidePolar(glide_polar);
OrderedTaskSettings otb = task_manager.GetOrderedTask().GetOrderedTaskSettings();
otb.aat_min_time = aat_min_time(test_num);
task_manager.SetOrderedTaskSettings(otb);
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(components, task_manager, autopilot_parms, n_wind,
speed_factor);
}
static task_edit_result
remove_from_task(const Waypoint &wp)
{
assert(protected_task_manager != NULL);
ProtectedTaskManager::ExclusiveLease task_manager(*protected_task_manager);
TaskEvents task_events;
GlidePolar glide_polar(task_manager->get_glide_polar());
OrderedTask *task = task_manager->clone(task_events,
XCSoarInterface::SettingsComputer(),
glide_polar);
task_edit_result result = remove_from_task(task, wp);
if (result == SUCCESS)
task_manager->commit(*task);
delete task;
return result;
}
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);
}
int main(int argc, char** argv)
{
if (!parse_args(argc,argv)) {
return 0;
}
#define NUM_RANDOM 50
#define NUM_TYPE_MANIPS 50
plan_tests(NUM_TASKS+2+NUM_RANDOM+8+NUM_TYPE_MANIPS);
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
setup_waypoints(waypoints);
{
TaskManager task_manager(waypoints);
task_manager.SetGlidePolar(glide_polar);
test_task_bad(task_manager,waypoints);
}
{
for (unsigned i = 0; i < NUM_TYPE_MANIPS; i++) {
TaskManager task_manager(waypoints);
ok(test_task_type_manip(task_manager,waypoints, i+2), "construction: task type manip", 0);
}
}
for (int i=0; i<NUM_TASKS+2; i++) {
TaskManager task_manager(waypoints);
task_manager.SetGlidePolar(glide_polar);
ok(test_task(task_manager, waypoints, i),test_name("construction",i,0),0);
}
for (int i=0; i<NUM_RANDOM; i++) {
TaskManager task_manager(waypoints);
task_manager.SetGlidePolar(glide_polar);
ok(test_task(task_manager, waypoints, 7),test_name("construction",7,0),0);
}
return exit_status();
}
static task_edit_result
append_to_task(const Waypoint &wp)
{
ProtectedTaskManager::ExclusiveLease task_manager(protected_task_manager);
TaskEvents task_events;
GlidePolar glide_polar(task_manager->get_glide_polar());
std::auto_ptr<OrderedTask> task(task_manager->clone(task_events,
XCSoarInterface::SettingsComputer(),
glide_polar));
int i = task->task_size() - 1;
/* skip all finish points */
while (i >= 0) {
const TaskPoint *tp = task->get_tp(i);
if (tp == NULL)
break;
if (tp->is_intermediate()) {
++i;
break;
}
--i;
}
const AbstractTaskFactory &factory = task->get_factory();
OrderedTaskPoint *tp = (OrderedTaskPoint *)factory.createIntermediate(wp);
if (tp == NULL)
return UNMODIFIED;
if (!(i >= 0 ? task->insert(tp, i) : task->append(tp))) {
delete tp;
return UNMODIFIED;
}
if (!task->check_task())
return INVALID;
task_manager->commit(*task);
return SUCCESS;
}
int main(int argc, char** argv) {
// default arguments
verbose=1;
if (!parse_args(argc,argv)) {
return 0;
}
TaskBehaviour task_behaviour;
TaskEventsPrint default_events(verbose);
GlidePolar glide_polar(fixed_two);
Waypoints waypoints;
setup_waypoints(waypoints);
TaskManager task_manager(default_events,
task_behaviour,
waypoints);
task_manager.set_glide_polar(glide_polar);
test_task(task_manager, waypoints, 0);
plan_tests(1);
ok(test_edit(task_manager, task_behaviour),
"edit task", 0);
/*
plan_tests(task_manager.task_size());
// here goes, example, edit all task points
SafeTaskEdit ste(task_manager, waypoints);
for (unsigned i=0; i<task_manager.task_size(); i++) {
ok(ste.edit(i),"edit tp",0);
task_report(task_manager, "edit tp\n");
}
*/
return exit_status();
}
static task_edit_result
replace_in_task(const Waypoint &wp)
{
ProtectedTaskManager::ExclusiveLease task_manager(protected_task_manager);
TaskEvents task_events;
GlidePolar glide_polar(task_manager->get_glide_polar());
std::auto_ptr<OrderedTask> task(task_manager->clone(task_events,
XCSoarInterface::SettingsComputer(),
glide_polar));
task->check_duplicate_waypoints(way_points);
unsigned i = task->getActiveIndex();
if (i >= task->task_size())
return UNMODIFIED;
task->relocate(i, wp);
if (!task->check_task())
return INVALID;
task_manager->commit(*task);
return SUCCESS;
}
static bool
test_route(const unsigned n_airspaces, const RasterMap& map)
{
Airspaces airspaces;
setup_airspaces(airspaces, map.GetMapCenter(), n_airspaces);
{
std::ofstream fout("results/terrain.txt");
unsigned nx = 100;
unsigned ny = 100;
GeoPoint origin(map.GetMapCenter());
for (unsigned i = 0; i < nx; ++i) {
for (unsigned j = 0; j < ny; ++j) {
fixed fx = (fixed)i / (nx - 1) * fixed(2.0) - fixed_one;
fixed fy = (fixed)j / (ny - 1) * fixed(2.0) - fixed_one;
GeoPoint x(origin.longitude + Angle::Degrees(fixed(0.2) + fixed(0.7) * fx),
origin.latitude + Angle::Degrees(fixed(0.9) * fy));
short h = map.GetInterpolatedHeight(x);
fout << x.longitude.Degrees() << " " << x.latitude.Degrees()
<< " " << h << "\n";
}
fout << "\n";
}
fout << "\n";
}
{
// local scope, see what happens when we go out of scope
GeoPoint p_start(Angle::Degrees(fixed(-0.3)), Angle::Degrees(fixed(0.0)));
p_start += map.GetMapCenter();
GeoPoint p_dest(Angle::Degrees(fixed(0.8)), Angle::Degrees(fixed(-0.7)));
p_dest += map.GetMapCenter();
AGeoPoint loc_start(p_start, RoughAltitude(map.GetHeight(p_start) + 100));
AGeoPoint loc_end(p_dest, RoughAltitude(map.GetHeight(p_dest) + 100));
AircraftState state;
GlidePolar glide_polar(fixed(0.1));
AirspaceAircraftPerformanceGlide perf(glide_polar);
GeoVector vec(loc_start, loc_end);
fixed range = fixed(10000) + vec.distance / 2;
state.location = loc_start;
state.altitude = loc_start.altitude;
{
Airspaces as_route(airspaces, false);
// dummy
// real one, see if items changed
as_route.synchronise_in_range(airspaces, vec.MidPoint(loc_start), range);
int size_1 = as_route.size();
if (verbose)
printf("# route airspace size %d\n", size_1);
as_route.synchronise_in_range(airspaces, vec.MidPoint(loc_start), fixed_one);
int size_2 = as_route.size();
if (verbose)
printf("# route airspace size %d\n", size_2);
ok(size_2 < size_1, "shrink as", 0);
// go back
as_route.synchronise_in_range(airspaces, vec.MidPoint(loc_end), range);
int size_3 = as_route.size();
if (verbose)
printf("# route airspace size %d\n", size_3);
ok(size_3 >= size_2, "grow as", 0);
// and again
as_route.synchronise_in_range(airspaces, vec.MidPoint(loc_start), range);
int size_4 = as_route.size();
if (verbose)
printf("# route airspace size %d\n", size_4);
ok(size_4 >= size_3, "grow as", 0);
scan_airspaces(state, as_route, perf, true, loc_end);
}
// try the solver
SpeedVector wind(Angle::Degrees(fixed(0)), fixed(0.0));
GlidePolar polar(fixed_one);
GlideSettings settings;
settings.SetDefaults();
AirspaceRoute route(airspaces);
route.UpdatePolar(settings, polar, polar, wind);
route.SetTerrain(&map);
RoutePlannerConfig config;
config.mode = RoutePlannerConfig::Mode::BOTH;
bool sol = false;
for (int i = 0; i < NUM_SOL; i++) {
loc_end.latitude += Angle::Degrees(fixed(0.1));
loc_end.altitude = map.GetHeight(loc_end) + 100;
route.Synchronise(airspaces, loc_start, loc_end);
if (route.Solve(loc_start, loc_end, config)) {
sol = true;
if (verbose) {
PrintHelper::print_route(route);
}
} else {
if (verbose) {
printf("# fail\n");
}
sol = false;
}
char buffer[80];
sprintf(buffer, "route %d solution", i);
ok(sol, buffer, 0);
}
}
return true;
}
static bool
test_replay()
{
Directory::Create(Path(_T("output/results")));
std::ofstream f("output/results/res-sample.txt");
GlidePolar glide_polar(4.0);
Waypoints waypoints;
AircraftState state_last;
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
task_behaviour.auto_mc = true;
TaskManager task_manager(task_behaviour, waypoints);
TaskEventsPrint default_events(verbose);
task_manager.SetTaskEvents(default_events);
glide_polar.SetBallast(1.0);
task_manager.SetGlidePolar(glide_polar);
OrderedTask* t = task_load(task_behaviour);
if (t) {
task_manager.Commit(*t);
delete t;
task_manager.Resume();
} else {
return false;
}
// task_manager.get_task_advance().get_advance_state() = TaskAdvance::AUTO;
Error error;
FileLineReaderA *reader = new FileLineReaderA(replay_file, error);
if (reader->error()) {
delete reader;
fprintf(stderr, "%s\n", error.GetMessage());
return false;
}
ReplayLoggerSim sim(reader);
sim.state.netto_vario = 0;
bool do_print = verbose;
unsigned print_counter=0;
NMEAInfo basic;
basic.Reset();
while (sim.Update(basic) && !sim.started) {
}
state_last = sim.state;
sim.state.wind.norm = 7;
sim.state.wind.bearing = Angle::Degrees(330);
auto time_last = sim.state.time;
// uncomment this to manually go to first tp
// task_manager.incrementActiveTaskPoint(1);
FlyingComputer flying_computer;
flying_computer.Reset();
FlyingState flying_state;
flying_state.Reset();
while (sim.Update(basic)) {
if (sim.state.time>time_last) {
n_samples++;
flying_computer.Compute(glide_polar.GetVTakeoff(),
sim.state, sim.state.time - time_last,
flying_state);
sim.state.flying = flying_state.flying;
task_manager.Update(sim.state, state_last);
task_manager.UpdateIdle(sim.state);
task_manager.UpdateAutoMC(sim.state, 0);
task_manager.SetTaskAdvance().SetArmed(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;
};
if (verbose) {
PrintDistanceCounts();
printf("# task elapsed %d (s)\n", (int)task_manager.GetStats().total.time_elapsed);
printf("# task speed %3.1f (kph)\n", (int)task_manager.GetStats().total.travelled.GetSpeed()*3.6);
printf("# travelled distance %4.1f (km)\n",
(double)task_manager.GetStats().total.travelled.GetDistance()/1000.0);
printf("# scored distance %4.1f (km)\n",
(double)task_manager.GetStats().distance_scored/1000.0);
if (task_manager.GetStats().total.time_elapsed > 0) {
printf("# scored speed %3.1f (kph)\n",
(double)task_manager.GetStats().distance_scored/(double)task_manager.GetStats().total.time_elapsed*3.6);
}
}
return true;
}
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;
}
void
Run(DebugReplay &replay, FlightPhaseDetector &flight_phase_detector,
WindList &wind_list,
const BrokenDateTime &takeoff_time,
const BrokenDateTime &scoring_start_time,
const BrokenDateTime &scoring_end_time,
const BrokenDateTime &landing_time,
Trace &full_trace, Trace &triangle_trace, Trace &sprint_trace,
ComputerSettings &computer_settings)
{
GeoPoint last_location = GeoPoint::Invalid();
constexpr Angle max_longitude_change = Angle::Degrees(30);
constexpr Angle max_latitude_change = Angle::Degrees(1);
CirclingSettings circling_settings;
circling_settings.SetDefaults();
CirclingComputer circling_computer;
circling_computer.Reset();
GlidePolar glide_polar(0);
WindSettings wind_settings;
wind_settings.SetDefaults();
WindComputer wind_computer;
wind_computer.Reset();
Validity last_wind;
last_wind.Clear();
const Waypoints waypoints;
AutoQNH auto_qnh(5);
auto_qnh.Reset();
const int64_t takeoff_unix = takeoff_time.ToUnixTimeUTC();
const int64_t landing_unix = landing_time.ToUnixTimeUTC();
int64_t scoring_start_unix, scoring_end_unix;
if (scoring_start_time.IsPlausible())
scoring_start_unix = scoring_start_time.ToUnixTimeUTC();
else
scoring_start_unix = std::numeric_limits<int64_t>::max();
if (scoring_end_time.IsPlausible())
scoring_end_unix = scoring_end_time.ToUnixTimeUTC();
else
scoring_end_unix = 0;
while (replay.Next()) {
const MoreData &basic = replay.Basic();
const int64_t date_time_utc = basic.date_time_utc.ToUnixTimeUTC();
if (date_time_utc < takeoff_unix)
continue;
if (date_time_utc > landing_unix)
break;
circling_computer.TurnRate(replay.SetCalculated(),
replay.Basic(),
replay.Calculated().flight);
circling_computer.Turning(replay.SetCalculated(),
replay.Basic(),
replay.Calculated().flight,
circling_settings);
flight_phase_detector.Update(replay.Basic(), replay.Calculated());
wind_computer.Compute(wind_settings, glide_polar, basic,
replay.SetCalculated());
if (replay.Calculated().estimated_wind_available.Modified(last_wind)) {
wind_list.push_back(WindListItem(basic.date_time_utc, basic.gps_altitude,
replay.Calculated().estimated_wind));
}
last_wind = replay.Calculated().estimated_wind_available;
auto_qnh.Process(basic, replay.SetCalculated(), computer_settings, waypoints);
if (!computer_settings.pressure_available && replay.Calculated().pressure_available) {
computer_settings.pressure = replay.Calculated().pressure;
computer_settings.pressure_available = replay.Calculated().pressure_available;
}
if (!basic.time_available || !basic.location_available ||
!basic.NavAltitudeAvailable())
continue;
if (last_location.IsValid() &&
((last_location.latitude - basic.location.latitude).Absolute() > max_latitude_change ||
(last_location.longitude - basic.location.longitude).Absolute() > max_longitude_change))
/* there was an implausible warp, which is usually triggered by
an invalid point declared "valid" by a bugged logger; if that
happens, we stop the analysis, because the IGC file is
obviously broken */
break;
last_location = basic.location;
if (date_time_utc >= scoring_start_unix && date_time_utc <= scoring_end_unix) {
const TracePoint point(basic);
full_trace.push_back(point);
triangle_trace.push_back(point);
sprint_trace.push_back(point);
}
}
flight_phase_detector.Finish();
}
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;
}
static bool
test_replay(const Contest olc_type,
const ContestResult &official_score)
{
Directory::Create(_T("output/results"));
std::ofstream f("output/results/res-sample.txt");
GlidePolar glide_polar(fixed(2));
Error error;
FileLineReaderA *reader = new FileLineReaderA(replay_file.c_str(), error);
if (reader->error()) {
delete reader;
fprintf(stderr, "%s\n", error.GetMessage());
return false;
}
ReplayLoggerSim sim(reader);
ComputerSettings settings_computer;
settings_computer.SetDefaults();
settings_computer.contest.enable = true;
load_scores(settings_computer.contest.handicap);
if (verbose) {
switch (olc_type) {
case Contest::OLC_LEAGUE:
std::cout << "# OLC-League\n";
break;
case Contest::OLC_SPRINT:
std::cout << "# OLC-Sprint\n";
break;
case Contest::OLC_FAI:
std::cout << "# OLC-FAI\n";
break;
case Contest::OLC_CLASSIC:
std::cout << "# OLC-Classic\n";
break;
case Contest::OLC_PLUS:
std::cout << "# OLC-Plus\n";
break;
default:
std::cout << "# Unknown!\n";
break;
}
}
bool do_print = verbose;
unsigned print_counter=0;
MoreData basic;
basic.Reset();
FlyingComputer flying_computer;
flying_computer.Reset();
FlyingState flying_state;
flying_state.Reset();
TraceComputer trace_computer;
ContestManager contest_manager(olc_type,
trace_computer.GetFull(),
trace_computer.GetFull(),
trace_computer.GetSprint());
contest_manager.SetHandicap(settings_computer.contest.handicap);
DerivedInfo calculated;
while (sim.Update(basic)) {
n_samples++;
flying_computer.Compute(glide_polar.GetVTakeoff(),
basic, calculated,
flying_state);
calculated.flight.flying = true;
trace_computer.Update(settings_computer, basic, calculated);
contest_manager.UpdateIdle();
if (verbose>1) {
sim.print(f, basic);
f.flush();
}
if (do_print) {
PrintHelper::trace_print(trace_computer.GetFull(), basic.location);
}
do_print = (++print_counter % output_skip ==0) && verbose;
};
contest_manager.SolveExhaustive();
if (verbose) {
PrintDistanceCounts();
}
return compare_scores(official_score,
contest_manager.GetStats().GetResult(0));
}
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(const Contests olc_type,
const ContestResult &official_score)
{
std::ofstream f("results/res-sample.txt");
GlidePolar glide_polar(fixed_two);
AircraftState state_last;
FileLineReaderA *reader = new FileLineReaderA(replay_file.c_str());
if (reader->error()) {
delete reader;
return false;
}
ReplayLoggerSim sim(reader);
ComputerSettings settings_computer;
settings_computer.SetDefaults();
settings_computer.task.enable_olc = true;
load_scores(settings_computer.task.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;
}
}
bool do_print = verbose;
unsigned print_counter=0;
MoreData basic;
basic.Reset();
while (sim.Update(basic, fixed_one) && !sim.started) {
}
state_last = sim.state;
fixed time_last = sim.state.time;
FlyingComputer flying_computer;
flying_computer.Reset();
FlyingState flying_state;
flying_state.Reset();
TraceComputer trace_computer;
ContestManager contest_manager(olc_type,
trace_computer.GetFull(),
trace_computer.GetSprint());
contest_manager.SetHandicap(settings_computer.task.contest_handicap);
DerivedInfo calculated;
while (sim.Update(basic, fixed_one)) {
if (sim.state.time>time_last) {
n_samples++;
flying_computer.Compute(glide_polar.GetVTakeoff(),
sim.state, flying_state);
calculated.flight.flying = flying_state.flying;
trace_computer.Update(settings_computer, basic, calculated);
contest_manager.UpdateIdle();
state_last = sim.state;
if (verbose>1) {
sim.print(f);
f.flush();
}
if (do_print) {
PrintHelper::trace_print(trace_computer.GetFull(), sim.state.location);
}
do_print = (++print_counter % output_skip ==0) && verbose;
}
time_last = sim.state.time;
};
contest_manager.SolveExhaustive();
if (verbose) {
PrintDistanceCounts();
}
return compare_scores(official_score,
contest_manager.GetStats().GetResult(0));
}
