On 29 October 2015 at 18:53, Rick Walsh <[email protected]> wrote:
> Robert, > > On 29 October 2015 at 07:18, Robert C. Helling <[email protected]> wrote: > >> Hi Rick, >> >> here are some more comments but I think we are converging on all the >> points. >> >> On 28 Oct 2015, at 13:10, Rick Walsh <[email protected]> wrote: >> >>> > >>> > bool off_gassing = false >>> > >>> > and then in the loop >>> > >>> > off_gassing ||= (pn2_oversat < 0) || (phe_oversat <0); >>> > >>> > and finally change add_segment from void to bool by returning >>> off_gassing. Then we can simply add all the time for all segments the we >>> added which return true. >>> >>> This would work, but will achieve almost the same outcome. Taking deco >>> time as time from max ceiling until time of clear ceiling implies that at >>> least one tissues, the leading tissue, is off-gassing. With a very deep >>> (setting deepest ceiling) to shallow (shallower ceiling) to deep (all >>> tissues on-gas and ceiling deepens but not to max), there could be a small >>> difference in calculated deco time. >>> >> A problem with this approach is that with a deep -> shallow -> deeper >> (setting deepest ceiling) profile is that it would start counting deco time >> before we are in the real ascent phase and actual offgassing. I don't >> believe we should be distributing the extra bubble volume allowed by the >> CVA over this section. I have kept it as is, but happy to discuss further. >> >> >> This is really about how to interpret the (in itself not very logical) >> philosophy of the model. I would argue, that whenever the tissues are >> oversaturated compared to the ambient pressure we are adding gas to the >> bubbles and those are there to stay (their decay is supposed to have a half >> time of two weeks). So, there is „free gas“ no matter if we later go to >> greater depth again or not. So I would count it. Or, maybe more convincing: >> Imagine a dive where you do something which in the real world would be >> rather stupid: You do all you stops and when at last the 3m ceiling clears, >> you realise that the anchor needs to be freed. So you do a final bounce to >> the bottom and then ascent. In that case, you would want to count all the >> bubbles of the real deco not just those of the bounce. >> >> Yes, how should the philosophy of model be interpreted? It's especially > hard when to my knowledge, nothing has been documented for interpreting > actual dives. > > I was actually considering the case of a dive with a final bounce. My > rationale was dropped equipment, rather than freeing an anchor, but the > profile is similar. I think an important feature of a final bounce, after > clearing the ceiling (or nearly clearing the ceiling) from the main dive > would be that any deco ceiling from the bounce would be shallower than the > maximum ceiling of the main part of the dive. If that weren't the case, > there'd be a significant deco obligation, the calculated deco time would be > much longer, and the boat captain would not be happy that we'd caused him > to wait an extra 45 minutes. > > Assuming the bounce ceiling is shallower than the deepest ceiling, the > deco time calculated as [runtime when ceiling cleared] - [runtime of > deepest ceiling] does count all the bubbles of the real deco. In fact it > would be a little bit longer than that calculated as [total offgassing > time], because the offgassing time wouldn't include the bounce descent. In > practice, the difference will be very little - a minute here or there > doesn't make much difference to the CVA. > The attached patch keeps the deco_time calculation as it was. > >> >>> > >>> > 2) I don’t really understand what you are doing >>> with first_ceiling_pressure_set. It seems to me you want to pick up the >>> first step after the maximum of the ceiling. So you look for a segment >>> where the ceiling goes up but in the previous step it didn’t. Why don’t you >>> simply memorise the last step where the ceiling gets deeper (it should be >>> the previous), by getting rid of first_ceiling_pressure_set and simply doing >>> > >>> > if (entry->ceiling > first_ceiling) { >>> > first_ceiling = entry->ceiling; >>> > first_ceiling_pressure.mbar = depth_to_mbar(first_ceiling, dive); >>> > } >>> > >>> > This would give you the value for the maximum ceiling. >>> >>> Yes, that's much simpler way to achieve the same thing. I'll do that. >>> >> I tried doing that. But it messes up the setting of the gradients. >> Until we reach the deepest ceiling, we want to use first_gradient, after >> setting the deepest ceiling, we want to use next_gradient (set once, when >> first_ceiling_pressure is set) with the approximated deco_time. To >> distinguish, I have used the first_ceiling_pressure_set boolean variable. >> >> >> I don’t follow you here. Next gradient is about the next round of the >> CVA. What you say sounds more like you are talking about the Boyle >> compensation. Taking care of the latter is rather trivial: When >> entry->ceiling >= first_ceiling you don’t compensate and otherwise you do. >> (First ceiling is actually the max_ceiling up to that point). >> >> Sorry, I didn't explain that well at all. The first pass is used to > calculate the deepest ceiling. After the deepest ceiling is set, we are in > "ascent mode". Like in the planner, the CVA calculations are based on this > point forward. We want to run vpmb_next_gradient at this point, but not > after it (like in the planner, when it is run at the start of the CVA > loop). I used first_ceiling_pressure_set as a marker for whether we should > update the gradients. > > vpmb_next_gradient is set once only for the subsequent iteration(s) (at > the end of the previous iteration), so this is filtered out while looping > through the samples by testing for the bool first_iteration. > > Looking at the code again, I agree that rather than testing for > !first_ceiling_pressure_set, we should be able to test for entry->ceiling > >= first_ceiling. I'll have another go at this - if I can get it to work, > it should remove a few lines of code. > It works, and a few lines of code have been removed. No more first_ceiling_pressure_set. I also made it so that first_ceiling is recalculated when iterating. It makes a very small difference, but because the gradients are updated, the ceiling can change a little. > >> >>> > >>> > 3) I am a bit worried that the last hunk copies quite a bit of >>> non-trivial code. Wouldn’t it be possible to factor this out, i.e. do it >>> with a loop or as a separate function that the logic is in the source only >>> once? Otherwise, we are almost guaranteed that when changing the code in >>> the future we will end up with two inconsistent copies. >>> > >>> Yes, at first glance I thought only a little bit of code needed to be >>> repeated so I thought copying it would be better. But it turns out I >>> needed to copy most of it. I loop is better. >>> >> I have reworked to loop through the code until it deco_time converges, or >> a max of 3 iterations. >> >> >> In a quick look, I could not see what the loop is run only once if we are >> not using VPM. But I need to do some more understanding and thinking here. >> >> It does only run once if running in the planner, or if using Buhlmann, > but I should add a comment to explain. > > + while ((abs(prev_deco_time - deco_time) >= 30) && (count_iteration < > 4)) { > ... > ... > > + if (prefs.deco_mode == VPMB && !in_planner()) { > ... > + } else { > + prev_deco_time = deco_time = 0; > } > } > > Setting prev_deco_time = deco_time means that the while condition will > fail. They don't need to be set to zero, but it seemed safer to set to > something, in case deco_time hadn't been initialized (even though it is), > and hadn't been set. > Comments added to commit > > Cheers, > > Rick >
From c239be8ff4e865957ce80e132ccaa64f03dacb4c Mon Sep 17 00:00:00 2001 From: Rick Walsh <[email protected]> Date: Sun, 25 Oct 2015 11:26:15 +1100 Subject: [PATCH 1/2] Calculate VPM-B ceiling outside of planner Doing VPM-B calculations for dives outside of the planner has not been possible because real dive data does not record either: - reference pressure for the Boyle's law compensation (i.e. first_stop_pressure), or - deco_time for the vpmb_next_gradient function used to do the CVA calculations However, we can infer these values to be: - first_stop_pressure is the deepest ceiling in the dive - deco_time is dive time from the deepest ceiling until the ceiling clears (or would have cleared if the diver finished their deco obligations) These assumptions avoid having to do more than one extra CVA iterations to calculate the optimum deco profile. Signed-off-by: Rick Walsh <[email protected]> --- deco.c | 4 +- profile.c | 171 +++++++++++++++++++++++++++++++++++++++++--------------------- 2 files changed, 116 insertions(+), 59 deletions(-) diff --git a/deco.c b/deco.c index 86acc03..506d8b5 100644 --- a/deco.c +++ b/deco.c @@ -244,7 +244,7 @@ double tissue_tolerance_calc(const struct dive *dive, double pressure) double lowest_ceiling = 0.0; double tissue_lowest_ceiling[16]; - if (prefs.deco_mode != VPMB || !in_planner()) { + if (prefs.deco_mode != VPMB) { for (ci = 0; ci < 16; ci++) { tissue_inertgas_saturation[ci] = tissue_n2_sat[ci] + tissue_he_sat[ci]; buehlmann_inertgas_a[ci] = ((buehlmann_N2_a[ci] * tissue_n2_sat[ci]) + (buehlmann_He_a[ci] * tissue_he_sat[ci])) / tissue_inertgas_saturation[ci]; @@ -509,7 +509,7 @@ void add_segment(double pressure, const struct gasmix *gasmix, int period_in_sec tissue_n2_sat[ci] += n2_satmult * pn2_oversat * n2_f; tissue_he_sat[ci] += he_satmult * phe_oversat * he_f; } - if(prefs.deco_mode == VPMB && in_planner()) + if(prefs.deco_mode == VPMB) calc_crushing_pressure(pressure); return; } diff --git a/profile.c b/profile.c index d39133c..fc19422 100644 --- a/profile.c +++ b/profile.c @@ -28,6 +28,9 @@ unsigned int dc_number = 0; static struct plot_data *last_pi_entry_new = NULL; void populate_pressure_information(struct dive *, struct divecomputer *, struct plot_info *, int); +extern bool in_planner(); +extern pressure_t first_ceiling_pressure; + #ifdef DEBUG_PI /* debugging tool - not normally used */ static void dump_pi(struct plot_info *pi) @@ -927,69 +930,123 @@ static void calculate_ndl_tts(struct plot_data *entry, struct dive *dive, double */ void calculate_deco_information(struct dive *dive, struct divecomputer *dc, struct plot_info *pi, bool print_mode) { - int i; + 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; int last_ndl_tts_calc_time = 0; - for (i = 1; i < pi->nr; i++) { - struct plot_data *entry = pi->entry + i; - int j, t0 = (entry - 1)->sec, t1 = entry->sec; - int time_stepsize = 20; - - entry->ambpressure = depth_to_bar(entry->depth, dive); - entry->gfline = MAX((double)prefs.gflow, (entry->ambpressure - surface_pressure) / (gf_low_pressure_this_dive - surface_pressure) * - (prefs.gflow - prefs.gfhigh) + - prefs.gfhigh) * - (100.0 - AMB_PERCENTAGE) / 100.0 + AMB_PERCENTAGE; - if (t0 > t1) { - fprintf(stderr, "non-monotonous dive stamps %d %d\n", t0, t1); - int xchg = t1; - t1 = t0; - t0 = xchg; - } - if (t0 != t1 && t1 - t0 < time_stepsize) - time_stepsize = t1 - t0; - for (j = t0 + time_stepsize; j <= t1; j += time_stepsize) { - int depth = interpolate(entry[-1].depth, entry[0].depth, j - t0, t1 - t0); - add_segment(depth_to_bar(depth, dive), - &dive->cylinder[entry->cylinderindex].gasmix, time_stepsize, entry->o2pressure.mbar, dive, entry->sac); - if ((t1 - j < time_stepsize) && (j < t1)) - time_stepsize = t1 - j; - } - if (t0 == t1) - entry->ceiling = (entry - 1)->ceiling; - else - entry->ceiling = deco_allowed_depth(tissue_tolerance_calc(dive, depth_to_bar(entry->depth, dive)), surface_pressure, dive, !prefs.calcceiling3m); - for (j = 0; j < 16; j++) { - double m_value = buehlmann_inertgas_a[j] + entry->ambpressure / buehlmann_inertgas_b[j]; - entry->ceilings[j] = deco_allowed_depth(tolerated_by_tissue[j], surface_pressure, dive, 1); - entry->percentages[j] = tissue_inertgas_saturation[j] < entry->ambpressure ? - tissue_inertgas_saturation[j] / entry->ambpressure * AMB_PERCENTAGE : - AMB_PERCENTAGE + (tissue_inertgas_saturation[j] - entry->ambpressure) / (m_value - entry->ambpressure) * (100.0 - AMB_PERCENTAGE); - } + int first_ceiling; + bool first_iteration = true; + int final_tts = 0 , time_clear_ceiling = 0, time_deep_ceiling = 0, deco_time = 0, prev_deco_time = 10000000; + char *cache_data_initial = NULL; + /* For VPM-B outside the planner, cache the initial deco state for CVA iterations */ + if (prefs.deco_mode == VPMB && !in_planner()) + cache_deco_state(&cache_data_initial); + /* For VPM-B outside the planner, iterate until deco time converges (usually one iteration after the initial) + * Set maximum number of iterations to 4 just in case */ + while ((abs(prev_deco_time - deco_time) >= 30) && (count_iteration < 4)) { + for (i = 1; i < pi->nr; i++) { + struct plot_data *entry = pi->entry + i; + int j, t0 = (entry - 1)->sec, t1 = entry->sec; + int time_stepsize = 20; + + entry->ambpressure = depth_to_bar(entry->depth, dive); + entry->gfline = MAX((double)prefs.gflow, (entry->ambpressure - surface_pressure) / (gf_low_pressure_this_dive - surface_pressure) * + (prefs.gflow - prefs.gfhigh) + + prefs.gfhigh) * + (100.0 - AMB_PERCENTAGE) / 100.0 + AMB_PERCENTAGE; + if (t0 > t1) { + fprintf(stderr, "non-monotonous dive stamps %d %d\n", t0, t1); + int xchg = t1; + t1 = t0; + t0 = xchg; + } + if (t0 != t1 && t1 - t0 < time_stepsize) + time_stepsize = t1 - t0; + for (j = t0 + time_stepsize; j <= t1; j += time_stepsize) { + int depth = interpolate(entry[-1].depth, entry[0].depth, j - t0, t1 - t0); + add_segment(depth_to_bar(depth, dive), + &dive->cylinder[entry->cylinderindex].gasmix, time_stepsize, entry->o2pressure.mbar, dive, entry->sac); + if ((t1 - j < time_stepsize) && (j < t1)) + time_stepsize = t1 - j; + } + if (t0 == t1) { + entry->ceiling = (entry - 1)->ceiling; + } else { + /* Keep updating the VPM-B gradients until the start of the ascent phase of the dive. */ + if (prefs.deco_mode == VPMB && !in_planner() && entry->depth >= first_ceiling && first_iteration == true) { + nuclear_regeneration(t1); + vpmb_start_gradient(); + /* For CVA calculations, start by guessing deco time = dive time remaining */ + deco_time = pi->maxtime - t1; + vpmb_next_gradient(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); + /* If using VPM-B outside the planner, take first_ceiling_pressure as the deepest ceiling */ + if (prefs.deco_mode == VPMB && !in_planner()) { + if (entry->ceiling >= first_ceiling) { + time_deep_ceiling = t1; + first_ceiling = entry->ceiling; + first_ceiling_pressure.mbar = depth_to_mbar(first_ceiling, dive); + } + // Use the point where the ceiling clears as the end of deco phase for CVA calculations + if (entry->ceiling > 0) + time_clear_ceiling = 0; + else if (time_clear_ceiling == 0) + time_clear_ceiling = t1; + } + } + for (j = 0; j < 16; j++) { + double m_value = buehlmann_inertgas_a[j] + entry->ambpressure / buehlmann_inertgas_b[j]; + entry->ceilings[j] = deco_allowed_depth(tolerated_by_tissue[j], surface_pressure, dive, 1); + entry->percentages[j] = tissue_inertgas_saturation[j] < entry->ambpressure ? + tissue_inertgas_saturation[j] / entry->ambpressure * AMB_PERCENTAGE : + AMB_PERCENTAGE + (tissue_inertgas_saturation[j] - entry->ambpressure) / (m_value - entry->ambpressure) * (100.0 - AMB_PERCENTAGE); + } - /* should we do more calculations? - * We don't for print-mode because this info doesn't show up there */ - if (prefs.calcndltts && !print_mode) { - /* only calculate ndl/tts on every 30 seconds */ - if ((entry->sec - last_ndl_tts_calc_time) < 30) { - struct plot_data *prev_entry = (entry - 1); - entry->stoptime_calc = prev_entry->stoptime_calc; - entry->stopdepth_calc = prev_entry->stopdepth_calc; - entry->tts_calc = prev_entry->tts_calc; - entry->ndl_calc = prev_entry->ndl_calc; - continue; + /* should we do more calculations? + * We don't for print-mode because this info doesn't show up there + * If the ceiling hasn't cleared by the last data point, we need tts for VPM-B CVA calculation */ + if ((prefs.calcndltts && !print_mode) || (prefs.deco_mode == VPMB && !in_planner() && i == pi->nr - 1 && entry->ceiling > 0)) { + /* only calculate ndl/tts on every 30 seconds */ + if ((entry->sec - last_ndl_tts_calc_time) < 30 && i != pi->nr - 1) { + struct plot_data *prev_entry = (entry - 1); + entry->stoptime_calc = prev_entry->stoptime_calc; + entry->stopdepth_calc = prev_entry->stopdepth_calc; + entry->tts_calc = prev_entry->tts_calc; + entry->ndl_calc = prev_entry->ndl_calc; + continue; + } + last_ndl_tts_calc_time = entry->sec; + + /* We are going to mess up deco state, so store it for later restore */ + char *cache_data = NULL; + cache_deco_state(&cache_data); + calculate_ndl_tts(entry, dive, surface_pressure); + if (prefs.deco_mode == VPMB && !in_planner() && i == pi->nr - 1) + final_tts = entry->tts_calc; + /* Restore "real" deco state for next real time step */ + restore_deco_state(cache_data); + free(cache_data); } - last_ndl_tts_calc_time = entry->sec; - - /* We are going to mess up deco state, so store it for later restore */ - char *cache_data = NULL; - cache_deco_state(&cache_data); - calculate_ndl_tts(entry, dive, surface_pressure); - /* Restore "real" deco state for next real time step */ - restore_deco_state(cache_data); - free(cache_data); + } + if (prefs.deco_mode == VPMB && !in_planner()) { + restore_deco_state(cache_data_initial); + prev_deco_time = deco_time; + last_ndl_tts_calc_time = 0; + first_ceiling = 0; + // Do we need to update deco_time? + if (final_tts > 0) + deco_time = pi->maxtime + final_tts - time_deep_ceiling; + else if (time_clear_ceiling > 0) + deco_time = time_clear_ceiling - time_deep_ceiling; + vpmb_next_gradient(deco_time, surface_pressure / 1000.0); + first_iteration = false; + count_iteration ++; + } else { + // With Buhlmann, or not in planner, iterations aren't needed. This makes the while condition false. + prev_deco_time = deco_time = 0; } } + free(cache_data_initial); #if DECO_CALC_DEBUG & 1 dump_tissues(); #endif -- 2.4.3
From 4f55748bc549a04a06d6d7ba495cff15cea51eb7 Mon Sep 17 00:00:00 2001 From: Rick Walsh <[email protected]> Date: Sat, 24 Oct 2015 20:03:46 +1100 Subject: [PATCH 2/2] Profile: Display VPM-B rather than GF when in VPM-B mode If we are planning a dive using VPM-B with +x conservatism, we want to print "VPM-B +x" at the top of the profile, instead of "GF xx/yy". Accordingly, the variable gradientFactor in profilewidget2.cpp is renamed decoModelParameters to reflect what it represents. Signed-off-by: Rick Walsh <[email protected]> --- qt-ui/profile/profilewidget2.cpp | 32 +++++++++++++++++++------------- qt-ui/profile/profilewidget2.h | 2 +- 2 files changed, 20 insertions(+), 14 deletions(-) diff --git a/qt-ui/profile/profilewidget2.cpp b/qt-ui/profile/profilewidget2.cpp index 3ccd1bb..d474670 100644 --- a/qt-ui/profile/profilewidget2.cpp +++ b/qt-ui/profile/profilewidget2.cpp @@ -87,7 +87,7 @@ ProfileWidget2::ProfileWidget2(QWidget *parent) : QGraphicsView(parent), gasPressureItem(new DiveGasPressureItem()), diveComputerText(new DiveTextItem()), diveCeiling(new DiveCalculatedCeiling()), - gradientFactor(new DiveTextItem()), + decoModelParameters(new DiveTextItem()), reportedCeiling(new DiveReportedCeiling()), pn2GasItem(new PartialPressureGasItem()), pheGasItem(new PartialPressureGasItem()), @@ -204,7 +204,7 @@ void ProfileWidget2::addItemsToScene() diveComputerText->setData(SUBSURFACE_OBJ_DATA, SUBSURFACE_OBJ_DC_TEXT); scene()->addItem(diveComputerText); scene()->addItem(diveCeiling); - scene()->addItem(gradientFactor); + scene()->addItem(decoModelParameters); scene()->addItem(reportedCeiling); scene()->addItem(pn2GasItem); scene()->addItem(pheGasItem); @@ -288,11 +288,11 @@ void ProfileWidget2::setupItemOnScene() rulerItem->setAxis(timeAxis, profileYAxis); tankItem->setHorizontalAxis(timeAxis); - // show the gradient factor at the top in the center - gradientFactor->setY(0); - gradientFactor->setX(50); - gradientFactor->setBrush(getColor(PRESSURE_TEXT)); - gradientFactor->setAlignment(Qt::AlignHCenter | Qt::AlignBottom); + // show the deco model parameters at the top in the center + decoModelParameters->setY(0); + decoModelParameters->setX(50); + decoModelParameters->setBrush(getColor(PRESSURE_TEXT)); + decoModelParameters->setAlignment(Qt::AlignHCenter | Qt::AlignBottom); setupItem(reportedCeiling, timeAxis, profileYAxis, dataModel, DivePlotDataModel::CEILING, DivePlotDataModel::TIME, 1); setupItem(diveCeiling, timeAxis, profileYAxis, dataModel, DivePlotDataModel::CEILING, DivePlotDataModel::TIME, 1); @@ -509,7 +509,10 @@ void ProfileWidget2::plotDive(struct dive *d, bool force) // this copies the dive and makes copies of all the relevant additional data copy_dive(d, &displayed_dive); - gradientFactor->setText(QString("GF %1/%2").arg(prefs.gflow).arg(prefs.gfhigh)); + if (prefs.deco_mode == VPMB) + decoModelParameters->setText(QString("VPM-B +%1").arg(prefs.conservatism_level)); + else + decoModelParameters->setText(QString("GF %1/%2").arg(prefs.gflow).arg(prefs.gfhigh)); } else { DivePlannerPointsModel *plannerModel = DivePlannerPointsModel::instance(); plannerModel->createTemporaryPlan(); @@ -518,7 +521,10 @@ void ProfileWidget2::plotDive(struct dive *d, bool force) plannerModel->deleteTemporaryPlan(); return; } - gradientFactor->setText(QString("GF %1/%2").arg(diveplan.gflow).arg(diveplan.gfhigh)); + if (prefs.deco_mode == VPMB) + decoModelParameters->setText(QString("VPM-B +%1").arg(prefs.conservatism_level)); + else + decoModelParameters->setText(QString("GF %1/%2").arg(prefs.gflow).arg(prefs.gfhigh)); } // special handling for the first time we display things @@ -926,7 +932,7 @@ void ProfileWidget2::setEmptyState() toolTipItem->setVisible(false); diveComputerText->setVisible(false); diveCeiling->setVisible(false); - gradientFactor->setVisible(false); + decoModelParameters->setVisible(false); reportedCeiling->setVisible(false); rulerItem->setVisible(false); tankItem->setVisible(false); @@ -1053,7 +1059,7 @@ void ProfileWidget2::setProfileState() diveComputerText->setPos(itemPos.dcLabel.on); diveCeiling->setVisible(prefs.calcceiling); - gradientFactor->setVisible(prefs.calcceiling); + decoModelParameters->setVisible(prefs.calcceiling); reportedCeiling->setVisible(prefs.dcceiling); if (prefs.calcalltissues) { @@ -1131,7 +1137,7 @@ void ProfileWidget2::setAddState() /* show the same stuff that the profile shows. */ currentState = ADD; /* enable the add state. */ diveCeiling->setVisible(true); - gradientFactor->setVisible(true); + decoModelParameters->setVisible(true); setBackgroundBrush(QColor("#A7DCFF")); } @@ -1165,7 +1171,7 @@ void ProfileWidget2::setPlanState() /* show the same stuff that the profile shows. */ currentState = PLAN; /* enable the add state. */ diveCeiling->setVisible(true); - gradientFactor->setVisible(true); + decoModelParameters->setVisible(true); setBackgroundBrush(QColor("#D7E3EF")); } diff --git a/qt-ui/profile/profilewidget2.h b/qt-ui/profile/profilewidget2.h index 2d1a7bf..23e9398 100644 --- a/qt-ui/profile/profilewidget2.h +++ b/qt-ui/profile/profilewidget2.h @@ -171,7 +171,7 @@ private: QList<DiveEventItem *> eventItems; DiveTextItem *diveComputerText; DiveCalculatedCeiling *diveCeiling; - DiveTextItem *gradientFactor; + DiveTextItem *decoModelParameters; QList<DiveCalculatedTissue *> allTissues; DiveReportedCeiling *reportedCeiling; PartialPressureGasItem *pn2GasItem; -- 2.4.3
_______________________________________________ subsurface mailing list [email protected] http://lists.subsurface-divelog.org/cgi-bin/mailman/listinfo/subsurface
