test/src/TaskPrinting.cpp

   1 /* Copyright_License {
   2
   3   XCSoar Glide Computer - http://www.xcsoar.org/
   4   Copyright (C) 2000-2013 The XCSoar Project
   5   A detailed list of copyright holders can be found in the file "AUTHORS".
   6
   7   This program is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU General Public License
   9   as published by the Free Software Foundation; either version 2
  10   of the License, or (at your option) any later version.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20 }
  21 */
  22
  23 #include "Printing.hpp"
  24 #include "Engine/Task/TaskManager.hpp"
  25 #include "Task/Points/TaskPoint.hpp"
  26 #include "Task/Points/SampledTaskPoint.hpp"
  27 #include "Engine/Task/Ordered/OrderedTask.hpp"
  28 #include "Engine/Task/Ordered/Points/OrderedTaskPoint.hpp"
  29 #include "Engine/Task/Ordered/Points/AATPoint.hpp"
  30 #include "Engine/Task/Ordered/AATIsolineSegment.hpp"
  31 #include "Engine/Task/Unordered/GotoTask.hpp"
  32 #include "Engine/Task/Unordered/AbortTask.hpp"
  33 #include "Engine/Task/Stats/CommonStats.hpp"
  34 #include "Engine/Task/ObservationZones/Boundary.hpp"
  35 #include "Engine/GlideSolvers/GlideResult.hpp"
  36 #include "Geo/Math.hpp"
  37 #include "OS/FileUtil.hpp"
  38
  39 #include <fstream>
  40
  41 static std::ostream &
  42 operator<<(std::ostream &f, const GlideResult &gl)
  43 {
  44   if (gl.validity != GlideResult::Validity::OK) {
  45     f << "#     Solution NOT OK\n";
  46   }
  47   f << "#    Altitude Difference " << gl.altitude_difference << " (m)\n";
  48   f << "#    Distance            " << gl.vector.distance << " (m)\n";
  49   f << "#    TrackBearing        " << gl.vector.bearing << " (deg)\n";
  50   f << "#    CruiseTrackBearing  " <<  gl.cruise_track_bearing << " (deg)\n";
  51   f << "#    VOpt                " <<  gl.v_opt << " (m/s)\n";
  52   f << "#    HeightClimb         " <<  gl.height_climb << " (m)\n";
  53   f << "#    HeightGlide         " <<  gl.height_glide << " (m)\n";
  54   f << "#    TimeElapsed         " <<  gl.time_elapsed << " (s)\n";
  55   f << "#    TimeVirtual         " <<  gl.time_virtual << " (s)\n";
  56   if (positive(gl.time_elapsed)) {
  57     f << "#    Vave remaining      " <<  gl.vector.distance/gl.time_elapsed << " (m/s)\n";
  58   }
  59   f << "#    EffectiveWindSpeed  " <<  gl.effective_wind_speed << " (m/s)\n";
  60   f << "#    EffectiveWindAngle  " <<  gl.effective_wind_angle << " (deg)\n";
  61   if (gl.IsFinalGlide()) {
  62     f << "#    On final glide\n";
  63   }
  64   return f;
  65 }
  66
  67 static std::ostream &
  68 operator<<(std::ostream &f, const DistanceStat &ds)
  69 {
  70   f << "#    Distance " << ds.GetDistance() << " (m)\n";
  71   f << "#    Speed " << ds.GetSpeed() << " (m/s)\n";
  72   f << "#    Speed incremental " << ds.GetSpeedIncremental() << " (m/s)\n";
  73   return f;
  74 }
  75
  76 static std::ostream &
  77 operator<<(std::ostream &f, const ElementStat &es)
  78 {
  79   f << "#  Time started " << es.time_started << " (s)\n";
  80   f << "#  Time elapsed " << es.time_elapsed << " (s)\n";
  81   f << "#  Time remaining " << es.time_remaining << " (s)\n";
  82   f << "#  Time planned " << es.time_planned << " (s)\n";
  83   f << "#  Gradient " << es.gradient << "\n";
  84   f << "#  Remaining: \n";
  85   f << es.remaining;
  86   f << es.solution_remaining;
  87   f << "#  Remaining effective: \n";
  88   f << es.remaining_effective;
  89   f << "#  Remaining mc0: \n";
  90   f << es.solution_mc0;
  91   f << "#  Planned: \n";
  92   f << es.planned;
  93   f << es.solution_planned;
  94   f << "#  Travelled: \n";
  95   f << es.travelled;
  96   f << es.solution_travelled;
  97   f << "#  Vario: ";
  98   f << es.vario.get_value();
  99   f << "\n";
 100   return f;
 101 }
 102
 103 #include "Task/Stats/TaskStats.hpp"
 104
 105 static std::ostream &
 106 operator<<(std::ostream &f, const TaskStats &ts)
 107 {
 108   f << "#### Task Stats\n";
 109   f << "# dist nominal " << ts.distance_nominal << " (m)\n";
 110   f << "# min dist after achieving max " << ts.distance_min << " (m)\n";
 111   f << "# max dist after achieving max " << ts.distance_max << " (m)\n";
 112   f << "# dist scored " << ts.distance_scored << " (m)\n";
 113   f << "# mc best " << ts.mc_best << " (m/s)\n";
 114   f << "# cruise efficiency " << ts.cruise_efficiency << "\n";
 115   f << "# glide required " << ts.glide_required << "\n";
 116   f << "#\n";
 117   f << "# Total -- \n";
 118   f << ts.total;
 119   f << "# Leg -- \n";
 120   f << ts.current_leg;
 121   return f;
 122 }
 123
 124 void
 125 PrintHelper::aatpoint_print(std::ostream& f,
 126                             const AATPoint& tp,
 127                             const AircraftState& state,
 128                             const TaskProjection &projection,
 129                             const int item)
 130 {
 131   switch(item) {
 132   case 0:
 133     orderedtaskpoint_print(f, tp, state, item);
 134     f << "#   Target " << tp.GetTargetLocation().longitude << ","
 135       << tp.GetTargetLocation().latitude << "\n";
 136     break;
 137
 138   case 1:
 139
 140     if (tp.valid() && (tp.GetActiveState() != OrderedTaskPoint::BEFORE_ACTIVE)) {
 141       assert(tp.GetPrevious());
 142       assert(tp.GetNext());
 143       // note in general this will only change if
 144       // prev max or target changes
 145
 146       AATIsolineSegment seg(tp, projection);
 147       fixed tdist = tp.GetPrevious()->GetLocationRemaining().Distance(
 148         tp.GetLocationMin());
 149       fixed rdist = tp.GetPrevious()->GetLocationRemaining().Distance(
 150         tp.GetTargetLocation());
 151
 152       bool filter_backtrack = true;
 153       if (seg.IsValid()) {
 154         for (double t = 0.0; t<=1.0; t+= 1.0/20) {
 155           GeoPoint ga = seg.Parametric(fixed(t));
 156           fixed dthis = tp.GetPrevious()->GetLocationRemaining().Distance(ga);
 157           if (!filter_backtrack
 158               || (dthis>=tdist)
 159               || (dthis>=rdist)) {
 160             /// @todo unless double dist is better than current
 161             f << ga.longitude << " " << ga.latitude << "\n";
 162           }
 163         }
 164       } else {
 165         GeoPoint ga = seg.Parametric(fixed(0));
 166         f << ga.longitude << " " << ga.latitude << "\n";
 167       }
 168       f << "\n";
 169
 170     }
 171     break;
 172   }
 173 }
 174
 175
 176 void
 177 PrintHelper::orderedtaskpoint_print(std::ostream& f,
 178                                     const OrderedTaskPoint& tp,
 179                                     const AircraftState& state,
 180                                     const int item)
 181 {
 182   if (item==0) {
 183     taskpoint_print(f,tp,state);
 184     orderedtaskpoint_print_boundary(f,tp,state);
 185     f << "# Entered " << tp.GetEnteredState().time << "\n";
 186     f << "# Bearing travelled " << tp.GetVectorTravelled().bearing << "\n";
 187     f << "# Distance travelled " << tp.GetVectorTravelled().distance << "\n";
 188     f << "# Bearing remaining " << tp.GetVectorRemaining(state.location).bearing << "\n";
 189     f << "# Distance remaining " << tp.GetVectorRemaining(state.location).distance << "\n";
 190     f << "# Bearing planned " << tp.GetVectorPlanned().bearing << "\n";
 191     f << "# Distance planned " << tp.GetVectorPlanned().distance << "\n";
 192   }
 193 }
 194
 195
 196 void
 197 PrintHelper::orderedtaskpoint_print_boundary(std::ostream& f,
 198                                              const OrderedTaskPoint& tp,
 199                                              const AircraftState &state)
 200 {
 201   f << "#   Boundary points\n";
 202   for (const auto &i : tp.GetBoundary())
 203     f << "     " << i.longitude << " " << i.latitude << "\n";
 204   f << "\n";
 205 }
 206
 207 void
 208 PrintHelper::sampledtaskpoint_print_samples(std::ostream& f,
 209                                             const ScoredTaskPoint &tp,
 210                                             const AircraftState &state)
 211 {
 212   const unsigned n= tp.GetSearchPoints().size();
 213   f << "#   Search points\n";
 214   if (tp.HasEntered()) {
 215     for (unsigned i=0; i<n; i++) {
 216       const GeoPoint loc = tp.GetSearchPoints()[i].GetLocation();
 217       f << "     " << loc.longitude << " " << loc.latitude << "\n";
 218     }
 219   }
 220   f << "\n";
 221 }
 222
 223
 224 void
 225 PrintHelper::taskpoint_print(std::ostream& f, const TaskPoint& tp,
 226                              const AircraftState &state)
 227 {
 228   f << "# Task point \n";
 229   f << "#   Location " << tp.GetLocation().longitude << "," <<
 230     tp.GetLocation().latitude << "\n";
 231 }
 232
 233
 234 void
 235 PrintHelper::abstracttask_print(const AbstractTask &task,
 236                                 const AircraftState &state)
 237 {
 238   Directory::Create(_T("output/results"));
 239   std::ofstream fs("output/results/res-stats-all.txt");
 240
 241   const auto &stats = task.GetStats();
 242
 243   if (!stats.task_valid)
 244     return;
 245
 246   fs << stats;
 247
 248   static std::ofstream f6("output/results/res-stats.txt");
 249   static bool first = true;
 250
 251   if (first) {
 252     first = false;
 253     f6 << "# Time atp mc_best d_tot_rem_eff d_tot_rem ceff v_tot_rem v_tot_rem_inc v_tot_eff v_tot_eff_inc task_vario effective_mc v_pirker alt_diff\n";
 254   }
 255
 256   f6 << " " << task.GetActiveTaskPointIndex()
 257      << " " << stats.mc_best
 258      << " " << stats.total.remaining_effective.GetDistance()
 259      << " " << stats.total.remaining.GetDistance()
 260      << " " << stats.cruise_efficiency
 261      << " " << stats.total.remaining.GetSpeed()
 262      << " " << stats.total.remaining.GetSpeedIncremental()
 263      << " " << stats.total.remaining_effective.GetSpeed()
 264      << " " << stats.total.remaining_effective.GetSpeedIncremental()
 265      << " " << stats.total.vario.get_value()
 266      << " " << stats.effective_mc
 267      << " " << stats.get_pirker_speed()
 268      << " " << stats.total.solution_remaining.altitude_difference
 269      << "\n";
 270   f6.flush();
 271 }
 272
 273
 274 void
 275 PrintHelper::gototask_print(const GotoTask &task,
 276                             const AircraftState &state)
 277 {
 278   abstracttask_print(task, state);
 279
 280   const TaskWaypoint *tp = task.GetActiveTaskPoint();
 281   if (tp != nullptr) {
 282     std::ofstream f1("output/results/res-goto.txt");
 283     taskpoint_print(f1, *tp, state);
 284   }
 285 }
 286
 287 void
 288 PrintHelper::orderedtask_print(const OrderedTask &task,
 289                                const AircraftState &state)
 290 {
 291   abstracttask_print(task, state);
 292   if (!task.CheckTask())
 293     return;
 294
 295   std::ofstream fi("output/results/res-isolines.txt");
 296   for (unsigned i = 0; i < task.TaskSize(); ++i) {
 297     const OrderedTaskPoint &tp = task.GetPoint(i);
 298     fi << "## point " << i << "\n";
 299     if (tp.GetType() == TaskPointType::AAT) {
 300       aatpoint_print(fi, (const AATPoint &)tp, state,
 301                      task.GetTaskProjection(), 1);
 302     } else {
 303       orderedtaskpoint_print(fi, tp, state, 1);
 304     }
 305     fi << "\n";
 306   }
 307
 308   std::ofstream f1("output/results/res-task.txt");
 309
 310   f1 << "#### Task points\n";
 311   for (unsigned i = 0; i < task.TaskSize(); ++i) {
 312     f1 << "## point " << i << " ###################\n";
 313     const OrderedTaskPoint &tp = task.GetPoint(i);
 314     if (tp.GetType() == TaskPointType::AAT) {
 315       aatpoint_print(f1, (const AATPoint &)tp, state,
 316                      task.GetTaskProjection(), 0);
 317     } else {
 318       orderedtaskpoint_print(f1, tp, state, 0);
 319     }
 320     f1 << "\n";
 321   }
 322
 323   std::ofstream f5("output/results/res-ssample.txt");
 324   f5 << "#### Task sampled points\n";
 325   for (unsigned i =0 ; i < task.TaskSize(); ++i) {
 326     const OrderedTaskPoint &tp = task.GetPoint(i);
 327     f5 << "## point " << i << "\n";
 328     sampledtaskpoint_print_samples(f5, tp, state);
 329     f5 << "\n";
 330   }
 331
 332   std::ofstream f2("output/results/res-max.txt");
 333   f2 << "#### Max task\n";
 334   for (unsigned i = 0; i < task.TaskSize(); ++i) {
 335     const OrderedTaskPoint &tp = task.GetPoint(i);
 336     f2 << tp.GetLocationMax().longitude << " "
 337        << tp.GetLocationMax().latitude << "\n";
 338   }
 339
 340   std::ofstream f3("output/results/res-min.txt");
 341   f3 << "#### Min task\n";
 342   for (unsigned i = 0; i < task.TaskSize(); ++i) {
 343     const OrderedTaskPoint &tp = task.GetPoint(i);
 344     f3 << tp.GetLocationMin().longitude << " "
 345        << tp.GetLocationMin().latitude << "\n";
 346   }
 347
 348   std::ofstream f4("output/results/res-rem.txt");
 349   f4 << "#### Remaining task\n";
 350   for (unsigned i = 0; i < task.TaskSize(); ++i) {
 351     const OrderedTaskPoint &tp = task.GetPoint(i);
 352     f4 << tp.GetLocationRemaining().longitude << " "
 353        << tp.GetLocationRemaining().latitude << "\n";
 354   }
 355 }
 356
 357
 358 void
 359 PrintHelper::aborttask_print(const AbortTask &task, const AircraftState &state)
 360 {
 361   abstracttask_print(task, state);
 362
 363   std::ofstream f1("output/results/res-abort-task.txt");
 364   f1 << "#### Task points\n";
 365   for (unsigned i = 0; i < task.TaskSize(); ++i) {
 366     GeoPoint l = task.GetAlternate(i).GetLocation();
 367     f1 << "## point " << i << " ###################\n";
 368     if (i == task.GetActiveTaskPointIndex()) {
 369       f1 << state.location.longitude << " " << state.location.latitude << "\n";
 370     }
 371     f1 << l.longitude << " " << l.latitude << "\n";
 372     f1 << "\n";
 373   }
 374 }
 375
 376
 377 void
 378 PrintHelper::taskmanager_print(const TaskManager &task,
 379                                const AircraftState &state)
 380 {
 381   switch (task.GetMode()) {
 382   case TaskType::NONE:
 383     break;
 384
 385   case TaskType::ABORT:
 386     aborttask_print(*(const AbortTask *)task.GetActiveTask(), state);
 387     break;
 388
 389   case TaskType::GOTO:
 390     gototask_print(*(const GotoTask *)task.GetActiveTask(), state);
 391     break;
 392
 393   case TaskType::ORDERED:
 394     orderedtask_print(task.GetOrderedTask(), state);
 395     break;
 396   }
 397 }
 398
 399 /*
 400 std::ostream& operator<< (std::ostream& o,
 401                           const TaskProjection& tp)
 402 {
 403   o << "# Task projection\n";
 404   o << "# deg (" << tp.location_min.Longitude << ","
 405     << tp.location_min.Latitude << "),("
 406     << tp.location_max.Longitude << "," << tp.location_max.Latitude << ")\n";
 407
 408   FlatGeoPoint pll, pur;
 409   pll = tp.project(tp.location_min);
 410   pur = tp.project(tp.location_max);
 411
 412   o << "# flat (" << pll.Longitude << "," << pll.Latitude << "),("
 413     << pur.Longitude << "," << pur.Latitude << "\n";
 414   return o;
 415 }
 416 */