mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2025-02-19 22:16:15 +00:00
Code Issues Projects Releases Packages Wiki Activity

VPMB profile: use deco_time rather bottom_time from planner

Browse source 
This makes the calculations in profile.c a little simpler, especially now we
adopt consistent final ascent rate to determine deco_time since d15779a27

Signed-off-by: Rick Walsh <rickmwalsh@gmail.com>
This commit is contained in:
Rick Walsh 2017-11-03 07:32:28 +11:00 • committed by Robert C. Helling
parent e365cac54e
commit fe474ac266
3 changed files with 35 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

2
core/dive.h
View file

@ -894,7 +894,7 @@ struct deco_state {
pressure_t max_bottom_ceiling_pressure; pressure_t max_bottom_ceiling_pressure;
int ci_pointing_to_guiding_tissue; int ci_pointing_to_guiding_tissue;
double gf_low_pressure_this_dive; double gf_low_pressure_this_dive;
int bottom_time; int deco_time;
}; };
extern void add_segment(double pressure, const struct gasmix *gasmix, int period_in_seconds, int setpoint, const struct dive *dive, int sac); extern void add_segment(double pressure, const struct gasmix *gasmix, int period_in_seconds, int setpoint, const struct dive *dive, int sac);

44
core/planner.c
View file

@ -652,7 +652,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
int bottom_gi; int bottom_gi;
int bottom_stopidx; int bottom_stopidx;
bool is_final_plan = true; bool is_final_plan = true;
int deco_time; int bottom_time;
int previous_deco_time; int previous_deco_time;
struct deco_state *bottom_cache = NULL; struct deco_state *bottom_cache = NULL;
struct sample *sample; struct sample *sample;
@ -713,7 +713,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
sample = &dive->dc.sample[dive->dc.samples - 1]; sample = &dive->dc.sample[dive->dc.samples - 1];
/* Keep time during the ascend */ /* Keep time during the ascend */
deco_state->bottom_time = clock = previous_point_time = dive->dc.sample[dive->dc.samples - 1].time.seconds; bottom_time = clock = previous_point_time = dive->dc.sample[dive->dc.samples - 1].time.seconds;
current_cylinder = get_cylinderid_at_time(dive, &dive->dc, sample->time); current_cylinder = get_cylinderid_at_time(dive, &dive->dc, sample->time);
gas = dive->cylinder[current_cylinder].gasmix; gas = dive->cylinder[current_cylinder].gasmix;
@ -721,7 +721,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
po2 = sample->setpoint.mbar; po2 = sample->setpoint.mbar;
depth = dive->dc.sample[dive->dc.samples - 1].depth.mm; depth = dive->dc.sample[dive->dc.samples - 1].depth.mm;
average_max_depth(diveplan, &avg_depth, &max_depth); average_max_depth(diveplan, &avg_depth, &max_depth);
last_ascend_rate = ascent_velocity(depth, avg_depth, deco_state->bottom_time); last_ascend_rate = ascent_velocity(depth, avg_depth, bottom_time);
/* if all we wanted was the dive just get us back to the surface */ /* if all we wanted was the dive just get us back to the surface */
if (!is_planner) { if (!is_planner) {
@ -765,7 +765,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
if (decoMode() == RECREATIONAL) { if (decoMode() == RECREATIONAL) {
bool safety_stop = prefs.safetystop && max_depth >= 10000; bool safety_stop = prefs.safetystop && max_depth >= 10000;
track_ascent_gas(depth, &dive->cylinder[current_cylinder], avg_depth, deco_state->bottom_time, safety_stop); track_ascent_gas(depth, &dive->cylinder[current_cylinder], avg_depth, bottom_time, safety_stop);
// How long can we stay at the current depth and still directly ascent to the surface? // How long can we stay at the current depth and still directly ascent to the surface?
do { do {
add_segment(depth_to_bar(depth, dive), add_segment(depth_to_bar(depth, dive),
@ -773,7 +773,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
timestep, po2, dive, prefs.bottomsac); timestep, po2, dive, prefs.bottomsac);
update_cylinder_pressure(dive, depth, depth, timestep, prefs.bottomsac, &dive->cylinder[current_cylinder], false); update_cylinder_pressure(dive, depth, depth, timestep, prefs.bottomsac, &dive->cylinder[current_cylinder], false);
clock += timestep; clock += timestep;
} while (trial_ascent(0, depth, 0, avg_depth, deco_state->bottom_time, &dive->cylinder[current_cylinder].gasmix, } while (trial_ascent(0, depth, 0, avg_depth, bottom_time, &dive->cylinder[current_cylinder].gasmix,
po2, diveplan->surface_pressure / 1000.0, dive) && po2, diveplan->surface_pressure / 1000.0, dive) &&
enough_gas(current_cylinder)); enough_gas(current_cylinder));
@ -787,11 +787,11 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
previous_point_time = clock; previous_point_time = clock;
do { do {
/* Ascend to surface */ /* Ascend to surface */
int deltad = ascent_velocity(depth, avg_depth, deco_state->bottom_time) * TIMESTEP; int deltad = ascent_velocity(depth, avg_depth, bottom_time) * TIMESTEP;
if (ascent_velocity(depth, avg_depth, deco_state->bottom_time) != last_ascend_rate) { if (ascent_velocity(depth, avg_depth, bottom_time) != last_ascend_rate) {
plan_add_segment(diveplan, clock - previous_point_time, depth, current_cylinder, po2, false); plan_add_segment(diveplan, clock - previous_point_time, depth, current_cylinder, po2, false);
previous_point_time = clock; previous_point_time = clock;
last_ascend_rate = ascent_velocity(depth, avg_depth, deco_state->bottom_time); last_ascend_rate = ascent_velocity(depth, avg_depth, bottom_time);
} }
if (depth - deltad < 0) if (depth - deltad < 0)
deltad = depth; deltad = depth;
@ -830,7 +830,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
// VPM-B or Buehlmann Deco // VPM-B or Buehlmann Deco
tissue_at_end(dive, cached_datap); tissue_at_end(dive, cached_datap);
previous_deco_time = 100000000; previous_deco_time = 100000000;
deco_time = 10000000; deco_state->deco_time = 10000000;
cache_deco_state(&bottom_cache); // Lets us make several iterations cache_deco_state(&bottom_cache); // Lets us make several iterations
bottom_depth = depth; bottom_depth = depth;
bottom_gi = gi; bottom_gi = gi;
@ -840,16 +840,16 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
//CVA //CVA
do { do {
decostopcounter = 0; decostopcounter = 0;
is_final_plan = (decoMode() == BUEHLMANN) || (previous_deco_time - deco_time < 10); // CVA time converges is_final_plan = (decoMode() == BUEHLMANN) || (previous_deco_time - deco_state->deco_time < 10); // CVA time converges
if (deco_time != 10000000) if (deco_state->deco_time != 10000000)
vpmb_next_gradient(deco_time, diveplan->surface_pressure / 1000.0); vpmb_next_gradient(deco_state->deco_time, diveplan->surface_pressure / 1000.0);
previous_deco_time = deco_time; previous_deco_time = deco_state->deco_time;
restore_deco_state(bottom_cache, true); restore_deco_state(bottom_cache, true);
depth = bottom_depth; depth = bottom_depth;
gi = bottom_gi; gi = bottom_gi;
clock = previous_point_time = deco_state->bottom_time; clock = previous_point_time = bottom_time;
gas = bottom_gas; gas = bottom_gas;
stopping = false; stopping = false;
decodive = false; decodive = false;
@ -864,7 +864,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
if (deco_state->max_bottom_ceiling_pressure.mbar > deco_state->first_ceiling_pressure.mbar) if (deco_state->max_bottom_ceiling_pressure.mbar > deco_state->first_ceiling_pressure.mbar)
deco_state->first_ceiling_pressure.mbar = deco_state->max_bottom_ceiling_pressure.mbar; deco_state->first_ceiling_pressure.mbar = deco_state->max_bottom_ceiling_pressure.mbar;
last_ascend_rate = ascent_velocity(depth, avg_depth, deco_state->bottom_time); last_ascend_rate = ascent_velocity(depth, avg_depth, bottom_time);
/* Always prefer the best_first_ascend_cylinder if it has the right gasmix. /* Always prefer the best_first_ascend_cylinder if it has the right gasmix.
* Otherwise take first cylinder from list with rightgasmix */ * Otherwise take first cylinder from list with rightgasmix */
if (same_gasmix(&gas, &dive->cylinder[best_first_ascend_cylinder].gasmix)) if (same_gasmix(&gas, &dive->cylinder[best_first_ascend_cylinder].gasmix))
@ -880,13 +880,13 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
/* We will break out when we hit the surface */ /* We will break out when we hit the surface */
do { do {
/* Ascend to next stop depth */ /* Ascend to next stop depth */
int deltad = ascent_velocity(depth, avg_depth, deco_state->bottom_time) * TIMESTEP; int deltad = ascent_velocity(depth, avg_depth, bottom_time) * TIMESTEP;
if (ascent_velocity(depth, avg_depth, deco_state->bottom_time) != last_ascend_rate) { if (ascent_velocity(depth, avg_depth, bottom_time) != last_ascend_rate) {
if (is_final_plan) if (is_final_plan)
plan_add_segment(diveplan, clock - previous_point_time, depth, current_cylinder, po2, false); plan_add_segment(diveplan, clock - previous_point_time, depth, current_cylinder, po2, false);
previous_point_time = clock; previous_point_time = clock;
stopping = false; stopping = false;
last_ascend_rate = ascent_velocity(depth, avg_depth, deco_state->bottom_time); last_ascend_rate = ascent_velocity(depth, avg_depth, bottom_time);
} }
if (depth - deltad < stoplevels[stopidx]) if (depth - deltad < stoplevels[stopidx])
deltad = depth - stoplevels[stopidx]; deltad = depth - stoplevels[stopidx];
@ -919,7 +919,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
if (current_cylinder != gaschanges[gi].gasidx) { if (current_cylinder != gaschanges[gi].gasidx) {
if (!prefs.switch_at_req_stop || if (!prefs.switch_at_req_stop ||
!trial_ascent(0, depth, stoplevels[stopidx - 1], avg_depth, deco_state->bottom_time, !trial_ascent(0, depth, stoplevels[stopidx - 1], avg_depth, bottom_time,
&dive->cylinder[current_cylinder].gasmix, po2, diveplan->surface_pressure / 1000.0, dive) || get_o2(&dive->cylinder[current_cylinder].gasmix) < 160) { &dive->cylinder[current_cylinder].gasmix, po2, diveplan->surface_pressure / 1000.0, dive) || get_o2(&dive->cylinder[current_cylinder].gasmix) < 160) {
current_cylinder = gaschanges[gi].gasidx; current_cylinder = gaschanges[gi].gasidx;
gas = dive->cylinder[current_cylinder].gasmix; gas = dive->cylinder[current_cylinder].gasmix;
@ -948,7 +948,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
/* Save the current state and try to ascend to the next stopdepth */ /* Save the current state and try to ascend to the next stopdepth */
while (1) { while (1) {
/* Check if ascending to next stop is clear, go back and wait if we hit the ceiling on the way */ /* Check if ascending to next stop is clear, go back and wait if we hit the ceiling on the way */
if (trial_ascent(0, depth, stoplevels[stopidx], avg_depth, deco_state->bottom_time, if (trial_ascent(0, depth, stoplevels[stopidx], avg_depth, bottom_time,
&dive->cylinder[current_cylinder].gasmix, po2, diveplan->surface_pressure / 1000.0, dive)) { &dive->cylinder[current_cylinder].gasmix, po2, diveplan->surface_pressure / 1000.0, dive)) {
decostoptable[decostopcounter].depth = depth; decostoptable[decostopcounter].depth = depth;
decostoptable[decostopcounter].time = 0; decostoptable[decostopcounter].time = 0;
@ -990,7 +990,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
pendinggaschange = false; pendinggaschange = false;
} }
int new_clock = wait_until(dive, clock, clock, laststoptime * 2 + 1, timestep, depth, stoplevels[stopidx], avg_depth, deco_state->bottom_time, &dive->cylinder[current_cylinder].gasmix, po2, diveplan->surface_pressure / 1000.0); int new_clock = wait_until(dive, clock, clock, laststoptime * 2 + 1, timestep, depth, stoplevels[stopidx], avg_depth, bottom_time, &dive->cylinder[current_cylinder].gasmix, po2, diveplan->surface_pressure / 1000.0);
laststoptime = new_clock - clock; laststoptime = new_clock - clock;
/* Finish infinite deco */ /* Finish infinite deco */
if (clock >= 48 * 3600 && depth >= 6000) { if (clock >= 48 * 3600 && depth >= 6000) {
@ -1060,7 +1060,7 @@ bool plan(struct diveplan *diveplan, struct dive *dive, int timestep, struct dec
* otherwise odd things can happen, such as CVA causing the final ascent to start *later* * otherwise odd things can happen, such as CVA causing the final ascent to start *later*
* if the ascent rate is slower, which is completely nonsensical. * if the ascent rate is slower, which is completely nonsensical.
* Assume final ascent takes 20s, which is the time taken to ascend at 9m/min from 3m */ * Assume final ascent takes 20s, which is the time taken to ascend at 9m/min from 3m */
deco_time = clock - deco_state->bottom_time - stoplevels[2] / last_ascend_rate + 20; deco_state->deco_time = clock - bottom_time - stoplevels[2] / last_ascend_rate + 20;
} while (!is_final_plan); } while (!is_final_plan);
decostoptable[decostopcounter].depth = 0; decostoptable[decostopcounter].depth = 0;

26
core/profile.c
View file

@ -954,14 +954,12 @@ static void calculate_ndl_tts(struct dive *dive, struct plot_data *entry, struct
*/ */
void calculate_deco_information(struct dive *dive, struct divecomputer *dc, struct plot_info *pi, bool print_mode) void calculate_deco_information(struct dive *dive, struct divecomputer *dc, struct plot_info *pi, bool print_mode)
{ {
int i, count_iteration = 0, deco_time; int i, count_iteration = 0;
double surface_pressure = (dc->surface_pressure.mbar ? dc->surface_pressure.mbar : get_surface_pressure_in_mbar(dive, true)) / 1000.0; double surface_pressure = (dc->surface_pressure.mbar ? dc->surface_pressure.mbar : get_surface_pressure_in_mbar(dive, true)) / 1000.0;
bool first_iteration = true; bool first_iteration = true;
int prev_deco_time = 10000000, time_deep_ceiling = 0; int prev_deco_time = 10000000, time_deep_ceiling = 0;
if (in_planner()) if (!in_planner())
deco_time = pi->maxtime - deco_state->bottom_time; deco_state->deco_time = 0;
else
deco_time = 0;
struct deco_state *cache_data_initial = NULL; struct deco_state *cache_data_initial = NULL;
/* For VPM-B outside the planner, cache the initial deco state for CVA iterations */ /* For VPM-B outside the planner, cache the initial deco state for CVA iterations */
if (decoMode() == VPMB) { if (decoMode() == VPMB) {
@ -969,7 +967,7 @@ void calculate_deco_information(struct dive *dive, struct divecomputer *dc, stru
} }
/* For VPM-B outside the planner, iterate until deco time converges (usually one or two iterations after the initial) /* For VPM-B outside the planner, iterate until deco time converges (usually one or two iterations after the initial)
* Set maximum number of iterations to 10 just in case */ * Set maximum number of iterations to 10 just in case */
while ((abs(prev_deco_time - deco_time) >= 30) && (count_iteration < 10)) { while ((abs(prev_deco_time - deco_state->deco_time) >= 30) && (count_iteration < 10)) {
int last_ndl_tts_calc_time = 0, first_ceiling = 0, current_ceiling, last_ceiling, final_tts = 0 , time_clear_ceiling = 0; int last_ndl_tts_calc_time = 0, first_ceiling = 0, current_ceiling, last_ceiling, final_tts = 0 , time_clear_ceiling = 0;
if (decoMode() == VPMB) if (decoMode() == VPMB)
deco_state->first_ceiling_pressure.mbar = depth_to_mbar(first_ceiling, dive); deco_state->first_ceiling_pressure.mbar = depth_to_mbar(first_ceiling, dive);
@ -1009,7 +1007,7 @@ void calculate_deco_information(struct dive *dive, struct divecomputer *dc, stru
vpmb_start_gradient(); vpmb_start_gradient();
/* For CVA iterations, calculate next gradient */ /* For CVA iterations, calculate next gradient */
if (!first_iteration || in_planner()) if (!first_iteration || in_planner())
vpmb_next_gradient(deco_time, surface_pressure / 1000.0); vpmb_next_gradient(deco_state->deco_time, surface_pressure / 1000.0);
} }
entry->ceiling = deco_allowed_depth(tissue_tolerance_calc(dive, depth_to_bar(entry->depth, dive)), surface_pressure, dive, !prefs.calcceiling3m); entry->ceiling = deco_allowed_depth(tissue_tolerance_calc(dive, depth_to_bar(entry->depth, dive)), surface_pressure, dive, !prefs.calcceiling3m);
if (prefs.calcceiling3m) if (prefs.calcceiling3m)
@ -1031,8 +1029,8 @@ void calculate_deco_information(struct dive *dive, struct divecomputer *dc, stru
but we want to over-estimate deco_time for the first iteration so it but we want to over-estimate deco_time for the first iteration so it
converges correctly, so add 30min*/ converges correctly, so add 30min*/
if (!in_planner()) if (!in_planner())
deco_time = pi->maxtime - t1 + 1800; deco_state->deco_time = pi->maxtime - t1 + 1800;
vpmb_next_gradient(deco_time, surface_pressure / 1000.0); vpmb_next_gradient(deco_state->deco_time, surface_pressure / 1000.0);
} }
} }
// Use the point where the ceiling clears as the end of deco phase for CVA calculations // Use the point where the ceiling clears as the end of deco phase for CVA calculations
@ -1079,17 +1077,17 @@ void calculate_deco_information(struct dive *dive, struct divecomputer *dc, stru
} }
} }
if (decoMode() == VPMB && !in_planner()) { if (decoMode() == VPMB && !in_planner()) {
prev_deco_time = deco_time; prev_deco_time = deco_state->deco_time;
// Do we need to update deco_time? // Do we need to update deco_time?
if (final_tts > 0) if (final_tts > 0)
deco_time = pi->maxtime + final_tts - time_deep_ceiling; deco_state->deco_time = pi->maxtime + final_tts - time_deep_ceiling;
else if (time_clear_ceiling > 0) else if (time_clear_ceiling > 0)
/* Consistent with planner, deco_time ends after ascending (20s @9m/min from 3m) /* Consistent with planner, deco_time ends after ascending (20s @9m/min from 3m)
* at end of whole minute after clearing ceiling. The deepest ceiling when planning a dive * at end of whole minute after clearing ceiling. The deepest ceiling when planning a dive
* comes typically 10-60s after the end of the bottom time, so add 20s to the calculated * comes typically 10-60s after the end of the bottom time, so add 20s to the calculated
* deco time. */ * deco time. */
deco_time = ROUND_UP(time_clear_ceiling - time_deep_ceiling + 20, 60) + 20; deco_state->deco_time = ROUND_UP(time_clear_ceiling - time_deep_ceiling + 20, 60) + 20;
vpmb_next_gradient(deco_time, surface_pressure / 1000.0); vpmb_next_gradient(deco_state->deco_time, surface_pressure / 1000.0);
final_tts = 0; final_tts = 0;
last_ndl_tts_calc_time = 0; last_ndl_tts_calc_time = 0;
first_ceiling = 0; first_ceiling = 0;
@ -1098,7 +1096,7 @@ void calculate_deco_information(struct dive *dive, struct divecomputer *dc, stru
restore_deco_state(cache_data_initial, true); restore_deco_state(cache_data_initial, true);
} else { } else {
// With Buhlmann iterating isn't needed. This makes the while condition false. // With Buhlmann iterating isn't needed. This makes the while condition false.
prev_deco_time = deco_time = 0; prev_deco_time = deco_state->deco_time = 0;
} }
} }
free(cache_data_initial); free(cache_data_initial);