Changeset b1ccd2f in subsurface


Ignore:
Timestamp:
May 26, 2017, 3:44:36 PM (6 months ago)
Author:
Dirk Hohndel <dirk@…>
Branches:
master
Children:
57ee5a5
Parents:
6bfb1f5
git-author:
Robert C. Helling <helling@…> (05/25/17 03:57:06)
git-committer:
Dirk Hohndel <dirk@…> (05/26/17 15:44:36)
Message:

Move planner notes to separate file

Signed-off-by: Robert C. Helling <helling@…>

Location:
core
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • core/CMakeLists.txt

    r78dc3a3 rb1ccd2f  
    4646        parse-xml.c
    4747        planner.c
     48        plannernotes.c
    4849        profile.c
    4950        gaspressures.c
  • core/planner.c

    r6399eaf rb1ccd2f  
    3636
    3737double plangflow, plangfhigh;
    38 bool plan_verbatim, plan_display_runtime, plan_display_duration, plan_display_transitions;
    3938
    4039extern double regressiona();
     
    6968}
    7069#endif
    71 
    72 /* this is in qthelper.cpp, so including the .h file is a pain */
    73 extern const char *get_current_date();
    7470
    7571bool diveplan_empty(struct diveplan *diveplan)
     
    524520#endif
    525521        return stoplevels;
    526 }
    527 
    528 int diveplan_duration(struct diveplan *diveplan)
    529 {
    530         struct divedatapoint *dp = diveplan->dp;
    531         int duration = 0;
    532         while(dp) {
    533                 if (dp->time > duration)
    534                         duration = dp->time;
    535                 dp = dp->next;
    536         }
    537         return duration / 60;
    538 }
    539 
    540 static void add_plan_to_notes(struct diveplan *diveplan, struct dive *dive, bool show_disclaimer, int error)
    541 {
    542         const unsigned int sz_buffer = 2000000;
    543         const unsigned int sz_temp = 100000;
    544         char *buffer = (char *)malloc(sz_buffer);
    545         char *temp = (char *)malloc(sz_temp);
    546         const char *deco, *segmentsymbol;
    547         static char buf[1000];
    548         int len, lastdepth = 0, lasttime = 0, lastsetpoint = -1, newdepth = 0, lastprintdepth = 0, lastprintsetpoint = -1;
    549         struct gasmix lastprintgasmix = {{ -1 }, { -1 }};
    550         struct divedatapoint *dp = diveplan->dp;
    551         bool gaschange_after = !plan_verbatim;
    552         bool gaschange_before;
    553         bool lastentered = true;
    554         struct divedatapoint *nextdp = NULL;
    555         struct divedatapoint *lastbottomdp = NULL;
    556 
    557         plan_verbatim = prefs.verbatim_plan;
    558         plan_display_runtime = prefs.display_runtime;
    559         plan_display_duration = prefs.display_duration;
    560         plan_display_transitions = prefs.display_transitions;
    561 
    562         if (decoMode() == VPMB) {
    563                 deco = translate("gettextFromC", "VPM-B");
    564         } else {
    565                 deco = translate("gettextFromC", "BUHLMANN");
    566         }
    567 
    568         snprintf(buf, sizeof(buf), translate("gettextFromC", "DISCLAIMER / WARNING: THIS IS A NEW IMPLEMENTATION OF THE %s "
    569                                 "ALGORITHM AND A DIVE PLANNER IMPLEMENTATION BASED ON THAT WHICH HAS "
    570                                 "RECEIVED ONLY A LIMITED AMOUNT OF TESTING. WE STRONGLY RECOMMEND NOT TO "
    571                                 "PLAN DIVES SIMPLY BASED ON THE RESULTS GIVEN HERE."), deco);
    572         disclaimer = buf;
    573 
    574         if (!dp) {
    575                 free((void *)buffer);
    576                 free((void *)temp);
    577                 return;
    578         }
    579 
    580         if (error) {
    581                 snprintf(temp, sz_temp, "%s",
    582                          translate("gettextFromC", "Decompression calculation aborted due to excessive time"));
    583                 snprintf(buffer, sz_buffer, "<span style='color: red;'>%s </span> %s<br>",
    584                                 translate("gettextFromC", "Warning:"), temp);
    585                 dive->notes = strdup(buffer);
    586 
    587                 free((void *)buffer);
    588                 free((void *)temp);
    589                 return;
    590         }
    591 
    592         len = show_disclaimer ? snprintf(buffer, sz_buffer, "<div><b>%s</b><br></div>", disclaimer) : 0;
    593 
    594         if (diveplan->surface_interval > 60) {
    595                 len += snprintf(buffer + len, sz_buffer - len, "<div><b>%s (%s) %s %d:%02d) %s %s<br>",
    596                                 translate("gettextFromC", "Subsurface"),
    597                                 subsurface_canonical_version(),
    598                                 translate("gettextFromC", "dive plan</b> (surface interval "),
    599                                 FRACTION(diveplan->surface_interval / 60, 60),
    600                                 translate("gettextFromC", "created on"),
    601                                 get_current_date());
    602         } else {
    603                 len += snprintf(buffer + len, sz_buffer - len, "<div><b>%s (%s) %s %s</b><br>",
    604                                 translate("gettextFromC", "Subsurface"),
    605                                 subsurface_canonical_version(),
    606                                 translate("gettextFromC", "dive plan</b> created on"),
    607                                 get_current_date());
    608         }
    609 
    610         len += snprintf(buffer + len, sz_buffer - len, translate("gettextFromC", "Runtime: %dmin<br></div>"),
    611                         diveplan_duration(diveplan));
    612 
    613         if (!plan_verbatim) {
    614                 len += snprintf(buffer + len, sz_buffer - len, "<table><thead><tr><th></th><th>%s</th>",
    615                                 translate("gettextFromC", "depth"));
    616                 if (plan_display_duration)
    617                         len += snprintf(buffer + len, sz_buffer - len, "<th style='padding-left: 10px;'>%s</th>",
    618                                         translate("gettextFromC", "duration"));
    619                 if (plan_display_runtime)
    620                         len += snprintf(buffer + len, sz_buffer - len, "<th style='padding-left: 10px;'>%s</th>",
    621                                         translate("gettextFromC", "runtime"));
    622                 len += snprintf(buffer + len, sz_buffer - len,
    623                                 "<th style='padding-left: 10px; float: left;'>%s</th></tr></thead><tbody style='float: left;'>",
    624                                 translate("gettextFromC", "gas"));
    625         }
    626         do {
    627                 struct gasmix gasmix, newgasmix = {};
    628                 const char *depth_unit;
    629                 double depthvalue;
    630                 int decimals;
    631                 bool isascent = (dp->depth.mm < lastdepth);
    632 
    633                 nextdp = dp->next;
    634                 if (dp->time == 0)
    635                         continue;
    636                 gasmix = dive->cylinder[dp->cylinderid].gasmix;
    637                 depthvalue = get_depth_units(dp->depth.mm, &decimals, &depth_unit);
    638                 /* analyze the dive points ahead */
    639                 while (nextdp && nextdp->time == 0)
    640                         nextdp = nextdp->next;
    641                 if (nextdp)
    642                         newgasmix = dive->cylinder[nextdp->cylinderid].gasmix;
    643                 gaschange_after = (nextdp && (gasmix_distance(&gasmix, &newgasmix) || dp->setpoint != nextdp->setpoint));
    644                 gaschange_before =  (gasmix_distance(&lastprintgasmix, &gasmix) || lastprintsetpoint != dp->setpoint);
    645                 /* do we want to skip this leg as it is devoid of anything useful? */
    646                 if (!dp->entered &&
    647                     nextdp &&
    648                     dp->depth.mm != lastdepth &&
    649                     nextdp->depth.mm != dp->depth.mm &&
    650                     !gaschange_before &&
    651                     !gaschange_after)
    652                         continue;
    653                 if (dp->time - lasttime < 10 && !(gaschange_after && dp->next && dp->depth.mm != dp->next->depth.mm))
    654                         continue;
    655 
    656                 /* Store pointer to last entered datapoint for minimum gas calculation */
    657                 /* Do this only if depth is larger than last/2nd last deco stop at ~6m */
    658                 int secondlastdecostop = 0;
    659                 if (prefs.units.length == METERS ) {
    660                         secondlastdecostop = decostoplevels_metric[2];
    661                 } else {
    662                         secondlastdecostop = decostoplevels_imperial[2];
    663                 }
    664                 if (dp->entered && !nextdp->entered && dp->depth.mm > secondlastdecostop)
    665                         lastbottomdp = dp;
    666 
    667                 len = strlen(buffer);
    668                 if (plan_verbatim) {
    669                         /* When displaying a verbatim plan, we output a waypoint for every gas change.
    670                          * Therefore, we do not need to test for difficult cases that mean we need to
    671                          * print a segment just so we don't miss a gas change.  This makes the logic
    672                          * to determine whether or not to print a segment much simpler than  with the
    673                          * non-verbatim plan.
    674                          */
    675                         if (dp->depth.mm != lastprintdepth) {
    676                                 if (plan_display_transitions || dp->entered || !dp->next || (gaschange_after && dp->next && dp->depth.mm != nextdp->depth.mm)) {
    677                                         if (dp->setpoint)
    678                                                 snprintf(temp, sz_temp, translate("gettextFromC", "Transition to %.*f %s in %d:%02d min - runtime %d:%02u on %s (SP = %.1fbar)"),
    679                                                          decimals, depthvalue, depth_unit,
    680                                                          FRACTION(dp->time - lasttime, 60),
    681                                                          FRACTION(dp->time, 60),
    682                                                          gasname(&gasmix),
    683                                                          (double) dp->setpoint / 1000.0);
    684 
    685                                         else
    686                                                 snprintf(temp, sz_temp, translate("gettextFromC", "Transition to %.*f %s in %d:%02d min - runtime %d:%02u on %s"),
    687                                                          decimals, depthvalue, depth_unit,
    688                                                          FRACTION(dp->time - lasttime, 60),
    689                                                          FRACTION(dp->time, 60),
    690                                                          gasname(&gasmix));
    691 
    692                                         len += snprintf(buffer + len, sz_buffer - len, "%s<br>", temp);
    693                                 }
    694                                 newdepth = dp->depth.mm;
    695                                 lasttime = dp->time;
    696                         } else {
    697                                 if ((nextdp && dp->depth.mm != nextdp->depth.mm) || gaschange_after) {
    698                                         if (dp->setpoint)
    699                                                 snprintf(temp, sz_temp, translate("gettextFromC", "Stay at %.*f %s for %d:%02d min - runtime %d:%02u on %s (SP = %.1fbar)"),
    700                                                                 decimals, depthvalue, depth_unit,
    701                                                                 FRACTION(dp->time - lasttime, 60),
    702                                                                 FRACTION(dp->time, 60),
    703                                                                 gasname(&gasmix),
    704                                                                 (double) dp->setpoint / 1000.0);
    705                                         else
    706                                                 snprintf(temp, sz_temp, translate("gettextFromC", "Stay at %.*f %s for %d:%02d min - runtime %d:%02u on %s"),
    707                                                                 decimals, depthvalue, depth_unit,
    708                                                                 FRACTION(dp->time - lasttime, 60),
    709                                                                 FRACTION(dp->time, 60),
    710                                                                 gasname(&gasmix));
    711 
    712                                                 len += snprintf(buffer + len, sz_buffer - len, "%s<br>", temp);
    713                                         newdepth = dp->depth.mm;
    714                                         lasttime = dp->time;
    715                                 }
    716                         }
    717                 } else {
    718                         /* When not displaying the verbatim dive plan, we typically ignore ascents between deco stops,
    719                          * unless the display transitions option has been selected.  We output a segment if any of the
    720                          * following conditions are met.
    721                          * 1) Display transitions is selected
    722                          * 2) The segment was manually entered
    723                          * 3) It is the last segment of the dive
    724                          * 4) The segment is not an ascent, there was a gas change at the start of the segment and the next segment
    725                          *    is a change in depth (typical deco stop)
    726                          * 5) There is a gas change at the end of the segment and the last segment was entered (first calculated
    727                          *    segment if it ends in a gas change)
    728                          * 6) There is a gaschange after but no ascent.  This should only occur when backgas breaks option is selected
    729                          * 7) It is an ascent ending with a gas change, but is not followed by a stop.   As case 5 already matches
    730                          *    the first calculated ascent if it ends with a gas change, this should only occur if a travel gas is
    731                          *    used for a calculated ascent, there is a subsequent gas change before the first deco stop, and zero
    732                          *    time has been allowed for a gas switch.
    733                          */
    734                         if (plan_display_transitions || dp->entered || !dp->next ||
    735                             (nextdp && dp->depth.mm != nextdp->depth.mm) ||
    736                             (!isascent && gaschange_before && nextdp && dp->depth.mm != nextdp->depth.mm) ||
    737                             (gaschange_after && lastentered) || (gaschange_after && !isascent) ||
    738                             (isascent && gaschange_after && nextdp && dp->depth.mm != nextdp->depth.mm )) {
    739                                 // Print a symbol to indicate whether segment is an ascent, descent, constant depth (user entered) or deco stop
    740                                 if (isascent)
    741                                         segmentsymbol = "&#10138;"; // up-right arrow for ascent
    742                                 else if (dp->depth.mm > lastdepth)
    743                                         segmentsymbol = "&#10136;"; // down-right arrow for descent
    744                                 else if (dp->entered)
    745                                         segmentsymbol = "&#10137;"; // right arrow for entered entered segment at constant depth
    746                                 else
    747                                         segmentsymbol = "-";        // minus sign (a.k.a. horizontal line) for deco stop
    748 
    749                                 len += snprintf(buffer + len, sz_buffer - len, "<tr><td style='padding-left: 10px; float: right;'>%s</td>", segmentsymbol);
    750 
    751                                 snprintf(temp, sz_temp, translate("gettextFromC", "%3.0f%s"), depthvalue, depth_unit);
    752                                 len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; float: right;'>%s</td>", temp);
    753                                 if (plan_display_duration) {
    754                                         snprintf(temp, sz_temp, translate("gettextFromC", "%3dmin"), (dp->time - lasttime + 30) / 60);
    755                                         len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; float: right;'>%s</td>", temp);
    756                                 }
    757                                 if (plan_display_runtime) {
    758                                         snprintf(temp, sz_temp, translate("gettextFromC", "%3dmin"), (dp->time + 30) / 60);
    759                                         len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; float: right;'>%s</td>", temp);
    760                                 }
    761 
    762                                 /* Normally a gas change is displayed on the stopping segment, so only display a gas change at the end of
    763                                  * an ascent segment if it is not followed by a stop
    764                                  */
    765                                 if ((isascent || dp->entered) && gaschange_after && dp->next && nextdp && (dp->depth.mm != nextdp->depth.mm || nextdp->entered)) {
    766                                         if (dp->setpoint) {
    767                                                 snprintf(temp, sz_temp, translate("gettextFromC", "(SP = %.1fbar)"), (double) nextdp->setpoint / 1000.0);
    768                                                 len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; color: red; float: left;'><b>%s %s</b></td>", gasname(&newgasmix),
    769                                                                         temp);
    770                                         } else {
    771                                                         len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; color: red; float: left;'><b>%s</b></td>", gasname(&newgasmix));
    772                                         }
    773                                         lastprintsetpoint = nextdp->setpoint;
    774                                         lastprintgasmix = newgasmix;
    775                                         gaschange_after = false;
    776                                 } else if (gaschange_before) {
    777                                 // If a new gas has been used for this segment, now is the time to show it
    778                                         if (dp->setpoint) {
    779                                                 snprintf(temp, sz_temp, translate("gettextFromC", "(SP = %.1fbar)"), (double) dp->setpoint / 1000.0);
    780                                                 len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; color: red; float: left;'><b>%s %s</b></td>", gasname(&gasmix),
    781                                                                         temp);
    782                                         } else {
    783                                                         len += snprintf(buffer + len, sz_buffer - len, "<td style='padding-left: 10px; color: red; float: left;'><b>%s</b></td>", gasname(&gasmix));
    784                                         }
    785                                         // Set variables so subsequent iterations can test against the last gas printed
    786                                         lastprintsetpoint = dp->setpoint;
    787                                         lastprintgasmix = gasmix;
    788                                         gaschange_after = false;
    789                                 } else {
    790                                         len += snprintf(buffer + len, sz_buffer - len, "<td>&nbsp;</td>");
    791                                 }
    792                                 len += snprintf(buffer + len, sz_buffer - len, "</tr>");
    793                                 newdepth = dp->depth.mm;
    794                                 lasttime = dp->time;
    795                         }
    796                 }
    797                 if (gaschange_after) {
    798                         // gas switch at this waypoint
    799                         if (plan_verbatim) {
    800                                 if (lastsetpoint >= 0) {
    801                                         if (nextdp && nextdp->setpoint)
    802                                                 snprintf(temp, sz_temp, translate("gettextFromC", "Switch gas to %s (SP = %.1fbar)"), gasname(&newgasmix), (double) nextdp->setpoint / 1000.0);
    803                                         else
    804                                                 snprintf(temp, sz_temp, translate("gettextFromC", "Switch gas to %s"), gasname(&newgasmix));
    805 
    806                                         len += snprintf(buffer + len, sz_buffer - len, "%s<br>", temp);
    807                                 }
    808                                 gaschange_after = false;
    809                         gasmix = newgasmix;
    810                         }
    811                 }
    812                 lastprintdepth = newdepth;
    813                 lastdepth = dp->depth.mm;
    814                 lastsetpoint = dp->setpoint;
    815                 lastentered = dp->entered;
    816         } while ((dp = nextdp) != NULL);
    817         if (!plan_verbatim)
    818                 len += snprintf(buffer + len, sz_buffer - len, "</tbody></table><br>");
    819 
    820         /* Print the CNS and OTU next.*/
    821         dive->cns = 0;
    822         dive->maxcns = 0;
    823         update_cylinder_related_info(dive);
    824         snprintf(temp, sz_temp, "%s", translate("gettextFromC", "CNS"));
    825         len += snprintf(buffer + len, sz_buffer - len, "<div>%s: %i%%", temp, dive->cns);
    826         snprintf(temp, sz_temp, "%s", translate("gettextFromC", "OTU"));
    827         len += snprintf(buffer + len, sz_buffer - len, "<br>%s: %i<br></div>", temp, dive->otu);
    828 
    829         /* Print the settings for the diveplan next. */
    830         if (decoMode() == BUEHLMANN){
    831                 snprintf(temp, sz_temp, translate("gettextFromC", "Deco model: Bühlmann ZHL-16C with GFLow = %d%% and GFHigh = %d%%"),
    832                         diveplan->gflow, diveplan->gfhigh);
    833         } else if (decoMode() == VPMB){
    834                 int temp_len;
    835                 if (diveplan->vpmb_conservatism == 0)
    836                         temp_len = snprintf(temp, sz_temp, "%s", translate("gettextFromC", "Deco model: VPM-B at nominal conservatism"));
    837                 else
    838                         temp_len = snprintf(temp, sz_temp, translate("gettextFromC", "Deco model: VPM-B at +%d conservatism"), diveplan->vpmb_conservatism);
    839                 if (diveplan->eff_gflow)
    840                         temp_len += snprintf(temp + temp_len, sz_temp - temp_len,  translate("gettextFromC", ", effective GF=%d/%d"), diveplan->eff_gflow
    841                                              , diveplan->eff_gfhigh);
    842 
    843         } else if (decoMode() == RECREATIONAL){
    844                 snprintf(temp, sz_temp, translate("gettextFromC", "Deco model: Recreational mode based on Bühlmann ZHL-16B with GFLow = %d%% and GFHigh = %d%%"),
    845                         diveplan->gflow, diveplan->gfhigh);
    846         }
    847         len += snprintf(buffer + len, sz_buffer - len, "<div>%s<br>",temp);
    848 
    849         const char *depth_unit;
    850         int altitude = (int) get_depth_units((int) (log(1013.0 / diveplan->surface_pressure) * 7800000), NULL, &depth_unit);
    851 
    852         len += snprintf(buffer + len, sz_buffer - len, translate("gettextFromC", "ATM pressure: %dmbar (%d%s)<br></div>"),
    853                         diveplan->surface_pressure,
    854                         altitude,
    855                         depth_unit);
    856 
    857         /* Get SAC values and units for printing it in gas consumption */
    858         double bottomsacvalue, decosacvalue;
    859         int sacdecimals;
    860         const char* sacunit;
    861 
    862         bottomsacvalue = get_volume_units(prefs.bottomsac, &sacdecimals, &sacunit);
    863         decosacvalue = get_volume_units(prefs.decosac, NULL, NULL);
    864 
    865         /* Reduce number of decimals from 1 to 0 for bar/min, keep 2 for cuft/min */
    866         if (sacdecimals==1) sacdecimals--;
    867 
    868         /* Print the gas consumption next.*/
    869         if (dive->dc.divemode == CCR)
    870                 snprintf(temp, sz_temp, "%s", translate("gettextFromC", "Gas consumption (CCR legs excluded):"));
    871         else
    872                 snprintf(temp, sz_temp, "%s %.*f|%.*f%s/min):", translate("gettextFromC", "Gas consumption (based on SAC"),
    873                         sacdecimals, bottomsacvalue, sacdecimals, decosacvalue, sacunit);
    874         len += snprintf(buffer + len, sz_buffer - len, "<div>%s<br>", temp);
    875 
    876         /* Print gas consumption: This loop covers all cylinders */
    877         for (int gasidx = 0; gasidx < MAX_CYLINDERS; gasidx++) {
    878                 double volume, pressure, deco_volume, deco_pressure, mingas_volume, mingas_pressure, mingas_depth;
    879                 const char *unit, *pressure_unit, *depth_unit;
    880                 char warning[1000] = "";
    881                 char mingas[1000] = "";
    882                 cylinder_t *cyl = &dive->cylinder[gasidx];
    883                 if (cylinder_none(cyl))
    884                         break;
    885 
    886                 volume = get_volume_units(cyl->gas_used.mliter, NULL, &unit);
    887                 deco_volume = get_volume_units(cyl->deco_gas_used.mliter, NULL, &unit);
    888                 if (cyl->type.size.mliter) {
    889                         int remaining_gas = lrint((double)cyl->end.mbar * cyl->type.size.mliter / 1000.0 / gas_compressibility_factor(&cyl->gasmix, cyl->end.mbar / 1000.0));
    890                         double deco_pressure_bar = isothermal_pressure(&cyl->gasmix, 1.0, remaining_gas + cyl->deco_gas_used.mliter, cyl->type.size.mliter)
    891                                         - cyl->end.mbar / 1000.0;
    892                         deco_pressure = get_pressure_units(lrint(1000.0 * deco_pressure_bar), &pressure_unit);
    893                         pressure = get_pressure_units(cyl->start.mbar - cyl->end.mbar, &pressure_unit);
    894                         /* Warn if the plan uses more gas than is available in a cylinder
    895                          * This only works if we have working pressure for the cylinder
    896                          * 10bar is a made up number - but it seemed silly to pretend you could breathe cylinder down to 0 */
    897                         if (cyl->end.mbar < 10000)
    898                                 snprintf(warning, sizeof(warning), "<br>&nbsp;&mdash; <span style='color: red;'>%s </span> %s",
    899                                         translate("gettextFromC", "Warning:"),
    900                                         translate("gettextFromC", "this is more gas than available in the specified cylinder!"));
    901                         else
    902                                 if ((float) cyl->end.mbar * cyl->type.size.mliter / 1000.0 / gas_compressibility_factor(&cyl->gasmix, cyl->end.mbar / 1000.0)
    903                                     < (float) cyl->deco_gas_used.mliter)
    904                                         snprintf(warning, sizeof(warning), "<br>&nbsp;&mdash; <span style='color: red;'>%s </span> %s",
    905                                                 translate("gettextFromC", "Warning:"),
    906                                                 translate("gettextFromC", "not enough reserve for gas sharing on ascent!"));
    907 
    908                         /* Do and print minimum gas calculation for last bottom gas, but only for OC mode, */
    909                         /* not for recreational mode and if no other warning was set before. */
    910                         else
    911                                 if (lastbottomdp && gasidx == lastbottomdp->cylinderid
    912                                         && dive->dc.divemode == OC && decoMode() != RECREATIONAL) {
    913                                         /* Calculate minimum gas volume. */
    914                                         volume_t mingasv;
    915                                         mingasv.mliter = lrint(prefs.sacfactor / 100.0 * prefs.problemsolvingtime * prefs.bottomsac
    916                                                 * depth_to_bar(lastbottomdp->depth.mm, dive)
    917                                                 + prefs.sacfactor / 100.0 * cyl->deco_gas_used.mliter);
    918                                         /* Calculate minimum gas pressure for cyclinder. */
    919                                         lastbottomdp->minimum_gas.mbar = lrint(isothermal_pressure(&cyl->gasmix, 1.0,
    920                                                 mingasv.mliter, cyl->type.size.mliter) * 1000);
    921                                         /* Translate all results into correct units */
    922                                         mingas_volume = get_volume_units(mingasv.mliter, NULL, &unit);
    923                                         mingas_pressure = get_pressure_units(lastbottomdp->minimum_gas.mbar, &pressure_unit);
    924                                         mingas_depth = get_depth_units(lastbottomdp->depth.mm, NULL, &depth_unit);
    925                                         /* Print it to results */
    926                                         if (cyl->start.mbar > lastbottomdp->minimum_gas.mbar) snprintf(mingas, sizeof(mingas),
    927                                                 translate("gettextFromC", "<br>&nbsp;&mdash; <span style='color: green;'>Minimum gas</span> (based on %.1fxSAC/+%dmin@%.0f%s): %.0f%s/%.0f%s"),
    928                                                 prefs.sacfactor / 100.0, prefs.problemsolvingtime,
    929                                                 mingas_depth, depth_unit,
    930                                                 mingas_volume, unit,
    931                                                 mingas_pressure, pressure_unit);
    932                                         else snprintf(warning, sizeof(warning), "<br>&nbsp;&mdash; <span style='color: red;'>%s </span> %s",
    933                                                 translate("gettextFromC", "Warning:"),
    934                                                 translate("gettextFromC", "required minimum gas for ascent already exceeding start pressure of cylinder!"));
    935                                 }
    936                         /* Print the gas consumption for every cylinder here to temp buffer. */
    937                         snprintf(temp, sz_temp, translate("gettextFromC", "%.0f%s/%.0f%s of <span style='color: red;'><b>%s</b></span> (%.0f%s/%.0f%s in planned ascent)"), volume, unit, pressure, pressure_unit, gasname(&cyl->gasmix), deco_volume, unit, deco_pressure, pressure_unit);
    938                        
    939                 } else {
    940                         snprintf(temp, sz_temp, translate("gettextFromC", "%.0f%s (%.0f%s during planned ascent) of <span style='color: red;'><b>%s</b></span>"),
    941                                 volume, unit, deco_volume, unit, gasname(&cyl->gasmix));
    942                 }
    943                 /* Gas consumption: Now finally print all strings to output */
    944                 len += snprintf(buffer + len, sz_buffer - len, "%s%s%s<br>", temp, warning, mingas);
    945         }
    946        
    947         /* Print warnings for pO2 */
    948         dp = diveplan->dp;
    949         bool o2warning_exist = false;
    950         if (dive->dc.divemode != CCR) {
    951                 while (dp) {
    952                         if (dp->time != 0) {
    953                                 struct gas_pressures pressures;
    954                                 struct gasmix *gasmix = &dive->cylinder[dp->cylinderid].gasmix;
    955                                 fill_pressures(&pressures, depth_to_atm(dp->depth.mm, dive), gasmix, 0.0, dive->dc.divemode);
    956 
    957                                 if (pressures.o2 > (dp->entered ? prefs.bottompo2 : prefs.decopo2) / 1000.0) {
    958                                         const char *depth_unit;
    959                                         int decimals;
    960                                         double depth_value = get_depth_units(dp->depth.mm, &decimals, &depth_unit);
    961                                         len = strlen(buffer);
    962                                         if (!o2warning_exist) len += snprintf(buffer + len, sz_buffer - len, "<br>");
    963                                         o2warning_exist = true;
    964                                         snprintf(temp, sz_temp,
    965                                                  translate("gettextFromC", "high pO₂ value %.2f at %d:%02u with gas %s at depth %.*f %s"),
    966                                                  pressures.o2, FRACTION(dp->time, 60), gasname(gasmix), decimals, depth_value, depth_unit);
    967                                         len += snprintf(buffer + len, sz_buffer - len, "<span style='color: red;'>%s </span> %s<br>",
    968                                                         translate("gettextFromC", "Warning:"), temp);
    969                                 } else if (pressures.o2 < 0.16) {
    970                                         const char *depth_unit;
    971                                         int decimals;
    972                                         double depth_value = get_depth_units(dp->depth.mm, &decimals, &depth_unit);
    973                                         len = strlen(buffer);
    974                                         if (!o2warning_exist) len += snprintf(buffer + len, sz_buffer - len, "<br>");
    975                                         o2warning_exist = true;
    976                                         snprintf(temp, sz_temp,
    977                                                  translate("gettextFromC", "low pO₂ value %.2f at %d:%02u with gas %s at depth %.*f %s"),
    978                                                  pressures.o2, FRACTION(dp->time, 60), gasname(gasmix), decimals, depth_value, depth_unit);
    979                                         len += snprintf(buffer + len, sz_buffer - len, "<span style='color: red;'>%s </span> %s<br>",
    980                                                         translate("gettextFromC", "Warning:"), temp);
    981 
    982                                 }
    983                         }
    984                         dp = dp->next;
    985                 }
    986         }
    987         snprintf(buffer + len, sz_buffer - len, "</div>");
    988         dive->notes = strdup(buffer);
    989 
    990         free((void *)buffer);
    991         free((void *)temp);
    992522}
    993523
  • core/planner.h

    r6399eaf rb1ccd2f  
    2222extern int get_gasidx(struct dive *dive, struct gasmix *mix);
    2323extern bool diveplan_empty(struct diveplan *diveplan);
     24extern void add_plan_to_notes(struct diveplan *diveplan, struct dive *dive, bool show_disclaimer, int error);
    2425
    2526extern void free_dps(struct diveplan *diveplan);
  • core/qthelperfromc.h

    r0dfa448 rb1ccd2f  
    2222enum deco_mode decoMode();
    2323int parse_seabear_header(const char *filename, char **params, int pnr);
     24extern const char *get_current_date();
     25
    2426
    2527#endif // QTHELPERFROMC_H
Note: See TracChangeset for help on using the changeset viewer.