38
+ − 1 ///////////////////////////////////////////////////////////////////////////////
+ − 2 /// -*- coding: UTF-8 -*-
+ − 3 ///
+ − 4 /// \file Discovery/Src/vpm.c
+ − 5 /// \brief critical_volume comment by hw
+ − 6 /// \author Heinrichs Weikamp, Erik C. Baker
+ − 7 /// \date 19-April-2014
+ − 8 ///
+ − 9 /// \details
+ − 10 ///
+ − 11 /// $Id$
+ − 12 ///////////////////////////////////////////////////////////////////////////////
+ − 13 /// \par Copyright (c) 2014-2018 Heinrichs Weikamp gmbh
+ − 14 ///
+ − 15 /// This program is free software: you can redistribute it and/or modify
+ − 16 /// it under the terms of the GNU General Public License as published by
+ − 17 /// the Free Software Foundation, either version 3 of the License, or
+ − 18 /// (at your option) any later version.
+ − 19 ///
+ − 20 /// This program is distributed in the hope that it will be useful,
+ − 21 /// but WITHOUT ANY WARRANTY; without even the implied warranty of
+ − 22 /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ − 23 /// GNU General Public License for more details.
+ − 24 ///
+ − 25 /// You should have received a copy of the GNU General Public License
+ − 26 /// along with this program. If not, see <http://www.gnu.org/licenses/>.
+ − 27 //////////////////////////////////////////////////////////////////////////////
+ − 28 /// \par Varying Permeability Model (VPM) Decompression Program in c (converted from FORTRAN)
+ − 29 ///
+ − 30 /// Author: Erik C. Baker
+ − 31 ///
+ − 32 /// "DISTRIBUTE FREELY - CREDIT THE AUTHORS"
+ − 33 ///
+ − 34 /// This program extends the 1986 VPM algorithm (Yount & Hoffman) to include
+ − 35 /// mixed gas, repetitive, and altitude diving. Developments to the algorithm
+ − 36 /// were made by David E. Yount, Eric B. Maiken, and Erik C. Baker over a
+ − 37 /// period from 1999 to 2001. This work is dedicated in remembrance of
+ − 38 /// Professor David E. Yount who passed away on April 27, 2000.
+ − 39 ///
+ − 40 /// Notes:
+ − 41 /// 1. This program uses the sixteen (16) half-time compartments of the
+ − 42 /// Buhlmann ZH-L16 model. The optional Compartment 1b is used here with
+ − 43 /// half-times of 1.88 minutes for helium and 5.0 minutes for nitrogen.
+ − 44 ///
+ − 45 /// 2. This program uses various DEC, IBM, and Microsoft extensions which
+ − 46 /// may not be supported by all FORTRAN compilers. Comments are made with
+ − 47 /// a capital "C" in the first column or an exclamation point "!" placed
+ − 48 /// in a line after code. An asterisk "*" in column 6 is a continuation
+ − 49 /// of the previous line. All code, except for line numbers, starts in
+ − 50 /// column 7.
+ − 51 ///
+ − 52 /// 3. Comments and suggestions for improvements are welcome. Please
+ − 53 /// respond by e-mail to: EBaker@se.aeieng.com
+ − 54 ///
+ − 55 /// Acknowledgment: Thanks to Kurt Spaugh for recommendations on how to clean
+ − 56 /// up the code.
+ − 57 /// ===============================================================================
+ − 58 /// Converted to vpmdeco.c using f2c; R.McGinnis (CABER Swe) 5/01
+ − 59 /// ===============================================================================
+ − 60 ///
+ − 61 /// ************************ Heirichs Weipkamp **************************************
+ − 62 ///
+ − 63 /// The original Yount & Baker code has been adjusted for real life calculation.
+ − 64 ///
+ − 65 /// 1) The original main function has been split in several functions
+ − 66 ///
+ − 67 /// 2) When the deco zone is reached (while ascending) the gradient factors are kept fix
+ − 68 /// and critical volume algorithm is switched of. maxfirststopdepth is kept fix
+ − 69 /// to make shure Boeyls Law algorithm works correctly
+ − 70 ///
+ − 71 /// 4) gas_loadings_ascent_descend heeds all gaschanges and CCR support has been added
+ − 72 ///
+ − 73
+ − 74 #include <stdio.h>
+ − 75 #include <stdlib.h>
+ − 76 #include <string.h>
+ − 77 #include <math.h>
+ − 78 #include <time.h>
+ − 79
+ − 80 #include "vpm.h"
+ − 81 #include "decom.h"
+ − 82
+ − 83 #define GAS_N2 0
+ − 84 #define GAS_HE 1
+ − 85
290
+ − 86 static const _Bool buehlmannSafety = true;
38
+ − 87 /* Common Block Declarations */
+ − 88
+ − 89 extern const float SURFACE_TENSION_GAMMA; //!Adj. Range: 0.015 to 0.065 N/m
+ − 90 extern const float SKIN_COMPRESSION_GAMMAC; //!Adj. Range: 0.160 to 0.290 N/m
+ − 91 extern const float UNITS_FACTOR;
+ − 92 extern const float WATER_VAPOR_PRESSURE; // (Schreiner value) based on respiratory quotien
+ − 93 extern const float CRIT_VOLUME_PARAMETER_LAMBDA; //!Adj. Range: 6500 to 8300 fsw-min
290
+ − 94 //extern const float GRADIENT_ONSET_OF_IMPERM_ATM; //!Adj. Range: 5.0 to 10.0 atm
38
+ − 95 extern const float REGENERATION_TIME_CONSTANT; //!Adj. Range: 10080 to 51840 min
290
+ − 96 //extern const float PRESSURE_OTHER_GASES_MMHG; //!Constant value for PO2 up to 2 atm
38
+ − 97 extern const float CONSTANT_PRESSURE_OTHER_GASES; // PRESSURE_OTHER_GASES_MMHG / 760. * UNITS_FACTOR;
+ − 98
+ − 99 extern const float HELIUM_TIME_CONSTANT[];
+ − 100 extern const float NITROGEN_TIME_CONSTANT[];
+ − 101
290
+ − 102 static float minimum_deco_stop_time;
+ − 103 static float run_time, run_time_first_stop;
+ − 104 static float segment_time;
+ − 105 static short mix_number;
+ − 106 static float barometric_pressure;
+ − 107 static _Bool altitude_dive_algorithm_off;
+ − 108 static _Bool units_equal_fsw, units_equal_msw;
38
+ − 109
+ − 110 /* by hw 11.06.2015 to allow */
290
+ − 111 static float gCNS_VPM;
38
+ − 112
290
+ − 113 static float helium_pressure[16], nitrogen_pressure[16];
+ − 114 static float surface_phase_volume_time[16];
+ − 115 static float regenerated_radius_he[16], regenerated_radius_n2[16];
+ − 116 static float allowable_gradient_he[16], allowable_gradient_n2[16];
38
+ − 117
+ − 118 //_Bool deco_zone_reached;
290
+ − 119 static _Bool critical_volume_algorithm_off;
+ − 120 static float max_first_stop_depth;
+ − 121 static float max_deco_ceiling_depth;
38
+ − 122 //Boylslaw compensation
290
+ − 123 static float deco_gradient_he[16];
+ − 124 static float deco_gradient_n2[16];
+ − 125 static int vpm_calc_what;
+ − 126 static int count_critical_volume_iteration;
+ − 127 static short number_of_changes;
+ − 128 static float depth_change[11];
+ − 129 static float step_size_change[11];
+ − 130 static float rate_change[11];
+ − 131 static short mix_change[11];
38
+ − 132
290
+ − 133 static const _Bool vpm_b = true;
38
+ − 134
907
+ − 135 static SvpmTableState vpmTableState = VPM_TABLE_INIT;
902
+ − 136 static SDecoinfo vpmTable;
+ − 137
38
+ − 138 extern const float float_buehlmann_N2_factor_expositon_20_seconds[];
+ − 139 extern const float float_buehlmann_He_factor_expositon_20_seconds[];
+ − 140 extern const float float_buehlmann_N2_factor_expositon_one_minute[];
+ − 141 extern const float float_buehlmann_He_factor_expositon_one_minute[];
+ − 142 extern const float float_buehlmann_N2_factor_expositon_five_minutes[];
+ − 143 extern const float float_buehlmann_He_factor_expositon_five_minutes[];
+ − 144 extern const float float_buehlmann_N2_factor_expositon_one_hour[];
+ − 145 extern const float float_buehlmann_He_factor_expositon_one_hour[];
+ − 146
290
+ − 147 static float depth_start_of_deco_calc;
+ − 148 static float depth_start_of_deco_zone;
+ − 149 static float first_stop_depth;
+ − 150 static float run_time_start_of_deco_zone;
38
+ − 151
290
+ − 152 static float r_nint(float *x);
+ − 153 static float r_int(float *x);
+ − 154 static _Bool nullzeit_unter60;
+ − 155 static int vpm_calc_status;
+ − 156 static _Bool buehlmann_wait_exceeded = false;
38
+ − 157
290
+ − 158 static SLifeData* pInput = NULL;
+ − 159 static SVpm* pVpm = NULL;
+ − 160 static SDecoinfo* pDecoInfo = NULL;
+ − 161 static SDiveSettings* pDiveSettings = NULL;
+ − 162
+ − 163 static float r_nint(float *x)
38
+ − 164 {
+ − 165 return( (*x)>=0 ?
+ − 166 floorf(*x + 0.5f) : -floorf(0.5f - *x) );
+ − 167 }
+ − 168
290
+ − 169 static float r_int(float *x)
38
+ − 170 {
863
+ − 171 return( (*x>0.0) ? floorf(*x) : -floorf(- *x) );
38
+ − 172 }
+ − 173
+ − 174 /** private functions
+ − 175 */
290
+ − 176 extern int radius_root_finder (float *a, float *b, float *c,float *low_bound, float *high_bound, float *ending_radius);
38
+ − 177
290
+ − 178 static int nuclear_regeneration(float *dive_time);// clock_();
+ − 179 static int calc_deco_ceiling(float *deco_ceiling_depth,_Bool fallowablw);
+ − 180 static int critical_volume(float *deco_phase_volume_time); ;
+ − 181 static int calc_start_of_deco_zone(float *starting_depth, float *rate, float *depth_start_of_deco_zone);
+ − 182 static int calc_initial_allowable_gradient(void);
+ − 183 static void decompression_stop(float *deco_stop_depth, float *step_size, _Bool final_deco_calculation);
+ − 184 static int gas_loadings_ascent_descen(float* helium_pressure, float* nitrogen_pressure, float starting_depth,float ending_depth, float rate,_Bool check_gas_change);
+ − 185 static int calc_surface_phase_volume_time(void);
+ − 186 static int calc_max_actual_gradient(float *deco_stop_depth);
+ − 187 static int projected_ascent(float *starting_depth, float *rate, float *deco_stop_depth, float *step_size);
+ − 188 static void vpm_calc_deco(void);
+ − 189 static int vpm_calc_critcal_volume(_Bool begin,_Bool calc_nulltime);
+ − 190 static int vpm_check_converged(_Bool calc_nulltime);
+ − 191 static int vpm_calc_final_deco(_Bool begin);
+ − 192 static void BOYLES_LAW_COMPENSATION (float* First_Stop_Depth,float * Deco_Stop_Depth,float* Step_Size);
292
+ − 193 static int vpm_calc_ndl(void);
290
+ − 194 static void vpm_init_1(void);
+ − 195 static void vpm_calc_deco_ceiling(void);
38
+ − 196
907
+ − 197 uint8_t vpm_get_decozone(void);
+ − 198
290
+ − 199 static void vpm_init_1(void)
38
+ − 200 {
+ − 201 units_equal_msw = true;
+ − 202 units_equal_fsw = false;
+ − 203 altitude_dive_algorithm_off= true; //!Options: ON or OFF
+ − 204 minimum_deco_stop_time=1.0; //!Options: float positive number
+ − 205 critical_volume_algorithm_off= false; //!Options: ON or OFF
+ − 206 run_time = 0.;
+ − 207 //barometric_pressure = dive_data.surface * 10;
+ − 208
+ − 209 //mix_number = dive_data.selected_gas + 1;
+ − 210
+ − 211 max_first_stop_depth = 0;
+ − 212 max_deco_ceiling_depth = 0;
+ − 213 //deco_zone_reached = false;
+ − 214 depth_start_of_deco_calc = 0;
+ − 215 depth_start_of_deco_zone = 0;
+ − 216 first_stop_depth = 0;
+ − 217 run_time_start_of_deco_zone = 0;
+ − 218
+ − 219 gCNS_VPM = 0;
+ − 220 }
+ − 221
+ − 222 float vpm_get_CNS(void)
+ − 223 {
+ − 224 return gCNS_VPM;
+ − 225 }
+ − 226
902
+ − 227
+ − 228 void vpm_maintainTable(SLifeData* pLifeData,SDecoinfo* pDecoInfo)
+ − 229 {
+ − 230 static uint32_t lastDiveSecond = 0;
+ − 231 uint8_t actual_deco_stop = 0;
+ − 232 int8_t index = 0;
+ − 233 uint8_t decreaseStopTime = 1;
+ − 234
+ − 235 if(lastDiveSecond < pLifeData->dive_time_seconds)
+ − 236 {
+ − 237 lastDiveSecond = pLifeData->dive_time_seconds;
+ − 238 actual_deco_stop = decom_get_actual_deco_stop((SDiveState*)stateUsed);
+ − 239
+ − 240 pDecoInfo->output_time_to_surface_seconds = 0;
+ − 241 for(index = DECOINFO_STRUCT_MAX_STOPS -1 ;index >= 0; index--)
+ − 242 {
+ − 243 if(pDecoInfo->output_stop_length_seconds[index] > 0)
+ − 244 {
+ − 245 if(decreaseStopTime)
+ − 246 {
907
+ − 247 if((pLifeData->depth_meter > (float)(actual_deco_stop - 1.5))
902
+ − 248 && (pLifeData->depth_meter < (float)actual_deco_stop + 1.5))
+ − 249 {
+ − 250 pDecoInfo->output_stop_length_seconds[index]--;
+ − 251 decreaseStopTime = 0;
+ − 252 }
907
+ − 253 else if (pLifeData->depth_meter < (float)(actual_deco_stop - 1.5)) /* missed deco stop */
+ − 254 {
+ − 255 vpmTableState = VPM_TABLE_MISSED;
+ − 256 pDecoInfo->output_stop_length_seconds[index] = 0;
+ − 257 decreaseStopTime = 0;
+ − 258 }
902
+ − 259 }
+ − 260 pDecoInfo->output_time_to_surface_seconds += pDecoInfo->output_stop_length_seconds[index];
+ − 261 }
+ − 262 }
+ − 263 pDecoInfo->output_time_to_surface_seconds += pLifeData->depth_meter / 10.0 * 60.0;
+ − 264 }
+ − 265 else if(lastDiveSecond > pLifeData->dive_time_seconds)
+ − 266 {
+ − 267 lastDiveSecond = pLifeData->dive_time_seconds;
+ − 268 }
+ − 269 }
+ − 270
38
+ − 271 int vpm_calc(SLifeData* pINPUT,
+ − 272 SDiveSettings* pSettings,
+ − 273 SVpm* pVPM,
+ − 274 SDecoinfo*
+ − 275 pDECOINFO,
+ − 276 int calc_what)
+ − 277 {
902
+ − 278 static uint8_t vpmTableActive = 0;
+ − 279
38
+ − 280 vpm_init_1();
+ − 281 //decom_CreateGasChangeList(pSettings, pINPUT);
+ − 282 vpm_calc_what = calc_what;
+ − 283 /**clear decoInfo*/
902
+ − 284
+ − 285 if((vpmTableActive) && (vpm_calc_what == DECOSTOPS))
+ − 286 {
+ − 287 memcpy(&vpmTable, pDECOINFO, sizeof(SDecoinfo)); /* save changes done by e.g. the simulator */
+ − 288 }
38
+ − 289 pDECOINFO->output_time_to_surface_seconds = 0;
+ − 290 pDECOINFO->output_ndl_seconds = 0;
+ − 291 pDECOINFO->output_ceiling_meter = 0;
247
+ − 292 pDECOINFO->super_saturation = 0;
38
+ − 293 uint8_t tmp_calc_status;
+ − 294 for(int i=0;i<DECOINFO_STRUCT_MAX_STOPS;i++)
+ − 295 {
+ − 296 pDECOINFO->output_stop_length_seconds[i] = 0;
+ − 297 }
+ − 298
305
305f251cc981
bugfix, consistency: show deco/NDL really after 1 minute divetime
Jan Mulder <jlmulder@xs4all.nl>
diff
changeset
+ − 299 if(pINPUT->dive_time_seconds_without_surface_time < 60)
38
+ − 300 {
292
+ − 301 vpm_calc_status = CALC_NDL;
38
+ − 302 return vpm_calc_status;
+ − 303 }
+ − 304 pVpm = pVPM;
+ − 305 pInput = pINPUT;
+ − 306 pDecoInfo = pDECOINFO;
+ − 307 pDiveSettings = pSettings;
+ − 308
292
+ − 309 if(vpm_calc_status == CALC_NDL)
38
+ − 310 {
292
+ − 311 tmp_calc_status = vpm_calc_ndl();
38
+ − 312 }
+ − 313 else
+ − 314 {
+ − 315 tmp_calc_status = CALC_BEGIN;
+ − 316 }
+ − 317 //Normal Deco calculation
292
+ − 318 if(tmp_calc_status != CALC_NDL)
38
+ − 319 {
+ − 320 max_first_stop_depth = pVpm->max_first_stop_depth_save;
+ − 321 run_time_start_of_deco_zone = pVpm->run_time_start_of_deco_zone_save;
+ − 322 depth_start_of_deco_zone = pVpm->depth_start_of_deco_zone_save;
+ − 323 for (int i = 0; i < 16; ++i) {
+ − 324 helium_pressure[i] = pInput->tissue_helium_bar[i] * 10;
+ − 325 nitrogen_pressure[i] = pInput->tissue_nitrogen_bar[i] * 10;
+ − 326 }
+ − 327 vpm_calc_deco();
+ − 328 tmp_calc_status = vpm_calc_critcal_volume(true,false);
+ − 329 if(vpm_calc_what == DECOSTOPS)
+ − 330 {
+ − 331 pVpm->max_first_stop_depth_save = max_first_stop_depth;
+ − 332 pVpm->run_time_start_of_deco_zone_save = run_time_start_of_deco_zone;
+ − 333 pVpm->depth_start_of_deco_zone_save = depth_start_of_deco_zone;
+ − 334 }
+ − 335 }
+ − 336
+ − 337 //Only Decostops not futute stops
+ − 338 if(vpm_calc_what == DECOSTOPS)
902
+ − 339 {
38
+ − 340 vpm_calc_status = tmp_calc_status;
902
+ − 341 if(pSettings->vpm_tableMode) /* store the most conservative deco plan and stick to it. */
+ − 342 {
+ − 343 if((int16_t)(pDECOINFO->output_time_to_surface_seconds - vpmTable.output_time_to_surface_seconds) > 60)
+ − 344 {
+ − 345 memcpy(&vpmTable, pDECOINFO, sizeof(SDecoinfo));
+ − 346 vpmTableActive = 1;
907
+ − 347 if(pVpm->deco_zone_reached) /* table should not change after deco zone was entered */
+ − 348 {
+ − 349 if(vpmTableState != VPM_TABLE_MISSED)
+ − 350 {
+ − 351 vpmTableState = VPM_TABLE_WARNING;
+ − 352 }
+ − 353 }
902
+ − 354 }
+ − 355 else
+ − 356 {
+ − 357 if(vpmTable.output_time_to_surface_seconds > 0)
+ − 358 {
+ − 359 vpm_maintainTable(pINPUT, &vpmTable);
+ − 360 vpmTable.output_ceiling_meter = pDECOINFO->output_ceiling_meter;
+ − 361 memcpy(pDECOINFO, &vpmTable, sizeof(SDecoinfo));
+ − 362 }
+ − 363 }
+ − 364 }
+ − 365 }
38
+ − 366 return vpm_calc_status;
+ − 367 }
+ − 368
+ − 369 void vpm_saturation_after_ascent(SLifeData* input)
+ − 370 {
+ − 371 int i = 0;
+ − 372 for (i = 0; i < 16; ++i) {
+ − 373 pInput->tissue_helium_bar[i] = helium_pressure[i] / 10;
+ − 374 pInput->tissue_nitrogen_bar[i] = nitrogen_pressure[i] / 10;
+ − 375 }
+ − 376 pInput->pressure_ambient_bar = pInput->pressure_surface_bar;
+ − 377 }
+ − 378 /* =============================================================================== */
+ − 379 /* NOTE ABOUT PRESSURE UNITS USED IN CALCULATIONS: */
+ − 380 /* It is the convention in decompression calculations to compute all gas */
+ − 381 /* loadings, absolute pressures, partial pressures, etc., in the units of */
+ − 382 /* depth pressure that you are diving - either feet of seawater (fsw) or */
+ − 383 /* meters of seawater (msw). This program follows that convention with the */
+ − 384 /* the exception that all VPM calculations are performed in SI units (by */
+ − 385 /* necessity). Accordingly, there are several conversions back and forth */
+ − 386 /* between the diving pressure units and the SI units. */
+ − 387 /* =============================================================================== */
+ − 388 /* =============================================================================== */
+ − 389 /* FUNCTION SUBPROGRAM FOR GAS LOADING CALCULATIONS - ASCENT AND DESCENT */
+ − 390 /* =============================================================================== */
+ − 391
+ − 392
+ − 393
+ − 394 /* =============================================================================== */
+ − 395 /* SUBROUTINE GAS_LOADINGS_ASCENT_DESCENT */
+ − 396 /* Purpose: This subprogram applies the Schreiner equation to update the */
+ − 397 /* gas loadings (partial pressures of helium and nitrogen) in the half-time */
+ − 398 /* compartments due to a linear ascent or descent segment at a constant rate. */
+ − 399 /* =============================================================================== */
+ − 400
290
+ − 401 static int gas_loadings_ascent_descen(float* helium_pressure,
38
+ − 402 float* nitrogen_pressure,
+ − 403 float starting_depth,
+ − 404 float ending_depth,
+ − 405 float rate,_Bool check_gas_change)
+ − 406 {
+ − 407 short i;
+ − 408 float initial_inspired_n2_pressure,
+ − 409 initial_inspired_he_pressure, nitrogen_rate,
+ − 410 last_run_time,
+ − 411 starting_ambient_pressure,
+ − 412 ending_ambient_pressure;
+ − 413 float initial_helium_pressure[16];
+ − 414 float initial_nitrogen_pressure[16];
+ − 415 float helium_rate;
+ − 416 float fraction_helium_begin;
+ − 417 float fraction_helium_end;
+ − 418 float fraction_nitrogen_begin;
+ − 419 float fraction_nitrogen_end;
+ − 420 float ending_depth_tmp = ending_depth;
+ − 421 float segment_time_tmp = 0;
+ − 422 /* loop */
+ − 423 /* =============================================================================== */
+ − 424 /* CALCULATIONS */
+ − 425 /* =============================================================================== */
+ − 426 segment_time = (ending_depth_tmp - starting_depth) / rate;
+ − 427 last_run_time = run_time;
+ − 428 run_time = last_run_time + segment_time;
+ − 429 do {
+ − 430 ending_depth_tmp = ending_depth;
+ − 431 if (starting_depth > ending_depth && check_gas_change && number_of_changes > 1)
+ − 432 {
+ − 433 for (i = 1; i < number_of_changes; ++i)
+ − 434 {
+ − 435 if (depth_change[i] < starting_depth && depth_change[i] > ending_depth)
+ − 436 {
+ − 437 ending_depth_tmp = depth_change[i];
+ − 438 break;
+ − 439 }
+ − 440 }
+ − 441 for (i = 1; i < number_of_changes; ++i)
+ − 442 {
+ − 443 if (depth_change[i] >= starting_depth)
+ − 444 {
+ − 445 mix_number = mix_change[i];
+ − 446 }
+ − 447 }
+ − 448 }
+ − 449 segment_time_tmp = (ending_depth_tmp - starting_depth) / rate;
+ − 450 ending_ambient_pressure = ending_depth_tmp + barometric_pressure;
+ − 451 starting_ambient_pressure = starting_depth + barometric_pressure;
+ − 452 decom_get_inert_gases( starting_ambient_pressure / 10, (&pDiveSettings->decogaslist[mix_number]), &fraction_nitrogen_begin, &fraction_helium_begin );
+ − 453 decom_get_inert_gases( ending_ambient_pressure / 10, (&pDiveSettings->decogaslist[mix_number]), &fraction_nitrogen_end, &fraction_helium_end );
+ − 454
+ − 455 initial_inspired_he_pressure = (starting_ambient_pressure - WATER_VAPOR_PRESSURE) * fraction_helium_begin;
+ − 456 initial_inspired_n2_pressure = (starting_ambient_pressure - WATER_VAPOR_PRESSURE) * fraction_nitrogen_begin;
+ − 457 //helium_rate = *rate * fraction_helium[mix_number - 1];
+ − 458 helium_rate = ((ending_ambient_pressure - WATER_VAPOR_PRESSURE)* fraction_helium_end - initial_inspired_he_pressure)/segment_time_tmp;
+ − 459 //nitrogen_rate2 = *rate * fraction_nitrogen[mix_number - 1];
+ − 460 nitrogen_rate = ((ending_ambient_pressure - WATER_VAPOR_PRESSURE)* fraction_nitrogen_end - initial_inspired_n2_pressure)/segment_time_tmp;
+ − 461
+ − 462
+ − 463 decom_oxygen_calculate_cns_stage_SchreinerStyle(segment_time_tmp,&pDiveSettings->decogaslist[mix_number],starting_ambient_pressure/10,ending_ambient_pressure/10,&gCNS_VPM);
+ − 464 //if(fabs(nitrogen_rate - nitrogen_rate2) > 0.000001)
+ − 465 //return -2;
+ − 466 for (i = 1; i <= 16; ++i)
+ − 467 {
+ − 468 initial_helium_pressure[i - 1] = helium_pressure[i - 1];
+ − 469 initial_nitrogen_pressure[i - 1] = nitrogen_pressure[i - 1];
+ − 470 helium_pressure[i - 1] =
+ − 471 schreiner_equation__2(&initial_inspired_he_pressure,
+ − 472 &helium_rate,
+ − 473 &segment_time,
+ − 474 &HELIUM_TIME_CONSTANT[i - 1],
+ − 475 &initial_helium_pressure[i - 1]);
+ − 476 nitrogen_pressure[i - 1] =
+ − 477 schreiner_equation__2(&initial_inspired_n2_pressure,
+ − 478 &nitrogen_rate,
+ − 479 &segment_time,
+ − 480 &NITROGEN_TIME_CONSTANT[i - 1],
+ − 481 &initial_nitrogen_pressure[i - 1]);
+ − 482
+ − 483 //nextround???
+ − 484
+ − 485 }
+ − 486 starting_depth = ending_depth_tmp;
+ − 487 } while(ending_depth_tmp > ending_depth);
+ − 488
+ − 489 return 0;
+ − 490 } /* gas_loadings_ascent_descen */
+ − 491
290
+ − 492 static float last_phase_volume_time[16];
+ − 493 static float n2_pressure_start_of_deco_zone[16];
+ − 494 static float he_pressure_start_of_deco_zone[16];
+ − 495 static float phase_volume_time[16];
+ − 496 static float n2_pressure_start_of_ascent[16];
+ − 497 static float he_pressure_start_of_ascent[16];
+ − 498 static float run_time_start_of_deco_calc;
+ − 499 static float starting_depth;
+ − 500 static float last_run_time;
+ − 501 static float deco_phase_volume_time;
+ − 502 static float run_time_start_of_ascent;
+ − 503 static float rate;
+ − 504 static float step_size;
+ − 505 static _Bool vpm_violates_buehlmann;
38
+ − 506
290
+ − 507 static void vpm_calc_deco(void)
38
+ − 508 {
+ − 509 /* System generated locals */
+ − 510
+ − 511 //float deepest_possible_stop_depth;
+ − 512 // altitude_of_dive,
+ − 513 short i;
+ − 514 int j = 0;
+ − 515
+ − 516 // float rounding_operation;
+ − 517
+ − 518 /* =============================================================================== */
+ − 519 /* INPUT PARAMETERS TO BE USED FOR STAGED DECOMPRESSION AND SAVE IN ARRAYS. */
+ − 520 /* ASSIGN INITAL PARAMETERS TO BE USED AT START OF ASCENT */
+ − 521 /* The user has the ability to change mix, ascent rate, and step size in any */
+ − 522 /* combination at any depth during the ascent. */
+ − 523 /* =============================================================================== */
+ − 524
+ − 525 run_time = ((float)pInput->dive_time_seconds )/ 60;
+ − 526 count_critical_volume_iteration = 0;
+ − 527 number_of_changes = 1;
+ − 528
+ − 529 barometric_pressure = pInput->pressure_surface_bar * 10;
+ − 530 depth_change[0] =(pInput->pressure_ambient_bar - pInput->pressure_surface_bar)* 10;
+ − 531 mix_change[0] = 0;
+ − 532 rate_change[0 ] = -10;// neu 160215 hw, zuvor: -12;
+ − 533 step_size_change[0] = 3;
+ − 534 vpm_violates_buehlmann = false;
+ − 535
+ − 536 for (i = 1; i < BUEHLMANN_STRUCT_MAX_GASES; i++)
+ − 537 {
+ − 538 depth_change[i] = 0;
+ − 539 mix_change[i] = 0;
+ − 540 }
+ − 541 j = 0;
+ − 542
+ − 543 for (i = 1; i < BUEHLMANN_STRUCT_MAX_GASES; i++)
+ − 544 {
830
+ − 545 if((pDiveSettings->decogaslist[i].change_during_ascent_depth_meter_otherwise_zero >= depth_change[0] + 1)
973
+ − 546 #ifdef ENABLE_DECOCALC_OPTION
+ − 547 && (pDiveSettings->gas[pDiveSettings->decogaslist[i].GasIdInSettings].note.ub.decocalc)
+ − 548 #endif
+ − 549 )
38
+ − 550 continue;
+ − 551
830
+ − 552 if((pDiveSettings->decogaslist[i].change_during_ascent_depth_meter_otherwise_zero <= 0)
973
+ − 553 #ifdef ENABLE_DECOCALC_OPTION
+ − 554 || (pDiveSettings->gas[pDiveSettings->decogaslist[i].GasIdInSettings].note.ub.decocalc == 0)
+ − 555 #endif
+ − 556 )
38
+ − 557 break;
+ − 558
+ − 559 j++;
+ − 560 number_of_changes ++;
+ − 561 depth_change[j] = pDiveSettings->decogaslist[i].change_during_ascent_depth_meter_otherwise_zero ;
+ − 562 mix_change[j] = i;
+ − 563 rate_change[j] = -10;// neu 160215 hw, zuvor: -12;
+ − 564 step_size_change[j] = 3;
+ − 565 }
+ − 566
+ − 567 starting_depth = depth_change[0] ;
+ − 568 mix_number = mix_change[0] ;
+ − 569 rate = rate_change[0];
+ − 570 step_size = step_size_change[0];
+ − 571
+ − 572 for (i = 0; i < 16; ++i) {
+ − 573 he_pressure_start_of_ascent[i ] = helium_pressure[i];
+ − 574 n2_pressure_start_of_ascent[i] = nitrogen_pressure[i];
+ − 575 }
+ − 576 run_time_start_of_ascent = run_time;
+ − 577 if(starting_depth <= depth_start_of_deco_zone && vpm_calc_what == DECOSTOPS)
+ − 578 {
+ − 579 pVpm->deco_zone_reached = true;
+ − 580 depth_start_of_deco_calc = starting_depth;
+ − 581 critical_volume_algorithm_off = true;
+ − 582 }
+ − 583 else
+ − 584 {
+ − 585 //if(deco_zone_reached)
+ − 586 //{
+ − 587 pVpm->deco_zone_reached = false;
+ − 588 critical_volume_algorithm_off = false;
+ − 589 //max_first_stop_depth = 0;
+ − 590 //max_first_stop_depth_save = 0;
+ − 591 //}
+ − 592 /* =============================================================================== */
+ − 593 /* BEGIN PROCESS OF ASCENT AND DECOMPRESSION */
+ − 594 /* First, calculate the regeneration of critical radii that takes place over */
+ − 595 /* the dive time. The regeneration time constant has a time scale of weeks */
+ − 596 /* so this will have very little impact on dives of normal length, but will */
+ − 597 /* have major impact for saturation dives. */
+ − 598 /* =============================================================================== */
+ − 599
+ − 600 nuclear_regeneration(&run_time);
+ − 601
+ − 602 /* =============================================================================== */
+ − 603 /* CALCULATE INITIAL ALLOWABLE GRADIENTS FOR ASCENT */
+ − 604 /* This is based on the maximum effective crushing pressure on critical radii */
+ − 605 /* in each compartment achieved during the dive profile. */
+ − 606 /* =============================================================================== */
+ − 607
+ − 608 calc_initial_allowable_gradient();
+ − 609
+ − 610 /* =============================================================================== */
+ − 611 /* SAVE VARIABLES AT START OF ASCENT (END OF BOTTOM TIME) SINCE THESE WILL */
+ − 612 /* BE USED LATER TO COMPUTE THE FINAL ASCENT PROFILE THAT IS WRITTEN TO THE */
+ − 613 /* OUTPUT FILE. */
+ − 614 /* The VPM uses an iterative process to compute decompression schedules so */
+ − 615 /* there will be more than one pass through the decompression loop. */
+ − 616 /* =============================================================================== */
+ − 617
+ − 618 /* =============================================================================== */
+ − 619 /* CALCULATE THE DEPTH WHERE THE DECOMPRESSION ZONE BEGINS FOR THIS PROFILE */
+ − 620 /* BASED ON THE INITIAL ASCENT PARAMETERS AND WRITE THE DEEPEST POSSIBLE */
+ − 621 /* DECOMPRESSION STOP DEPTH TO THE OUTPUT FILE */
+ − 622 /* Knowing where the decompression zone starts is very important. Below */
+ − 623 /* that depth there is no possibility for bubble formation because there */
+ − 624 /* will be no supersaturation gradients. Deco stops should never start */
+ − 625 /* below the deco zone. The deepest possible stop deco stop depth is */
+ − 626 /* defined as the next "standard" stop depth above the point where the */
+ − 627 /* leading compartment enters the deco zone. Thus, the program will not */
+ − 628 /* base this calculation on step sizes larger than 10 fsw or 3 msw. The */
+ − 629 /* deepest possible stop depth is not used in the program, per se, rather */
+ − 630 /* it is information to tell the diver where to start putting on the brakes */
+ − 631 /* during ascent. This should be prominently displayed by any deco program. */
+ − 632 /* =============================================================================== */
+ − 633
+ − 634 calc_start_of_deco_zone(&starting_depth, &rate, &depth_start_of_deco_zone);
+ − 635 /* =============================================================================== */
+ − 636 /* TEMPORARILY ASCEND PROFILE TO THE START OF THE DECOMPRESSION ZONE, SAVE */
+ − 637 /* VARIABLES AT THIS POINT, AND INITIALIZE VARIABLES FOR CRITICAL VOLUME LOOP */
+ − 638 /* The iterative process of the VPM Critical Volume Algorithm will operate */
+ − 639 /* only in the decompression zone since it deals with excess gas volume */
+ − 640 /* released as a result of supersaturation gradients (not possible below the */
+ − 641 /* decompression zone). */
+ − 642 /* =============================================================================== */
+ − 643 gas_loadings_ascent_descen(helium_pressure,nitrogen_pressure, starting_depth, depth_start_of_deco_zone, rate, true);
+ − 644
+ − 645 run_time_start_of_deco_zone = run_time;
+ − 646 depth_start_of_deco_calc = depth_start_of_deco_zone;
+ − 647
+ − 648 for (i = 0; i < 16; ++i)
+ − 649 {
+ − 650 pVpm->max_actual_gradient[i] = 0.;
+ − 651 }
+ − 652 }
+ − 653
+ − 654 for (i = 0; i < 16; ++i)
+ − 655 {
+ − 656 surface_phase_volume_time[i] = 0.;
+ − 657 last_phase_volume_time[i] = 0.;
+ − 658 he_pressure_start_of_deco_zone[i] = helium_pressure[i];
+ − 659 n2_pressure_start_of_deco_zone[i] = nitrogen_pressure[i];
+ − 660 //pVpm->max_actual_gradient[i] = 0.;
+ − 661 }
+ − 662 run_time_start_of_deco_calc = run_time;
+ − 663 }
+ − 664 /* =============================================================================== */
+ − 665 /* START OF CRITICAL VOLUME LOOP */
+ − 666 /* This loop operates between Lines 50 and 100. If the Critical Volume */
+ − 667 /* Algorithm is toggled "off" in the program settings, there will only be */
+ − 668 /* one pass through this loop. Otherwise, there will be two or more passes */
+ − 669 /* through this loop until the deco schedule is "converged" - that is when a */
+ − 670 /* comparison between the phase volume time of the present iteration and the */
+ − 671 /* last iteration is less than or equal to one minute. This implies that */
+ − 672 /* the volume of released gas in the most recent iteration differs from the */
+ − 673 /* "critical" volume limit by an acceptably small amount. The critical */
+ − 674 /* volume limit is set by the Critical Volume Parameter Lambda in the program */
+ − 675 /* settings (default setting is 7500 fsw-min with adjustability range from */
+ − 676 /* from 6500 to 8300 fsw-min according to Bruce Wienke). */
+ − 677 /* =============================================================================== */
+ − 678 /* L50: */
+ − 679
290
+ − 680 static float deco_stop_depth;
+ − 681 static int vpm_calc_critcal_volume(_Bool begin,
38
+ − 682 _Bool calc_nulltime)
+ − 683 { /* loop will run continuous there is an exit stateme */
+ − 684
+ − 685 short i;
+ − 686
+ − 687 float rounding_operation2;
+ − 688 //float ending_depth;
+ − 689 float deco_ceiling_depth;
+ − 690
+ − 691 //float deco_time;
+ − 692 int count = 0;
+ − 693 _Bool first_stop;
+ − 694 int dp = 0;
+ − 695 float tissue_He_saturation[16];
+ − 696 float tissue_N2_saturation[16];
+ − 697 float vpm_buehlmann_safety_gradient = 1.0f - (((float)pDiveSettings->vpm_conservatism) / 40);
+ − 698 /* =============================================================================== */
+ − 699 /* CALCULATE CURRENT DECO CEILING BASED ON ALLOWABLE SUPERSATURATION */
+ − 700 /* GRADIENTS AND SET FIRST DECO STOP. CHECK TO MAKE SURE THAT SELECTED STEP */
+ − 701 /* SIZE WILL NOT ROUND UP FIRST STOP TO A DEPTH THAT IS BELOW THE DECO ZONE. */
+ − 702 /* =============================================================================== */
+ − 703 if(begin)
+ − 704 {
+ − 705 if(depth_start_of_deco_calc < max_first_stop_depth )
+ − 706 {
+ − 707 if(vpm_b)
+ − 708 {
+ − 709 BOYLES_LAW_COMPENSATION(&max_first_stop_depth, &depth_start_of_deco_calc, &step_size);
+ − 710 }
+ − 711 calc_deco_ceiling(&deco_ceiling_depth, false);
+ − 712 }
+ − 713 else
+ − 714 calc_deco_ceiling(&deco_ceiling_depth, true);
+ − 715
+ − 716
+ − 717 if (deco_ceiling_depth <= 0.0f) {
+ − 718 deco_stop_depth = 0.0f;
+ − 719 } else {
+ − 720 rounding_operation2 = deco_ceiling_depth / step_size + ( float)0.5f;
+ − 721 deco_stop_depth = r_nint(&rounding_operation2) * step_size;
+ − 722 }
+ − 723
+ − 724 // buehlmann safety
+ − 725 if(buehlmannSafety)
+ − 726 {
+ − 727 for (i = 0; i < 16; i++)
+ − 728 {
863
+ − 729 tissue_He_saturation[i] = helium_pressure[i] / 10.0;
+ − 730 tissue_N2_saturation[i] = nitrogen_pressure[i] / 10.0;
38
+ − 731 }
+ − 732
+ − 733 if(!decom_tissue_test_tolerance(tissue_N2_saturation, tissue_He_saturation, vpm_buehlmann_safety_gradient, (deco_stop_depth / 10.0f) + pInput->pressure_surface_bar))
+ − 734 {
+ − 735
+ − 736 vpm_violates_buehlmann = true;
+ − 737 do {
863
+ − 738 deco_stop_depth += 3.0;
38
+ − 739 } while (!decom_tissue_test_tolerance(tissue_N2_saturation, tissue_He_saturation, vpm_buehlmann_safety_gradient, (deco_stop_depth / 10.0f) + pInput->pressure_surface_bar));
+ − 740 }
+ − 741 }
+ − 742
+ − 743 /* =============================================================================== */
+ − 744 /* PERFORM A SEPARATE "PROJECTED ASCENT" OUTSIDE OF THE MAIN PROGRAM TO MAKE */
+ − 745 /* SURE THAT AN INCREASE IN GAS LOADINGS DURING ASCENT TO THE FIRST STOP WILL */
+ − 746 /* NOT CAUSE A VIOLATION OF THE DECO CEILING. IF SO, ADJUST THE FIRST STOP */
+ − 747 /* DEEPER BASED ON STEP SIZE UNTIL A SAFE ASCENT CAN BE MADE. */
+ − 748 /* Note: this situation is a possibility when ascending from extremely deep */
+ − 749 /* dives or due to an unusual gas mix selection. */
+ − 750 /* CHECK AGAIN TO MAKE SURE THAT ADJUSTED FIRST STOP WILL NOT BE BELOW THE */
+ − 751 /* DECO ZONE. */
+ − 752 /* =============================================================================== */
+ − 753 if (deco_stop_depth < depth_start_of_deco_calc)
+ − 754 {
+ − 755 projected_ascent(&depth_start_of_deco_calc, &rate, &deco_stop_depth, &step_size);
+ − 756 }
+ − 757
+ − 758 /*if (deco_stop_depth > depth_start_of_deco_zone) {
+ − 759 printf("\t\n");
+ − 760 printf(fmt_905);
+ − 761 printf(fmt_900);
+ − 762 printf("\nPROGRAM TERMINATED\n");
+ − 763 exit(1);
+ − 764 }*/
+ − 765
+ − 766 /* =============================================================================== */
+ − 767 /* HANDLE THE SPECIAL CASE WHEN NO DECO STOPS ARE REQUIRED - ASCENT CAN BE */
+ − 768 /* MADE DIRECTLY TO THE SURFACE */
+ − 769 /* Write ascent data to output file and exit the Critical Volume Loop. */
+ − 770 /* =============================================================================== */
+ − 771
+ − 772 if (deco_stop_depth == 0.0f)
+ − 773 {
+ − 774 if(calc_nulltime)
+ − 775 {
+ − 776 return CALC_END;
+ − 777 }
+ − 778 if(pVpm->deco_zone_reached)
+ − 779 {
+ − 780 for(dp = 0;dp < DECOINFO_STRUCT_MAX_STOPS;dp++)
+ − 781 {
+ − 782 pDecoInfo->output_stop_length_seconds[dp] = 0;
+ − 783 }
+ − 784 pDecoInfo->output_ndl_seconds = 0;
+ − 785 }
+ − 786
292
+ − 787 return CALC_NDL;
38
+ − 788 /* exit the critical volume l */
+ − 789 }
+ − 790
+ − 791 /* =============================================================================== */
+ − 792 /* ASSIGN VARIABLES FOR ASCENT FROM START OF DECO ZONE TO FIRST STOP. SAVE */
+ − 793 /* FIRST STOP DEPTH FOR LATER USE WHEN COMPUTING THE FINAL ASCENT PROFILE */
+ − 794 /* =============================================================================== */
877
+ − 795 deco_stop_depth = fmaxf(deco_stop_depth,(float)pDiveSettings->last_stop_depth_bar * 10);
38
+ − 796 starting_depth = depth_start_of_deco_calc;
+ − 797 first_stop_depth = deco_stop_depth;
+ − 798 first_stop = true;
+ − 799 }
+ − 800 /* =============================================================================== */
+ − 801 /* DECO STOP LOOP BLOCK WITHIN CRITICAL VOLUME LOOP */
+ − 802 /* This loop computes a decompression schedule to the surface during each */
+ − 803 /* iteration of the critical volume loop. No output is written from this */
+ − 804 /* loop, rather it computes a schedule from which the in-water portion of the */
+ − 805 /* total phase volume time (Deco_Phase_Volume_Time) can be extracted. Also, */
+ − 806 /* the gas loadings computed at the end of this loop are used the subroutine */
+ − 807 /* which computes the out-of-water portion of the total phase volume time */
+ − 808 /* (Surface_Phase_Volume_Time) for that schedule. */
+ − 809
+ − 810 /* Note that exit is made from the loop after last ascent is made to a deco */
+ − 811 /* stop depth that is less than or equal to zero. A final deco stop less */
+ − 812 /* than zero can happen when the user makes an odd step size change during */
+ − 813 /* ascent - such as specifying a 5 msw step size change at the 3 msw stop! */
+ − 814 /* =============================================================================== */
+ − 815
+ − 816 while(true) /* loop will run continuous there is an break statement */
+ − 817 {
+ − 818 if(starting_depth > deco_stop_depth )
+ − 819 gas_loadings_ascent_descen(helium_pressure, nitrogen_pressure, starting_depth, deco_stop_depth, rate,first_stop);
+ − 820
+ − 821 first_stop = false;
+ − 822 if (deco_stop_depth <= 0.0f)
+ − 823 {
+ − 824 break;
+ − 825 }
+ − 826 if (number_of_changes > 1)
+ − 827 {
+ − 828 int i1 = number_of_changes;
+ − 829 for (i = 2; i <= i1; ++i) {
+ − 830 if (depth_change[i - 1] >= deco_stop_depth)
+ − 831 {
+ − 832 mix_number = mix_change[i - 1];
+ − 833 rate = rate_change[i - 1];
+ − 834 step_size = step_size_change[i - 1];
+ − 835 }
+ − 836 }
+ − 837 }
+ − 838 if(vpm_b)
+ − 839 {
+ − 840 float fist_stop_depth2 = fmaxf(first_stop_depth,max_first_stop_depth);
+ − 841 BOYLES_LAW_COMPENSATION(&fist_stop_depth2, &deco_stop_depth, &step_size);
+ − 842 }
+ − 843 decompression_stop(&deco_stop_depth, &step_size, false);
+ − 844 starting_depth = deco_stop_depth;
+ − 845
877
+ − 846 if(deco_stop_depth == (float)pDiveSettings->last_stop_depth_bar * 10)
38
+ − 847 deco_stop_depth = 0;
+ − 848 else
+ − 849 {
+ − 850 deco_stop_depth = deco_stop_depth - step_size;
877
+ − 851 deco_stop_depth = fmaxf(deco_stop_depth,(float)pDiveSettings->last_stop_depth_bar * 10);
38
+ − 852 }
+ − 853
+ − 854 count++;
+ − 855 //if(count > 14)
+ − 856 //return CALC_CRITICAL2;
+ − 857 /* L60: */
+ − 858 }
+ − 859
+ − 860 return vpm_check_converged(calc_nulltime);
+ − 861 }
+ − 862 /* =============================================================================== */
+ − 863 /* COMPUTE TOTAL PHASE VOLUME TIME AND MAKE CRITICAL VOLUME COMPARISON */
+ − 864 /* The deco phase volume time is computed from the run time. The surface */
+ − 865 /* phase volume time is computed in a subroutine based on the surfacing gas */
+ − 866 /* loadings from previous deco loop block. Next the total phase volume time */
+ − 867 /* (in-water + surface) for each compartment is compared against the previous */
+ − 868 /* total phase volume time. The schedule is converged when the difference is */
+ − 869 /* less than or equal to 1 minute in any one of the 16 compartments. */
+ − 870
+ − 871 /* Note: the "phase volume time" is somewhat of a mathematical concept. */
+ − 872 /* It is the time divided out of a total integration of supersaturation */
+ − 873 /* gradient x time (in-water and surface). This integration is multiplied */
+ − 874 /* by the excess bubble number to represent the amount of free-gas released */
+ − 875 /* as a result of allowing a certain number of excess bubbles to form. */
+ − 876 /* =============================================================================== */
+ − 877 /* end of deco stop loop */
+ − 878
290
+ − 879 static int vpm_check_converged(_Bool calc_nulltime)
38
+ − 880 {
+ − 881
+ − 882 short i;
+ − 883 float critical_volume_comparison;
+ − 884 float r1;
+ − 885 _Bool schedule_converged = false;
+ − 886
+ − 887
+ − 888 deco_phase_volume_time = run_time - run_time_start_of_deco_zone;
+ − 889 calc_surface_phase_volume_time();
+ − 890
+ − 891 for (i = 1; i <= 16; ++i)
+ − 892 {
+ − 893 phase_volume_time[i - 1] =
+ − 894 deco_phase_volume_time + surface_phase_volume_time[i - 1];
+ − 895 critical_volume_comparison = (r1 = phase_volume_time[i - 1] - last_phase_volume_time[i - 1], fabs(r1));
+ − 896
+ − 897 if (critical_volume_comparison <= 1.0f)
+ − 898 {
+ − 899 schedule_converged = true;
+ − 900 }
+ − 901 }
+ − 902
+ − 903 /* =============================================================================== */
+ − 904 /* CRITICAL VOLUME DECISION TREE BETWEEN LINES 70 AND 99 */
+ − 905 /* There are two options here. If the Critical Volume Agorithm setting is */
+ − 906 /* "on" and the schedule is converged, or the Critical Volume Algorithm */
+ − 907 /* setting was "off" in the first place, the program will re-assign variables */
+ − 908 /* to their values at the start of ascent (end of bottom time) and process */
+ − 909 /* a complete decompression schedule once again using all the same ascent */
+ − 910 /* parameters and first stop depth. This decompression schedule will match */
+ − 911 /* the last iteration of the Critical Volume Loop and the program will write */
+ − 912 /* the final deco schedule to the output file. */
+ − 913
+ − 914 /* Note: if the Critical Volume Agorithm setting was "off", the final deco */
+ − 915 /* schedule will be based on "Initial Allowable Supersaturation Gradients." */
+ − 916 /* If it was "on", the final schedule will be based on "Adjusted Allowable */
+ − 917 /* Supersaturation Gradients" (gradients that are "relaxed" as a result of */
+ − 918 /* the Critical Volume Algorithm). */
+ − 919
+ − 920 /* If the Critical Volume Agorithm setting is "on" and the schedule is not */
+ − 921 /* converged, the program will re-assign variables to their values at the */
+ − 922 /* start of the deco zone and process another trial decompression schedule. */
+ − 923 /* =============================================================================== */
+ − 924 /* L70: */
+ − 925 //Not more than 4 iteration allowed
+ − 926 count_critical_volume_iteration++;
+ − 927 if(count_critical_volume_iteration > 4)
+ − 928 {
+ − 929 //return CALC_FINAL_DECO;
+ − 930 if(calc_nulltime)
+ − 931 return CALC_FINAL_DECO;
+ − 932 else
+ − 933 return vpm_calc_final_deco(true);
+ − 934 }
+ − 935 if (schedule_converged || critical_volume_algorithm_off)
+ − 936 {
+ − 937
+ − 938 //return CALC_FINAL_DECO;
+ − 939 if(calc_nulltime)
+ − 940 return CALC_FINAL_DECO;
+ − 941 else
+ − 942 return vpm_calc_final_deco(true);
+ − 943 /* final deco schedule */
+ − 944 /* exit critical volume l */
+ − 945
+ − 946 /* =============================================================================== */
+ − 947 /* IF SCHEDULE NOT CONVERGED, COMPUTE RELAXED ALLOWABLE SUPERSATURATION */
+ − 948 /* GRADIENTS WITH VPM CRITICAL VOLUME ALGORITHM AND PROCESS ANOTHER */
+ − 949 /* ITERATION OF THE CRITICAL VOLUME LOOP */
+ − 950 /* =============================================================================== */
+ − 951
+ − 952 } else {
+ − 953 critical_volume(&deco_phase_volume_time);
+ − 954 deco_phase_volume_time = 0.;
+ − 955 run_time = run_time_start_of_deco_calc;
+ − 956 starting_depth = depth_start_of_deco_calc;
+ − 957 mix_number = mix_change[0];
+ − 958 rate = rate_change[0];
+ − 959 step_size = step_size_change[0];
+ − 960 for (i = 1; i <= 16; ++i)
+ − 961 {
+ − 962 last_phase_volume_time[i - 1] = phase_volume_time[i - 1];
+ − 963 helium_pressure[i - 1] = he_pressure_start_of_deco_zone[i - 1];
+ − 964 nitrogen_pressure[i - 1] = n2_pressure_start_of_deco_zone[i - 1];
+ − 965 }
+ − 966 if(calc_nulltime)
+ − 967 return CALC_CRITICAL;
+ − 968 else
+ − 969 return vpm_calc_critcal_volume(true, false);
+ − 970 }
+ − 971 /* end of critical volume decision */
+ − 972 /* L100: */
+ − 973 // }/* end of critical vol loop */
+ − 974 }
+ − 975
290
+ − 976 static void vpm_calc_deco_ceiling(void)
38
+ − 977 {
+ − 978
+ − 979 short i;
+ − 980 // hw 1601209 float r1;
+ − 981 // hw 1601209 float stop_time;
+ − 982 // hw 1601209 int count = 0;
+ − 983 //static int dp_max;
+ − 984 //static float surfacetime;
+ − 985 // _Bool first_stop = false;
+ − 986 float tissue_He_saturation[16];
+ − 987 float tissue_N2_saturation[16];
877
+ − 988 float vpm_buehlmann_safety_gradient = 1.0f - (((float)pDiveSettings->vpm_conservatism) / 40);
38
+ − 989 //max_first_stop_depth = fmaxf(first_stop_depth,max_first_stop_depth);
+ − 990
+ − 991 /** CALC DECO Ceiling ******************************************************************/
+ − 992 /** Not when Future stops */
+ − 993 if(vpm_calc_what == DECOSTOPS)
+ − 994 {
+ − 995
+ − 996 for (i = 1; i <= 16; ++i)
+ − 997 {
+ − 998 helium_pressure[i - 1] = he_pressure_start_of_deco_zone[i - 1];
+ − 999 nitrogen_pressure[i - 1] = n2_pressure_start_of_deco_zone[i - 1];
+ − 1000 }
+ − 1001 run_time = run_time_start_of_ascent;// run_time_start_of_ascent;
+ − 1002 starting_depth = depth_change[0];
+ − 1003 mix_number = mix_change[0];
+ − 1004 rate = rate_change[0];
+ − 1005 //gas_loadings_ascent_descen(helium_pressure,nitrogen_pressure, starting_depth, depth_start_of_deco_calc, rate, true);
+ − 1006
+ − 1007 float deco_ceiling_depth = 0.0f;
+ − 1008 if(depth_start_of_deco_calc > max_deco_ceiling_depth)
+ − 1009 {
+ − 1010 calc_deco_ceiling(&deco_ceiling_depth, true);
+ − 1011 }
+ − 1012 if(buehlmannSafety)
+ − 1013 {
+ − 1014 for (i = 0; i < 16; i++)
+ − 1015 {
863
+ − 1016 tissue_He_saturation[i] = helium_pressure[i] / 10.0;
+ − 1017 tissue_N2_saturation[i] = nitrogen_pressure[i] / 10.0;
38
+ − 1018 }
+ − 1019
+ − 1020 if(!decom_tissue_test_tolerance(tissue_N2_saturation, tissue_He_saturation, vpm_buehlmann_safety_gradient, (deco_ceiling_depth / 10.0f) + pInput->pressure_surface_bar))
+ − 1021 {
+ − 1022 vpm_violates_buehlmann = true;
+ − 1023 do {
+ − 1024 deco_ceiling_depth += 0.1f;
+ − 1025 } while (!decom_tissue_test_tolerance(tissue_N2_saturation, tissue_He_saturation, vpm_buehlmann_safety_gradient, (deco_ceiling_depth / 10.0f) + pInput->pressure_surface_bar));
+ − 1026 }
+ − 1027 }
+ − 1028
+ − 1029 if (deco_ceiling_depth < depth_start_of_deco_calc)
+ − 1030 {
+ − 1031 projected_ascent(&depth_start_of_deco_calc, &rate, &deco_ceiling_depth, &step_size);
+ − 1032 }
+ − 1033
+ − 1034 max_deco_ceiling_depth = fmaxf(max_deco_ceiling_depth,deco_ceiling_depth);
+ − 1035
+ − 1036 if(depth_start_of_deco_calc > deco_ceiling_depth)
+ − 1037 {
+ − 1038 gas_loadings_ascent_descen(helium_pressure,nitrogen_pressure, depth_start_of_deco_calc,deco_ceiling_depth, rate, true);
+ − 1039 //surfacetime += segment_time;
+ − 1040 }
+ − 1041
+ − 1042 if(vpm_b)
+ − 1043 {
+ − 1044 BOYLES_LAW_COMPENSATION(&max_deco_ceiling_depth, &deco_ceiling_depth, &step_size);
+ − 1045 }
+ − 1046 calc_deco_ceiling(&deco_ceiling_depth, false);
+ − 1047
+ − 1048 // buehlmann safety
+ − 1049 if(vpm_violates_buehlmann)
+ − 1050 {
+ − 1051 for (i = 0; i < 16; i++)
+ − 1052 {
863
+ − 1053 tissue_He_saturation[i] = helium_pressure[i] / 10.0;
+ − 1054 tissue_N2_saturation[i] = nitrogen_pressure[i] / 10.0;
38
+ − 1055 }
+ − 1056
+ − 1057 if(!decom_tissue_test_tolerance(tissue_N2_saturation, tissue_He_saturation, vpm_buehlmann_safety_gradient, (deco_ceiling_depth / 10.0f) + pInput->pressure_surface_bar))
+ − 1058 {
+ − 1059 vpm_violates_buehlmann = true;
+ − 1060 do {
+ − 1061 deco_ceiling_depth += 0.1f;
+ − 1062 } while (!decom_tissue_test_tolerance(tissue_N2_saturation, tissue_He_saturation, vpm_buehlmann_safety_gradient, (deco_ceiling_depth / 10.0f) + pInput->pressure_surface_bar));
+ − 1063 }
+ − 1064 }
+ − 1065 // output_ceiling_meter
+ − 1066 if(deco_ceiling_depth > first_stop_depth)
+ − 1067 deco_ceiling_depth = first_stop_depth;
+ − 1068 pDecoInfo->output_ceiling_meter = deco_ceiling_depth ;
+ − 1069 }
+ − 1070 else
+ − 1071 {
863
+ − 1072 pDecoInfo->output_ceiling_meter = 0.0;
38
+ − 1073 }
+ − 1074
+ − 1075 // fix hw 160627
863
+ − 1076 if(pDecoInfo->output_ceiling_meter < 0.0)
+ − 1077 pDecoInfo->output_ceiling_meter = 0.0;
38
+ − 1078
+ − 1079 /*** End CALC ceiling ***************************************************/
+ − 1080 }
+ − 1081
+ − 1082
+ − 1083 /* =============================================================================== */
+ − 1084 /* DECO STOP LOOP BLOCK FOR FINAL DECOMPRESSION SCHEDULE */
+ − 1085 /* =============================================================================== */
+ − 1086
290
+ − 1087 static int vpm_calc_final_deco(_Bool begin)
38
+ − 1088 {
+ − 1089 short i;
+ − 1090 float r1;
+ − 1091 float stop_time;
+ − 1092 int count = 0;
+ − 1093 static int dp_max;
+ − 1094 static float surfacetime;
+ − 1095 _Bool first_stop = false;
902
+ − 1096 float roundingValue = 0.0;
863
+ − 1097
902
+ − 1098 uint16_t stop_time_seconds;
863
+ − 1099
38
+ − 1100 max_first_stop_depth = fmaxf(first_stop_depth,max_first_stop_depth);
+ − 1101 if(begin)
+ − 1102 {
+ − 1103 gCNS_VPM = 0;
+ − 1104 dp_max = 0;
+ − 1105 for (i = 1; i <= 16; ++i)
+ − 1106 {
+ − 1107 helium_pressure[i - 1] =
+ − 1108 he_pressure_start_of_ascent[i - 1];
+ − 1109 nitrogen_pressure[i - 1] =
+ − 1110 n2_pressure_start_of_ascent[i - 1];
+ − 1111 }
+ − 1112 run_time = run_time_start_of_ascent;// run_time_start_of_ascent;
+ − 1113 starting_depth = depth_change[0];
+ − 1114 mix_number = mix_change[0];
+ − 1115 rate = rate_change[0];
+ − 1116 step_size = step_size_change[0];
+ − 1117 deco_stop_depth = first_stop_depth;
+ − 1118 max_first_stop_depth = fmaxf(first_stop_depth,max_first_stop_depth);
+ − 1119 last_run_time = 0.;
+ − 1120
+ − 1121
+ − 1122
+ − 1123 /* =============================================================================== */
+ − 1124 /* DECO STOP LOOP BLOCK FOR FINAL DECOMPRESSION SCHEDULE */
+ − 1125 /* =============================================================================== */
+ − 1126 surfacetime = 0;
+ − 1127 first_stop = true;
+ − 1128 }
+ − 1129
+ − 1130 while(true) /* loop will run continuous until there is an break statement */
+ − 1131 {
+ − 1132 if(starting_depth > deco_stop_depth)
+ − 1133 {
+ − 1134 gas_loadings_ascent_descen(helium_pressure,nitrogen_pressure, starting_depth,deco_stop_depth, rate, first_stop);
+ − 1135 surfacetime += segment_time;
+ − 1136 }
+ − 1137
+ − 1138 /* =============================================================================== */
+ − 1139 /* DURING FINAL DECOMPRESSION SCHEDULE PROCESS, COMPUTE MAXIMUM ACTUAL */
+ − 1140 /* SUPERSATURATION GRADIENT RESULTING IN EACH COMPARTMENT */
+ − 1141 /* If there is a repetitive dive, this will be used later in the VPM */
+ − 1142 /* Repetitive Algorithm to adjust the values for critical radii. */
+ − 1143 /* =============================================================================== */
+ − 1144 if(vpm_calc_what == DECOSTOPS)
+ − 1145 calc_max_actual_gradient(&deco_stop_depth);
+ − 1146
+ − 1147 if (deco_stop_depth <= 0.0f) {
+ − 1148 break;
+ − 1149 }
+ − 1150 if (number_of_changes > 1)
+ − 1151 {
+ − 1152 int i1 = number_of_changes;
+ − 1153 for (i = 2; i <= i1; ++i)
+ − 1154 {
+ − 1155 if (depth_change[i - 1] >= deco_stop_depth)
+ − 1156 {
+ − 1157 mix_number = mix_change[i - 1];
+ − 1158 rate = rate_change[i - 1];
+ − 1159 step_size = step_size_change[i - 1];
+ − 1160 }
+ − 1161 }
+ − 1162 }
+ − 1163
+ − 1164 if(first_stop)
+ − 1165 {
+ − 1166 run_time_first_stop = run_time;
+ − 1167 first_stop = false;
+ − 1168 }
+ − 1169 if(vpm_b)
+ − 1170 {
+ − 1171 BOYLES_LAW_COMPENSATION(&max_first_stop_depth, &deco_stop_depth, &step_size);
+ − 1172 }
+ − 1173 decompression_stop(&deco_stop_depth, &step_size, true);
+ − 1174
+ − 1175 /* =============================================================================== */
+ − 1176 /* This next bit justs rounds up the stop time at the first stop to be in */
+ − 1177 /* whole increments of the minimum stop time (to make for a nice deco table). */
+ − 1178 /* =============================================================================== */
+ − 1179
+ − 1180 if (last_run_time == 0.0f)
+ − 1181 {
+ − 1182 r1 = segment_time / minimum_deco_stop_time + 0.5f;
+ − 1183 stop_time = r_int(&r1) * minimum_deco_stop_time;
+ − 1184 } else {
+ − 1185 stop_time = run_time - last_run_time;
+ − 1186 }
+ − 1187 stop_time = segment_time;
+ − 1188 surfacetime += stop_time;
+ − 1189 if((vpm_calc_what == DECOSTOPS) || (vpm_calc_what == BAILOUTSTOPS))
+ − 1190 {
+ − 1191 int dp = 0;
+ − 1192 if(deco_stop_depth == (float)pDiveSettings->last_stop_depth_bar * 10)
+ − 1193 {
+ − 1194 dp = 0;
+ − 1195 }
+ − 1196 else
+ − 1197 {
902
+ − 1198 roundingValue = (deco_stop_depth - (pDiveSettings->input_second_to_last_stop_depth_bar * 10.0)) / step_size;
+ − 1199 dp = 1 + r_nint(&roundingValue);
38
+ − 1200 }
863
+ − 1201
+ − 1202 //dp_max = (int)fmaxf(dp_max,dp);
+ − 1203 if(dp > dp_max)
+ − 1204 {
+ − 1205 dp_max = dp;
+ − 1206 }
38
+ − 1207 if(dp < DECOINFO_STRUCT_MAX_STOPS)
+ − 1208 {
902
+ − 1209 stop_time_seconds = (uint16_t)(fminf((999.9 * 60.0), (stop_time *60.0)));
38
+ − 1210 //
+ − 1211
+ − 1212 //if(vpm_calc_what == DECOSTOPS)
863
+ − 1213 pDecoInfo->output_stop_length_seconds[dp] = stop_time_seconds;
38
+ − 1214 //else
+ − 1215 //decostop_bailout[dp] = (unsigned short)stop_time_seconds;
+ − 1216 }
+ − 1217 }
+ − 1218
+ − 1219
+ − 1220 /* =============================================================================== */
+ − 1221 /* DURING FINAL DECOMPRESSION SCHEDULE, IF MINIMUM STOP TIME PARAMETER IS A */
+ − 1222 /* WHOLE NUMBER (i.e. 1 minute) THEN WRITE DECO SCHEDULE USING short */
+ − 1223 /* NUMBERS (looks nicer). OTHERWISE, USE DECIMAL NUMBERS. */
+ − 1224 /* Note: per the request of a noted exploration diver(!), program now allows */
+ − 1225 /* a minimum stop time of less than one minute so that total ascent time can */
+ − 1226 /* be minimized on very long dives. In fact, with step size set at 1 fsw or */
+ − 1227 /* 0.2 msw and minimum stop time set at 0.1 minute (6 seconds), a near */
+ − 1228 /* continuous decompression schedule can be computed. */
+ − 1229 /* =============================================================================== */
+ − 1230
+ − 1231 starting_depth = deco_stop_depth;
877
+ − 1232 if(deco_stop_depth == (float)pDiveSettings->last_stop_depth_bar * 10)
+ − 1233 deco_stop_depth = 0;
38
+ − 1234 else
+ − 1235 {
+ − 1236 deco_stop_depth = deco_stop_depth - step_size;
877
+ − 1237 deco_stop_depth = fmaxf(deco_stop_depth,(float)pDiveSettings->last_stop_depth_bar * 10);
38
+ − 1238 }
+ − 1239
+ − 1240 last_run_time = run_time;
+ − 1241 count++;
+ − 1242 //if(count > 14)
+ − 1243 //return CALC_FINAL_DECO2;
+ − 1244 /* L80: */
+ − 1245 } /* for final deco sche */
+ − 1246
+ − 1247 if( (vpm_calc_what == DECOSTOPS) || (vpm_calc_what == BAILOUTSTOPS))
+ − 1248 {
+ − 1249 for(int dp = dp_max +1;dp < DECOINFO_STRUCT_MAX_STOPS;dp++)
+ − 1250 {
+ − 1251 //if(vpm_calc_what == DECOSTOPS)
+ − 1252 pDecoInfo->output_stop_length_seconds[dp] = 0;
+ − 1253 //else
+ − 1254 //decostop_bailout[dp] = 0;
+ − 1255 }
+ − 1256 }
863
+ − 1257 pDecoInfo->output_time_to_surface_seconds = (int)(surfacetime * 60.0);
38
+ − 1258 pDecoInfo->output_ndl_seconds = 0;
+ − 1259
+ − 1260 vpm_calc_deco_ceiling();
+ − 1261 /* end of deco stop lo */
+ − 1262 return CALC_END;
+ − 1263 }
+ − 1264
+ − 1265 /* =============================================================================== */
+ − 1266 /* SUBROUTINE NUCLEAR_REGENERATION */
+ − 1267 /* Purpose: This subprogram calculates the regeneration of VPM critical */
+ − 1268 /* radii that takes place over the dive time. The regeneration time constant */
+ − 1269 /* has a time scale of weeks so this will have very little impact on dives of */
+ − 1270 /* normal length, but will have a major impact for saturation dives. */
+ − 1271 /* =============================================================================== */
+ − 1272
290
+ − 1273 static int nuclear_regeneration(float *dive_time)
38
+ − 1274 {
+ − 1275 /* Local variables */
+ − 1276 float crush_pressure_adjust_ratio_he,
+ − 1277 ending_radius_n2,
+ − 1278 ending_radius_he;
+ − 1279 short i;
+ − 1280 float crushing_pressure_pascals_n2,
+ − 1281 crushing_pressure_pascals_he,
+ − 1282 adj_crush_pressure_n2_pascals,
+ − 1283 adj_crush_pressure_he_pascals,
+ − 1284 crush_pressure_adjust_ratio_n2;
+ − 1285
+ − 1286 /* loop */
+ − 1287 /* =============================================================================== */
+ − 1288 /* CALCULATIONS */
+ − 1289 /* First convert the maximum crushing pressure obtained for each compartment */
+ − 1290 /* to Pascals. Next, compute the ending radius for helium and nitrogen */
+ − 1291 /* critical nuclei in each compartment. */
+ − 1292 /* =============================================================================== */
+ − 1293
+ − 1294 for (i = 1; i <= 16; ++i)
+ − 1295 {
+ − 1296 crushing_pressure_pascals_he =
+ − 1297 pVpm->max_crushing_pressure_he[i - 1] / UNITS_FACTOR * 101325.0f;
+ − 1298 crushing_pressure_pascals_n2 =
+ − 1299 pVpm->max_crushing_pressure_n2[i - 1] / UNITS_FACTOR * 101325.0f;
+ − 1300 ending_radius_he =
+ − 1301 1.0f / (crushing_pressure_pascals_he /
+ − 1302 ((SKIN_COMPRESSION_GAMMAC - SURFACE_TENSION_GAMMA) * 2.0f) +
+ − 1303 1.0f / pVpm->adjusted_critical_radius_he[i - 1]);
+ − 1304 ending_radius_n2 =
+ − 1305 1.0f / (crushing_pressure_pascals_n2 /
+ − 1306 ((SKIN_COMPRESSION_GAMMAC - SURFACE_TENSION_GAMMA) * 2.0f) +
+ − 1307 1.0f / pVpm->adjusted_critical_radius_n2[i - 1]);
+ − 1308
+ − 1309 /* =============================================================================== */
+ − 1310 /* A "regenerated" radius for each nucleus is now calculated based on the */
+ − 1311 /* regeneration time constant. This means that after application of */
+ − 1312 /* crushing pressure and reduction in radius, a nucleus will slowly grow */
+ − 1313 /* back to its original initial radius over a period of time. This */
+ − 1314 /* phenomenon is probabilistic in nature and depends on absolute temperature. */
+ − 1315 /* It is independent of crushing pressure. */
+ − 1316 /* =============================================================================== */
+ − 1317
+ − 1318 regenerated_radius_he[i - 1] =
+ − 1319 pVpm->adjusted_critical_radius_he[i - 1] +
+ − 1320 (ending_radius_he - pVpm->adjusted_critical_radius_he[i - 1]) *
+ − 1321 expf(-(*dive_time) / REGENERATION_TIME_CONSTANT);
+ − 1322 regenerated_radius_n2[i - 1] =
+ − 1323 pVpm->adjusted_critical_radius_n2[i - 1] +
+ − 1324 (ending_radius_n2 - pVpm->adjusted_critical_radius_n2[i - 1]) *
+ − 1325 expf(-(*dive_time) / REGENERATION_TIME_CONSTANT);
+ − 1326
+ − 1327 /* =============================================================================== */
+ − 1328 /* In order to preserve reference back to the initial critical radii after */
+ − 1329 /* regeneration, an "adjusted crushing pressure" for the nuclei in each */
+ − 1330 /* compartment must be computed. In other words, this is the value of */
+ − 1331 /* crushing pressure that would have reduced the original nucleus to the */
+ − 1332 /* to the present radius had regeneration not taken place. The ratio */
+ − 1333 /* for adjusting crushing pressure is obtained from algebraic manipulation */
+ − 1334 /* of the standard VPM equations. The adjusted crushing pressure, in lieu */
+ − 1335 /* of the original crushing pressure, is then applied in the VPM Critical */
+ − 1336 /* Volume Algorithm and the VPM Repetitive Algorithm. */
+ − 1337 /* =============================================================================== */
+ − 1338
+ − 1339 crush_pressure_adjust_ratio_he =
+ − 1340 ending_radius_he * (pVpm->adjusted_critical_radius_he[i - 1] -
+ − 1341 regenerated_radius_he[i - 1]) /
+ − 1342 (regenerated_radius_he[i - 1] *
+ − 1343 (pVpm->adjusted_critical_radius_he[i - 1] -
+ − 1344 ending_radius_he));
+ − 1345 crush_pressure_adjust_ratio_n2 =
+ − 1346 ending_radius_n2 * (pVpm->adjusted_critical_radius_n2[i - 1] -
+ − 1347 regenerated_radius_n2[i - 1]) /
+ − 1348 (regenerated_radius_n2[i - 1] *
+ − 1349 (pVpm->adjusted_critical_radius_n2[i - 1] -
+ − 1350 ending_radius_n2));
+ − 1351 adj_crush_pressure_he_pascals =
+ − 1352 crushing_pressure_pascals_he * crush_pressure_adjust_ratio_he;
+ − 1353 adj_crush_pressure_n2_pascals =
+ − 1354 crushing_pressure_pascals_n2 * crush_pressure_adjust_ratio_n2;
+ − 1355 pVpm->adjusted_crushing_pressure_he[i - 1] =
+ − 1356 adj_crush_pressure_he_pascals / 101325.0f * UNITS_FACTOR;
+ − 1357 pVpm->adjusted_crushing_pressure_n2[i - 1] =
+ − 1358 adj_crush_pressure_n2_pascals / 101325.0f * UNITS_FACTOR;
+ − 1359 }
+ − 1360 return 0;
+ − 1361 } /* nuclear_regeneration */
+ − 1362
+ − 1363 /* =============================================================================== */
+ − 1364 /* SUBROUTINE CALC_INITIAL_ALLOWABLE_GRADIENT */
+ − 1365 /* Purpose: This subprogram calculates the initial allowable gradients for */
+ − 1366 /* helium and nitrogren in each compartment. These are the gradients that */
+ − 1367 /* will be used to set the deco ceiling on the first pass through the deco */
+ − 1368 /* loop. If the Critical Volume Algorithm is set to "off", then these */
+ − 1369 /* gradients will determine the final deco schedule. Otherwise, if the */
+ − 1370 /* Critical Volume Algorithm is set to "on", these gradients will be further */
+ − 1371 /* "relaxed" by the Critical Volume Algorithm subroutine. The initial */
+ − 1372 /* allowable gradients are referred to as "PssMin" in the papers by Yount */
+ − 1373 /* and colleauges, i.e., the minimum supersaturation pressure gradients */
+ − 1374 /* that will probe bubble formation in the VPM nuclei that started with the */
+ − 1375 /* designated minimum initial radius (critical radius). */
+ − 1376
+ − 1377 /* The initial allowable gradients are computed directly from the */
+ − 1378 /* "regenerated" radii after the Nuclear Regeneration subroutine. These */
+ − 1379 /* gradients are tracked separately for helium and nitrogen. */
+ − 1380 /* =============================================================================== */
+ − 1381
290
+ − 1382 static int calc_initial_allowable_gradient()
38
+ − 1383 {
+ − 1384 float initial_allowable_grad_n2_pa,
+ − 1385 initial_allowable_grad_he_pa;
+ − 1386 short i;
+ − 1387
+ − 1388 /* loop */
+ − 1389 /* =============================================================================== */
+ − 1390 /* CALCULATIONS */
+ − 1391 /* The initial allowable gradients are computed in Pascals and then converted */
+ − 1392 /* to the diving pressure units. Two different sets of arrays are used to */
+ − 1393 /* save the calculations - Initial Allowable Gradients and Allowable */
+ − 1394 /* Gradients. The Allowable Gradients are assigned the values from Initial */
+ − 1395 /* Allowable Gradients however the Allowable Gradients can be changed later */
+ − 1396 /* by the Critical Volume subroutine. The values for the Initial Allowable */
+ − 1397 /* Gradients are saved in a global array for later use by both the Critical */
+ − 1398 /* Volume subroutine and the VPM Repetitive Algorithm subroutine. */
+ − 1399 /* =============================================================================== */
+ − 1400
+ − 1401 for (i = 1; i <= 16; ++i)
+ − 1402 {
+ − 1403 initial_allowable_grad_n2_pa =
+ − 1404 SURFACE_TENSION_GAMMA * 2.0f *
+ − 1405 (SKIN_COMPRESSION_GAMMAC - SURFACE_TENSION_GAMMA) /
+ − 1406 (regenerated_radius_n2[i - 1] * SKIN_COMPRESSION_GAMMAC);
+ − 1407
+ − 1408 initial_allowable_grad_he_pa =
+ − 1409 SURFACE_TENSION_GAMMA * 2.0f *
+ − 1410 (SKIN_COMPRESSION_GAMMAC - SURFACE_TENSION_GAMMA) /
+ − 1411 (regenerated_radius_he[i - 1] * SKIN_COMPRESSION_GAMMAC);
+ − 1412
+ − 1413 pVpm->initial_allowable_gradient_n2[i - 1] =
+ − 1414 initial_allowable_grad_n2_pa / 101325.0f * UNITS_FACTOR;
+ − 1415
+ − 1416 pVpm->initial_allowable_gradient_he[i - 1] =
+ − 1417 initial_allowable_grad_he_pa / 101325.0f * UNITS_FACTOR;
+ − 1418
+ − 1419 allowable_gradient_he[i - 1] =
+ − 1420 pVpm->initial_allowable_gradient_he[i - 1];
+ − 1421
+ − 1422 allowable_gradient_n2[i - 1] =
+ − 1423 pVpm->initial_allowable_gradient_n2[i - 1];
+ − 1424 }
+ − 1425 return 0;
+ − 1426 } /* calc_initial_allowable_gradient */
+ − 1427
+ − 1428 /* =============================================================================== */
+ − 1429 /* SUBROUTINE CALC_DECO_CEILING */
+ − 1430 /* Purpose: This subprogram calculates the deco ceiling (the safe ascent */
+ − 1431 /* depth) in each compartment, based on the allowable gradients, and then */
+ − 1432 /* finds the deepest deco ceiling across all compartments. This deepest */
+ − 1433 /* value (Deco Ceiling Depth) is then used by the Decompression Stop */
+ − 1434 /* subroutine to determine the actual deco schedule. */
+ − 1435 /* =============================================================================== */
+ − 1436
290
+ − 1437 static int calc_deco_ceiling(float *deco_ceiling_depth,_Bool fallowable)
38
+ − 1438 {
+ − 1439 /* System generated locals */
+ − 1440 float r1, r2;
+ − 1441 /* Local variables */
+ − 1442 float weighted_allowable_gradient;
+ − 1443 short i;
+ − 1444 float compartment_deco_ceiling[16],
+ − 1445 gas_loading,
+ − 1446 tolerated_ambient_pressure;
+ − 1447 float gradient_he, gradient_n2;
+ − 1448
+ − 1449 if(!vpm_b)
+ − 1450 fallowable = true;
+ − 1451 /* loop */
+ − 1452 /* =============================================================================== */
+ − 1453 /* CALCULATIONS */
+ − 1454 /* Since there are two sets of allowable gradients being tracked, one for */
+ − 1455 /* helium and one for nitrogen, a "weighted allowable gradient" must be */
+ − 1456 /* computed each time based on the proportions of helium and nitrogen in */
+ − 1457 /* each compartment. This proportioning follows the methodology of */
+ − 1458 /* Buhlmann/Keller. If there is no helium and nitrogen in the compartment, */
+ − 1459 /* such as after extended periods of oxygen breathing, then the minimum value */
+ − 1460 /* across both gases will be used. It is important to note that if a */
+ − 1461 /* compartment is empty of helium and nitrogen, then the weighted allowable */
+ − 1462 /* gradient formula cannot be used since it will result in division by zero. */
+ − 1463 /* =============================================================================== */
+ − 1464
+ − 1465 for (i = 1; i <= 16; ++i)
+ − 1466 {
+ − 1467
+ − 1468 // abfrage raus und pointer stattdessen
+ − 1469 if(fallowable){
+ − 1470 gradient_he = allowable_gradient_he[i-1];
+ − 1471 gradient_n2 = allowable_gradient_n2[i-1];
+ − 1472 }
+ − 1473 else{
+ − 1474 gradient_he = deco_gradient_he[i-1];
+ − 1475 gradient_n2 = deco_gradient_n2[i-1];
+ − 1476 }
+ − 1477
+ − 1478 gas_loading = helium_pressure[i - 1] + nitrogen_pressure[i - 1];
+ − 1479
+ − 1480 if (gas_loading > 0)
+ − 1481 {
+ − 1482 weighted_allowable_gradient =
+ − 1483 (gradient_he * helium_pressure[i - 1] +
+ − 1484 gradient_n2 * nitrogen_pressure[i - 1]) /
+ − 1485 (helium_pressure[i - 1] + nitrogen_pressure[i - 1]);
+ − 1486
+ − 1487 tolerated_ambient_pressure =
+ − 1488 gas_loading +
+ − 1489 CONSTANT_PRESSURE_OTHER_GASES -
+ − 1490 weighted_allowable_gradient;
+ − 1491 }
+ − 1492 else
+ − 1493 {
+ − 1494 /* Computing MIN */
+ − 1495 r1 = gradient_he;
+ − 1496 r2 = gradient_n2;
+ − 1497 weighted_allowable_gradient = fminf(r1,r2);
+ − 1498
+ − 1499 tolerated_ambient_pressure =
+ − 1500 CONSTANT_PRESSURE_OTHER_GASES - weighted_allowable_gradient;
+ − 1501 }
+ − 1502
+ − 1503 /* =============================================================================== */
+ − 1504 /* The tolerated ambient pressure cannot be less than zero absolute, i.e., */
+ − 1505 /* the vacuum of outer space! */
+ − 1506 /* =============================================================================== */
+ − 1507
863
+ − 1508 if (tolerated_ambient_pressure < 0.0) {
+ − 1509 tolerated_ambient_pressure = 0.0;
38
+ − 1510 }
+ − 1511 compartment_deco_ceiling[i - 1] =
+ − 1512 tolerated_ambient_pressure - barometric_pressure;
+ − 1513 }
+ − 1514
+ − 1515 /* =============================================================================== */
+ − 1516 /* The Deco Ceiling Depth is computed in a loop after all of the individual */
+ − 1517 /* compartment deco ceilings have been calculated. It is important that the */
+ − 1518 /* Deco Ceiling Depth (max deco ceiling across all compartments) only be */
+ − 1519 /* extracted from the compartment values and not be compared against some */
+ − 1520 /* initialization value. For example, if MAX(Deco_Ceiling_Depth . .) was */
+ − 1521 /* compared against zero, this could cause a program lockup because sometimes */
+ − 1522 /* the Deco Ceiling Depth needs to be negative (but not less than zero */
+ − 1523 /* absolute ambient pressure) in order to decompress to the last stop at zero */
+ − 1524 /* depth. */
+ − 1525 /* =============================================================================== */
+ − 1526
+ − 1527 *deco_ceiling_depth = compartment_deco_ceiling[0];
+ − 1528 for (i = 2; i <= 16; ++i)
+ − 1529 {
+ − 1530 /* Computing MAX */
+ − 1531 r1 = *deco_ceiling_depth;
+ − 1532 r2 = compartment_deco_ceiling[i - 1];
+ − 1533 *deco_ceiling_depth = fmaxf(r1,r2);
+ − 1534 }
+ − 1535 return 0;
+ − 1536 } /* calc_deco_ceiling */
+ − 1537
+ − 1538
+ − 1539
+ − 1540 /* =============================================================================== */
+ − 1541 /* SUBROUTINE CALC_MAX_ACTUAL_GRADIENT */
+ − 1542 /* Purpose: This subprogram calculates the actual supersaturation gradient */
+ − 1543 /* obtained in each compartment as a result of the ascent profile during */
+ − 1544 /* decompression. Similar to the concept with crushing pressure, the */
+ − 1545 /* supersaturation gradients are not cumulative over a multi-level, staged */
+ − 1546 /* ascent. Rather, it will be the maximum value obtained in any one discrete */
+ − 1547 /* step of the overall ascent. Thus, the program must compute and store the */
+ − 1548 /* maximum actual gradient for each compartment that was obtained across all */
+ − 1549 /* steps of the ascent profile. This subroutine is invoked on the last pass */
+ − 1550 /* through the deco stop loop block when the final deco schedule is being */
+ − 1551 /* generated. */
+ − 1552 /* */
+ − 1553 /* The max actual gradients are later used by the VPM Repetitive Algorithm to */
+ − 1554 /* determine if adjustments to the critical radii are required. If the max */
+ − 1555 /* actual gradient did not exceed the initial alllowable gradient, then no */
+ − 1556 /* adjustment will be made. However, if the max actual gradient did exceed */
+ − 1557 /* the intitial allowable gradient, such as permitted by the Critical Volume */
+ − 1558 /* Algorithm, then the critical radius will be adjusted (made larger) on the */
+ − 1559 /* repetitive dive to compensate for the bubbling that was allowed on the */
+ − 1560 /* previous dive. The use of the max actual gradients is intended to prevent */
+ − 1561 /* the repetitive algorithm from being overly conservative. */
+ − 1562 /* =============================================================================== */
+ − 1563
290
+ − 1564 static int calc_max_actual_gradient(float *deco_stop_depth)
38
+ − 1565 {
+ − 1566 /* System generated locals */
+ − 1567 float r1;
+ − 1568
+ − 1569 /* Local variables */
+ − 1570 short i;
+ − 1571 float compartment_gradient;
+ − 1572
+ − 1573 /* loop */
+ − 1574 /* =============================================================================== */
+ − 1575 /* CALCULATIONS */
+ − 1576 /* Note: negative supersaturation gradients are meaningless for this */
+ − 1577 /* application, so the values must be equal to or greater than zero. */
+ − 1578 /* =============================================================================== */
+ − 1579
+ − 1580 for (i = 1; i <= 16; ++i)
+ − 1581 {
+ − 1582 compartment_gradient =
+ − 1583 helium_pressure[i - 1] +
+ − 1584 nitrogen_pressure[i - 1] +
+ − 1585 CONSTANT_PRESSURE_OTHER_GASES -
+ − 1586 (*deco_stop_depth + barometric_pressure);
+ − 1587 if (compartment_gradient <= 0.0f) {
+ − 1588 compartment_gradient = 0.0f;
+ − 1589 }
+ − 1590 /* Computing MAX */
+ − 1591 r1 = pVpm->max_actual_gradient[i - 1];
+ − 1592 pVpm->max_actual_gradient[i - 1] = fmaxf(r1, compartment_gradient);
+ − 1593 }
+ − 1594 return 0;
+ − 1595 } /* calc_max_actual_gradient */
+ − 1596
+ − 1597 /* =============================================================================== */
+ − 1598 /* SUBROUTINE CALC_SURFACE_PHASE_VOLUME_TIME */
+ − 1599 /* Purpose: This subprogram computes the surface portion of the total phase */
+ − 1600 /* volume time. This is the time factored out of the integration of */
+ − 1601 /* supersaturation gradient x time over the surface interval. The VPM */
+ − 1602 /* considers the gradients that allow bubbles to form or to drive bubble */
+ − 1603 /* growth both in the water and on the surface after the dive. */
+ − 1604
+ − 1605 /* This subroutine is a new development to the VPM algorithm in that it */
+ − 1606 /* computes the time course of supersaturation gradients on the surface */
+ − 1607 /* when both helium and nitrogen are present. Refer to separate write-up */
+ − 1608 /* for a more detailed explanation of this algorithm. */
+ − 1609 /* =============================================================================== */
+ − 1610
290
+ − 1611 static int calc_surface_phase_volume_time()
38
+ − 1612 {
+ − 1613 /* Local variables */
+ − 1614 float decay_time_to_zero_gradient;
+ − 1615 short i;
+ − 1616 float integral_gradient_x_time,
+ − 1617 surface_inspired_n2_pressure;
+ − 1618
+ − 1619 /* loop */
+ − 1620 /* =============================================================================== */
+ − 1621 /* CALCULATIONS */
+ − 1622 /* =============================================================================== */
+ − 1623
+ − 1624 surface_inspired_n2_pressure =
+ − 1625 (barometric_pressure - WATER_VAPOR_PRESSURE) * 0.79f;
+ − 1626 for (i = 1; i <= 16; ++i)
+ − 1627 {
+ − 1628 if (nitrogen_pressure[i - 1] > surface_inspired_n2_pressure)
+ − 1629 {
+ − 1630 surface_phase_volume_time[i - 1] =
+ − 1631 (helium_pressure[i - 1] / HELIUM_TIME_CONSTANT[i - 1] +
+ − 1632 (nitrogen_pressure[i - 1] - surface_inspired_n2_pressure) /
+ − 1633 NITROGEN_TIME_CONSTANT[i - 1]) /
+ − 1634 (helium_pressure[i - 1] + nitrogen_pressure[i - 1] -
+ − 1635 surface_inspired_n2_pressure);
+ − 1636 } else if (nitrogen_pressure[i - 1] <= surface_inspired_n2_pressure &&
+ − 1637 helium_pressure[i - 1] + nitrogen_pressure[i - 1] >= surface_inspired_n2_pressure)
+ − 1638 {
+ − 1639 decay_time_to_zero_gradient =
+ − 1640 1.0f / (NITROGEN_TIME_CONSTANT[i - 1] - HELIUM_TIME_CONSTANT[i - 1]) *
+ − 1641 log((surface_inspired_n2_pressure - nitrogen_pressure[i - 1]) /
+ − 1642 helium_pressure[i - 1]);
+ − 1643 integral_gradient_x_time =
+ − 1644 helium_pressure[i - 1] /
+ − 1645 HELIUM_TIME_CONSTANT[i - 1] *
+ − 1646 (1.0f - expf(-HELIUM_TIME_CONSTANT[i - 1] *
+ − 1647 decay_time_to_zero_gradient)) +
+ − 1648 (nitrogen_pressure[i - 1] - surface_inspired_n2_pressure) /
+ − 1649 NITROGEN_TIME_CONSTANT[i - 1] *
+ − 1650 (1.0f - expf(-NITROGEN_TIME_CONSTANT[i - 1] *
+ − 1651 decay_time_to_zero_gradient));
+ − 1652 surface_phase_volume_time[i - 1] =
+ − 1653 integral_gradient_x_time /
+ − 1654 (helium_pressure[i - 1] +
+ − 1655 nitrogen_pressure[i - 1] -
+ − 1656 surface_inspired_n2_pressure);
+ − 1657 } else {
+ − 1658 surface_phase_volume_time[i - 1] = 0.0f;
+ − 1659 }
+ − 1660 }
+ − 1661 return 0;
+ − 1662 } /* calc_surface_phase_volume_time */
+ − 1663
+ − 1664 /* =============================================================================== */
+ − 1665 /* SUBROUTINE CRITICAL_VOLUME */
+ − 1666 /* Purpose: This subprogram applies the VPM Critical Volume Algorithm. This */
+ − 1667 /* algorithm will compute "relaxed" gradients for helium and nitrogen based */
+ − 1668 /* on the setting of the Critical Volume Parameter Lambda. */
+ − 1669 /* =============================================================================== */
+ − 1670
290
+ − 1671 static int critical_volume(float *deco_phase_volume_time)
38
+ − 1672 {
+ − 1673 /* System generated locals */
+ − 1674 float r1;
+ − 1675
+ − 1676 /* Local variables */
+ − 1677 float initial_allowable_grad_n2_pa,
+ − 1678 initial_allowable_grad_he_pa,
+ − 1679 parameter_lambda_pascals, b,
+ − 1680 c;
+ − 1681 short i;
+ − 1682 float new_allowable_grad_n2_pascals,
+ − 1683 phase_volume_time[16],
+ − 1684 new_allowable_grad_he_pascals,
+ − 1685 adj_crush_pressure_n2_pascals,
+ − 1686 adj_crush_pressure_he_pascals;
+ − 1687
+ − 1688 /* loop */
+ − 1689 /* =============================================================================== */
+ − 1690 /* CALCULATIONS */
+ − 1691 /* Note: Since the Critical Volume Parameter Lambda was defined in units of */
+ − 1692 /* fsw-min in the original papers by Yount and colleauges, the same */
+ − 1693 /* convention is retained here. Although Lambda is adjustable only in units */
+ − 1694 /* of fsw-min in the program settings (range from 6500 to 8300 with default */
+ − 1695 /* 7500), it will convert to the proper value in Pascals-min in this */
+ − 1696 /* subroutine regardless of which diving pressure units are being used in */
+ − 1697 /* the main program - feet of seawater (fsw) or meters of seawater (msw). */
+ − 1698 /* The allowable gradient is computed using the quadratic formula (refer to */
+ − 1699 /* separate write-up posted on the Deco List web site). */
+ − 1700 /* =============================================================================== */
+ − 1701
+ − 1702 /**
+ − 1703 ******************************************************************************
+ − 1704 * @brief critical_volume comment by hw
+ − 1705 * @version V0.0.1
+ − 1706 * @date 19-April-2014
+ − 1707 * @retval global: allowable_gradient_he[i], allowable_gradient_n2[i]
+ − 1708 ******************************************************************************
+ − 1709 */
+ − 1710
+ − 1711 parameter_lambda_pascals =
+ − 1712 CRIT_VOLUME_PARAMETER_LAMBDA / 33.0f * 101325.0f;
+ − 1713 for (i = 1; i <= 16; ++i)
+ − 1714 {
+ − 1715 phase_volume_time[i - 1] =
+ − 1716 *deco_phase_volume_time + surface_phase_volume_time[i - 1];
+ − 1717 }
+ − 1718 for (i = 1; i <= 16; ++i)
+ − 1719 {
+ − 1720
+ − 1721 adj_crush_pressure_he_pascals =
+ − 1722 pVpm->adjusted_crushing_pressure_he[i - 1] / UNITS_FACTOR * 101325.0f;
+ − 1723
+ − 1724 initial_allowable_grad_he_pa =
+ − 1725 pVpm->initial_allowable_gradient_he[i - 1] / UNITS_FACTOR * 101325.0f;
+ − 1726
+ − 1727 b = initial_allowable_grad_he_pa + parameter_lambda_pascals *
+ − 1728 SURFACE_TENSION_GAMMA / (
+ − 1729 SKIN_COMPRESSION_GAMMAC * phase_volume_time[i - 1]);
+ − 1730
+ − 1731 c = SURFACE_TENSION_GAMMA * (
+ − 1732 SURFACE_TENSION_GAMMA * (
+ − 1733 parameter_lambda_pascals * adj_crush_pressure_he_pascals)) /
+ − 1734 (SKIN_COMPRESSION_GAMMAC *
+ − 1735 (SKIN_COMPRESSION_GAMMAC * phase_volume_time[i - 1]));
+ − 1736 /* Computing 2nd power */
+ − 1737
+ − 1738 r1 = b;
+ − 1739
+ − 1740 new_allowable_grad_he_pascals =
+ − 1741 (b + sqrtf(r1 * r1 - c * 4.0f)) / 2.0f;
+ − 1742
+ − 1743 /* modify global variable */
+ − 1744 allowable_gradient_he[i - 1] =
+ − 1745 new_allowable_grad_he_pascals / 101325.0f * UNITS_FACTOR;
+ − 1746 }
+ − 1747
+ − 1748 for (i = 1; i <= 16; ++i)
+ − 1749 {
+ − 1750 adj_crush_pressure_n2_pascals =
+ − 1751 pVpm->adjusted_crushing_pressure_n2[i - 1] / UNITS_FACTOR * 101325.0f;
+ − 1752
+ − 1753 initial_allowable_grad_n2_pa =
+ − 1754 pVpm->initial_allowable_gradient_n2[i - 1] / UNITS_FACTOR * 101325.0f;
+ − 1755
+ − 1756 b = initial_allowable_grad_n2_pa + parameter_lambda_pascals *
+ − 1757 SURFACE_TENSION_GAMMA / (
+ − 1758 SKIN_COMPRESSION_GAMMAC * phase_volume_time[i - 1]);
+ − 1759
+ − 1760 c = SURFACE_TENSION_GAMMA *
+ − 1761 (SURFACE_TENSION_GAMMA *
+ − 1762 (parameter_lambda_pascals * adj_crush_pressure_n2_pascals)) /
+ − 1763 (SKIN_COMPRESSION_GAMMAC *
+ − 1764 (SKIN_COMPRESSION_GAMMAC * phase_volume_time[i - 1]));
+ − 1765 /* Computing 2nd power */
+ − 1766
+ − 1767 r1 = b;
+ − 1768
+ − 1769 new_allowable_grad_n2_pascals =
+ − 1770 (b + sqrtf(r1 * r1 - c * 4.0f)) / 2.0f;
+ − 1771
+ − 1772 /* modify global variable */
+ − 1773 allowable_gradient_n2[i - 1] =
+ − 1774 new_allowable_grad_n2_pascals / 101325.0f * UNITS_FACTOR;
+ − 1775 }
+ − 1776 return 0;
+ − 1777 } /* critical_volume */
+ − 1778
+ − 1779 /* =============================================================================== */
+ − 1780 /* SUBROUTINE CALC_START_OF_DECO_ZONE */
+ − 1781 /* Purpose: This subroutine uses the Bisection Method to find the depth at */
+ − 1782 /* which the leading compartment just enters the decompression zone. */
+ − 1783 /* Source: "Numerical Recipes in Fortran 77", Cambridge University Press, */
+ − 1784 /* 1992. */
+ − 1785 /* =============================================================================== */
+ − 1786
290
+ − 1787 static int calc_start_of_deco_zone(float *starting_depth,
38
+ − 1788 float *rate,
+ − 1789 float *depth_start_of_deco_zone)
+ − 1790 {
+ − 1791 /* Local variables */
+ − 1792 float last_diff_change,
+ − 1793 initial_helium_pressure,
+ − 1794 mid_range_nitrogen_pressure;
+ − 1795 short i, j;
+ − 1796 float initial_inspired_n2_pressure,
+ − 1797 cpt_depth_start_of_deco_zone,
+ − 1798 low_bound,
+ − 1799 initial_inspired_he_pressure,
+ − 1800 high_bound_nitrogen_pressure,
+ − 1801 nitrogen_rate,
+ − 1802 function_at_mid_range,
+ − 1803 function_at_low_bound,
+ − 1804 high_bound,
+ − 1805 mid_range_helium_pressure,
+ − 1806 mid_range_time,
+ − 1807 starting_ambient_pressure,
+ − 1808 initial_nitrogen_pressure,
+ − 1809 function_at_high_bound;
+ − 1810
+ − 1811 float time_to_start_of_deco_zone,
+ − 1812 high_bound_helium_pressure,
+ − 1813 helium_rate,
+ − 1814 differential_change;
+ − 1815 float fraction_helium_begin;
+ − 1816 float fraction_helium_end;
+ − 1817 float fraction_nitrogen_begin;
+ − 1818 float fraction_nitrogen_end;
+ − 1819 float ending_ambient_pressure;
+ − 1820 float time_test;
+ − 1821
+ − 1822
+ − 1823 /* loop */
+ − 1824 /* =============================================================================== */
+ − 1825 /* CALCULATIONS */
+ − 1826 /* First initialize some variables */
+ − 1827 /* =============================================================================== */
+ − 1828
+ − 1829 *depth_start_of_deco_zone = 0.0f;
+ − 1830 starting_ambient_pressure = *starting_depth + barometric_pressure;
+ − 1831
+ − 1832 //>>>>>>>>>>>>>>>>>>>>
+ − 1833 //Test depth to calculate helium_rate and nitrogen_rate
+ − 1834 ending_ambient_pressure = starting_ambient_pressure/2;
+ − 1835
+ − 1836 time_test = (ending_ambient_pressure - starting_ambient_pressure) / *rate;
863
+ − 1837 decom_get_inert_gases(starting_ambient_pressure / 10.0, (&pDiveSettings->decogaslist[mix_number]), &fraction_nitrogen_begin, &fraction_helium_begin );
+ − 1838 decom_get_inert_gases(ending_ambient_pressure / 10.0, (&pDiveSettings->decogaslist[mix_number]), &fraction_nitrogen_end, &fraction_helium_end );
38
+ − 1839 initial_inspired_he_pressure = (starting_ambient_pressure - WATER_VAPOR_PRESSURE) * fraction_helium_begin;
+ − 1840 initial_inspired_n2_pressure = (starting_ambient_pressure - WATER_VAPOR_PRESSURE) * fraction_nitrogen_begin;
+ − 1841 helium_rate = ((ending_ambient_pressure - WATER_VAPOR_PRESSURE)* fraction_helium_end - initial_inspired_he_pressure)/time_test;
+ − 1842 nitrogen_rate = ((ending_ambient_pressure - WATER_VAPOR_PRESSURE)* fraction_nitrogen_end - initial_inspired_n2_pressure)/time_test;
+ − 1843 //>>>>>>>>>>>>>>>>>>>>>
+ − 1844 /*initial_inspired_he_pressure =
+ − 1845 (starting_ambient_pressure - water_vapor_pressure) *
+ − 1846 fraction_helium[mix_number - 1];
+ − 1847 initial_inspired_n2_pressure =
+ − 1848 (starting_ambient_pressure - water_vapor_pressure) *
+ − 1849 fraction_nitrogen[mix_number - 1];
+ − 1850 helium_rate = *rate * fraction_helium[mix_number - 1];
+ − 1851 nitrogen_rate = *rate * fraction_nitrogen[mix_number - 1];*/
+ − 1852
+ − 1853 /* =============================================================================== */
+ − 1854 /* ESTABLISH THE BOUNDS FOR THE ROOT SEARCH USING THE BISECTION METHOD */
+ − 1855 /* AND CHECK TO MAKE SURE THAT THE ROOT WILL BE WITHIN BOUNDS. PROCESS */
+ − 1856 /* EACH COMPARTMENT INDIVIDUALLY AND FIND THE MAXIMUM DEPTH ACROSS ALL */
+ − 1857 /* COMPARTMENTS (LEADING COMPARTMENT) */
+ − 1858 /* In this case, we are solving for time - the time when the gas tension in */
+ − 1859 /* the compartment will be equal to ambient pressure. The low bound for time */
+ − 1860 /* is set at zero and the high bound is set at the time it would take to */
+ − 1861 /* ascend to zero ambient pressure (absolute). Since the ascent rate is */
+ − 1862 /* negative, a multiplier of -1.0 is used to make the time positive. The */
+ − 1863 /* desired point when gas tension equals ambient pressure is found at a time */
+ − 1864 /* somewhere between these endpoints. The algorithm checks to make sure that */
+ − 1865 /* the solution lies in between these bounds by first computing the low bound */
+ − 1866 /* and high bound function values. */
+ − 1867 /* =============================================================================== */
+ − 1868
863
+ − 1869 low_bound = 0.0;
38
+ − 1870 high_bound = starting_ambient_pressure / *rate * -1.0f;
+ − 1871 for (i = 1; i <= 16; ++i)
+ − 1872 {
+ − 1873 initial_helium_pressure = helium_pressure[i - 1];
+ − 1874 initial_nitrogen_pressure = nitrogen_pressure[i - 1];
+ − 1875 function_at_low_bound =
+ − 1876 initial_helium_pressure +
+ − 1877 initial_nitrogen_pressure +
+ − 1878 CONSTANT_PRESSURE_OTHER_GASES -
+ − 1879 starting_ambient_pressure;
+ − 1880 high_bound_helium_pressure =
+ − 1881 schreiner_equation__2(&initial_inspired_he_pressure,
+ − 1882 &helium_rate,
+ − 1883 &high_bound,
+ − 1884 &HELIUM_TIME_CONSTANT[i - 1],
+ − 1885 &initial_helium_pressure);
+ − 1886 high_bound_nitrogen_pressure =
+ − 1887 schreiner_equation__2(&initial_inspired_n2_pressure,
+ − 1888 &nitrogen_rate,
+ − 1889 &high_bound,
+ − 1890 &NITROGEN_TIME_CONSTANT[i - 1],
+ − 1891 &initial_nitrogen_pressure);
+ − 1892 function_at_high_bound = high_bound_helium_pressure +
+ − 1893 high_bound_nitrogen_pressure +
+ − 1894 CONSTANT_PRESSURE_OTHER_GASES;
+ − 1895 if (function_at_high_bound * function_at_low_bound >= 0.0f)
+ − 1896 {
+ − 1897 printf("\nERROR! ROOT IS NOT WITHIN BRACKETS");
+ − 1898 }
+ − 1899
+ − 1900 /* =============================================================================== */
+ − 1901 /* APPLY THE BISECTION METHOD IN SEVERAL ITERATIONS UNTIL A SOLUTION WITH */
+ − 1902 /* THE DESIRED ACCURACY IS FOUND */
+ − 1903 /* Note: the program allows for up to 100 iterations. Normally an exit will */
+ − 1904 /* be made from the loop well before that number. If, for some reason, the */
+ − 1905 /* program exceeds 100 iterations, there will be a pause to alert the user. */
+ − 1906 /* =============================================================================== */
+ − 1907
+ − 1908 if (function_at_low_bound < 0.0f)
+ − 1909 {
+ − 1910 time_to_start_of_deco_zone = low_bound;
+ − 1911 differential_change = high_bound - low_bound;
+ − 1912 } else {
+ − 1913 time_to_start_of_deco_zone = high_bound;
+ − 1914 differential_change = low_bound - high_bound;
+ − 1915 }
+ − 1916 for (j = 1; j <= 100; ++j)
+ − 1917 {
+ − 1918 last_diff_change = differential_change;
+ − 1919 differential_change = last_diff_change * 0.5f;
+ − 1920 mid_range_time =
+ − 1921 time_to_start_of_deco_zone +
+ − 1922 differential_change;
+ − 1923 mid_range_helium_pressure =
+ − 1924 schreiner_equation__2(&initial_inspired_he_pressure,
+ − 1925 &helium_rate,
+ − 1926 &mid_range_time,
+ − 1927 &HELIUM_TIME_CONSTANT[i - 1],
+ − 1928 &initial_helium_pressure);
+ − 1929 mid_range_nitrogen_pressure =
+ − 1930 schreiner_equation__2(&initial_inspired_n2_pressure,
+ − 1931 &nitrogen_rate,
+ − 1932 &mid_range_time,
+ − 1933 &NITROGEN_TIME_CONSTANT[i - 1],
+ − 1934 &initial_nitrogen_pressure);
+ − 1935 function_at_mid_range =
+ − 1936 mid_range_helium_pressure +
+ − 1937 mid_range_nitrogen_pressure +
+ − 1938 CONSTANT_PRESSURE_OTHER_GASES -
+ − 1939 (starting_ambient_pressure + *rate * mid_range_time);
+ − 1940 if (function_at_mid_range <= 0.0f) {
+ − 1941 time_to_start_of_deco_zone = mid_range_time;
+ − 1942 }
+ − 1943 if( fabs(differential_change) < 0.001f
+ − 1944 || function_at_mid_range == 0.0f)
+ − 1945 {
+ − 1946 goto L170;
+ − 1947 }
+ − 1948 /* L150: */
+ − 1949 }
+ − 1950 printf("\nERROR! ROOT SEARCH EXCEEDED MAXIMUM ITERATIONS");
+ − 1951 //pause();
+ − 1952
+ − 1953 /* =============================================================================== */
+ − 1954 /* When a solution with the desired accuracy is found, the program jumps out */
+ − 1955 /* of the loop to Line 170 and assigns the solution value for the individual */
+ − 1956 /* compartment. */
+ − 1957 /* =============================================================================== */
+ − 1958
+ − 1959 L170:
+ − 1960 cpt_depth_start_of_deco_zone =
+ − 1961 starting_ambient_pressure +
+ − 1962 *rate * time_to_start_of_deco_zone -
+ − 1963 barometric_pressure;
+ − 1964
+ − 1965 /* =============================================================================== */
+ − 1966 /* The overall solution will be the compartment with the maximum depth where */
+ − 1967 /* gas tension equals ambient pressure (leading compartment). */
+ − 1968 /* =============================================================================== */
+ − 1969
+ − 1970 *depth_start_of_deco_zone =
+ − 1971 fmaxf(*depth_start_of_deco_zone, cpt_depth_start_of_deco_zone);
+ − 1972 /* L200: */
+ − 1973 }
+ − 1974 return 0;
+ − 1975 } /* calc_start_of_deco_zone */
+ − 1976
+ − 1977 /* =============================================================================== */
+ − 1978 /* SUBROUTINE PROJECTED_ASCENT */
+ − 1979 /* Purpose: This subprogram performs a simulated ascent outside of the main */
+ − 1980 /* program to ensure that a deco ceiling will not be violated due to unusual */
+ − 1981 /* gas loading during ascent (on-gassing). If the deco ceiling is violated, */
+ − 1982 /* the stop depth will be adjusted deeper by the step size until a safe */
+ − 1983 /* ascent can be made. */
+ − 1984 /* =============================================================================== */
+ − 1985
290
+ − 1986 static int projected_ascent(float *starting_depth,
38
+ − 1987 float *rate,
+ − 1988 float *deco_stop_depth,
+ − 1989 float *step_size)
+ − 1990 {
+ − 1991 /* Local variables */
+ − 1992 float weighted_allowable_gradient,
+ − 1993 ending_ambient_pressure,
+ − 1994 temp_gas_loading[16];
+ − 1995 int i;
+ − 1996 float allowable_gas_loading[16];
+ − 1997 float temp_nitrogen_pressure[16];
+ − 1998 float temp_helium_pressure[16];
+ − 1999 float run_time_save = 0;
+ − 2000
+ − 2001 /* loop */
+ − 2002 /* =============================================================================== */
+ − 2003 /* CALCULATIONS */
+ − 2004 /* =============================================================================== */
+ − 2005
+ − 2006
+ − 2007 L665:
+ − 2008 ending_ambient_pressure = *deco_stop_depth + barometric_pressure;
+ − 2009 for (i = 1; i <= 16; ++i) {
+ − 2010 temp_helium_pressure[i - 1] = helium_pressure[i - 1];
+ − 2011 temp_nitrogen_pressure[i - 1] = nitrogen_pressure[i - 1];
+ − 2012 }
+ − 2013 run_time_save = run_time;
+ − 2014 gas_loadings_ascent_descen(temp_helium_pressure, temp_nitrogen_pressure, *starting_depth,*deco_stop_depth,*rate,true);
+ − 2015 run_time = run_time_save;
+ − 2016
+ − 2017 for (i = 1; i <= 16; ++i)
+ − 2018 {
+ − 2019 temp_gas_loading[i - 1] =
+ − 2020 temp_helium_pressure[i - 1] +
+ − 2021 temp_nitrogen_pressure[i - 1];
+ − 2022 if (temp_gas_loading[i - 1] > 0.0f)
+ − 2023 {
+ − 2024 weighted_allowable_gradient =
+ − 2025 (allowable_gradient_he[i - 1] *
+ − 2026 temp_helium_pressure[i - 1] +
+ − 2027 allowable_gradient_n2[i - 1] *
+ − 2028 temp_nitrogen_pressure[i - 1]) / temp_gas_loading[i - 1];
+ − 2029 } else {
+ − 2030 /* Computing MIN */
+ − 2031 weighted_allowable_gradient = fminf(allowable_gradient_he[i - 1],allowable_gradient_n2[i - 1]);
+ − 2032 }
+ − 2033 allowable_gas_loading[i - 1] =
+ − 2034 ending_ambient_pressure +
+ − 2035 weighted_allowable_gradient -
+ − 2036 CONSTANT_PRESSURE_OTHER_GASES;
+ − 2037 /* L670: */
+ − 2038 }
+ − 2039 for (i = 1; i <= 16; ++i) {
+ − 2040 if (temp_gas_loading[i - 1] > allowable_gas_loading[i - 1]) {
+ − 2041 *deco_stop_depth += *step_size;
+ − 2042 goto L665;
+ − 2043 }
+ − 2044 /* L671: */
+ − 2045 }
+ − 2046 return 0;
+ − 2047 } /* projected_ascent */
+ − 2048
+ − 2049 /* =============================================================================== */
+ − 2050 /* SUBROUTINE DECOMPRESSION_STOP */
+ − 2051 /* Purpose: This subprogram calculates the required time at each */
+ − 2052 /* decompression stop. */
+ − 2053 /* =============================================================================== */
+ − 2054
290
+ − 2055 static void decompression_stop(float *deco_stop_depth,
38
+ − 2056 float *step_size,
+ − 2057 _Bool final_deco_calculation)
+ − 2058 {
+ − 2059 /* Local variables */
+ − 2060 float inspired_nitrogen_pressure;
+ − 2061 // short last_segment_number;
+ − 2062 // float weighted_allowable_gradient;
+ − 2063 float initial_helium_pressure[16];
+ − 2064 /* by hw */
51
+ − 2065 float initial_CNS = gCNS_VPM;
38
+ − 2066
+ − 2067 //static float time_counter;
+ − 2068 short i;
+ − 2069 float ambient_pressure;
+ − 2070 float inspired_helium_pressure,
+ − 2071 next_stop;
+ − 2072 //last_run_time,
+ − 2073 //temp_segment_time;
+ − 2074
+ − 2075 float deco_ceiling_depth,
+ − 2076 initial_nitrogen_pressure[16];
+ − 2077 //round_up_operation;
+ − 2078 float fraction_helium_begin;
+ − 2079 float fraction_nitrogen_begin;
+ − 2080 int count = 0;
+ − 2081 _Bool buehlmann_wait = false;
+ − 2082 float tissue_He_saturation[16];
+ − 2083 float tissue_N2_saturation[16];
877
+ − 2084 float vpm_buehlmann_safety_gradient = 1.0f - (((float)pDiveSettings->vpm_conservatism) / 40);
38
+ − 2085 /* loop */
+ − 2086 /* =============================================================================== */
+ − 2087 /* CALCULATIONS */
+ − 2088 /* =============================================================================== */
+ − 2089
+ − 2090 segment_time = 0;
+ − 2091 // temp_segment_time = segment_time;
+ − 2092 ambient_pressure = *deco_stop_depth + barometric_pressure;
+ − 2093 //ending_ambient_pressure = ambient_pressure;
+ − 2094 decom_get_inert_gases(ambient_pressure / 10, (&pDiveSettings->decogaslist[mix_number]), &fraction_nitrogen_begin, &fraction_helium_begin );
+ − 2095
877
+ − 2096 if(*deco_stop_depth == (float)(pDiveSettings->last_stop_depth_bar * 10))
38
+ − 2097 next_stop = 0;
+ − 2098 else
+ − 2099 {
+ − 2100 next_stop = *deco_stop_depth - *step_size;
877
+ − 2101 next_stop = fmaxf(next_stop,(float)pDiveSettings->last_stop_depth_bar * 10);
38
+ − 2102 }
+ − 2103
+ − 2104 inspired_helium_pressure =
+ − 2105 (ambient_pressure - WATER_VAPOR_PRESSURE) * fraction_helium_begin;
+ − 2106 inspired_nitrogen_pressure =
+ − 2107 (ambient_pressure - WATER_VAPOR_PRESSURE) * fraction_nitrogen_begin;
+ − 2108
+ − 2109 /* =============================================================================== */
+ − 2110 /* Check to make sure that program won't lock up if unable to decompress */
+ − 2111 /* to the next stop. If so, write error message and terminate program. */
+ − 2112 /* =============================================================================== */
+ − 2113
+ − 2114 //deco_ceiling_depth = next_stop +1; //deco_ceiling_depth = next_stop + 1;
+ − 2115 if(!vpm_violates_buehlmann)
149
+ − 2116 {
38
+ − 2117 calc_deco_ceiling(&deco_ceiling_depth, false); //weg, weil auf jeden Fall schleife für safety und so konservativer
149
+ − 2118 }
38
+ − 2119 else
149
+ − 2120 {
863
+ − 2121 deco_ceiling_depth = next_stop + 1.0;
149
+ − 2122 }
38
+ − 2123 if(deco_ceiling_depth > next_stop)
+ − 2124 {
+ − 2125 while (deco_ceiling_depth > next_stop)
+ − 2126 {
+ − 2127
863
+ − 2128 segment_time += 60.0;
+ − 2129 if(segment_time >= 999.0 )
38
+ − 2130 {
863
+ − 2131 segment_time = 999.0 ;
38
+ − 2132 run_time += segment_time;
+ − 2133 return;
+ − 2134 }
+ − 2135 //goto L700;
+ − 2136 initial_CNS = gCNS_VPM;
+ − 2137 decom_oxygen_calculate_cns_exposure(60*60,&pDiveSettings->decogaslist[mix_number],ambient_pressure/10,&gCNS_VPM);
+ − 2138 for (i = 0; i < 16; i++)
+ − 2139 {
+ − 2140 initial_helium_pressure[i] = helium_pressure[i];
+ − 2141 initial_nitrogen_pressure[i] = nitrogen_pressure[i];
+ − 2142 helium_pressure[i] += (inspired_helium_pressure - helium_pressure[i]) * float_buehlmann_He_factor_expositon_one_hour[i];
+ − 2143 nitrogen_pressure[i] += (inspired_nitrogen_pressure - nitrogen_pressure[i]) * float_buehlmann_N2_factor_expositon_one_hour[i];
+ − 2144 }
+ − 2145 calc_deco_ceiling(&deco_ceiling_depth, false);
+ − 2146 }
+ − 2147 if(deco_ceiling_depth < next_stop)
+ − 2148 {
863
+ − 2149 segment_time -= 60.0;
38
+ − 2150 gCNS_VPM = initial_CNS;
+ − 2151 for (i = 0; i < 16; i++)
+ − 2152 {
+ − 2153 helium_pressure[i] = initial_helium_pressure[i];
+ − 2154 nitrogen_pressure[i] = initial_nitrogen_pressure[i];
+ − 2155 }
+ − 2156 deco_ceiling_depth = next_stop +1;
+ − 2157 }
+ − 2158 count = 0;
+ − 2159 while (deco_ceiling_depth > next_stop && count < 13)
+ − 2160 {
+ − 2161 count++;
+ − 2162 segment_time += 5;
+ − 2163 //goto L700;
+ − 2164 initial_CNS = gCNS_VPM;
+ − 2165 decom_oxygen_calculate_cns_exposure(60*5,&pDiveSettings->decogaslist[mix_number],ambient_pressure/10,&gCNS_VPM);
+ − 2166 for (i = 0; i < 16; i++)
+ − 2167 {
+ − 2168 initial_helium_pressure[i] = helium_pressure[i];
+ − 2169 initial_nitrogen_pressure[i] = nitrogen_pressure[i];
+ − 2170 helium_pressure[i] += (inspired_helium_pressure - helium_pressure[i]) * float_buehlmann_He_factor_expositon_five_minutes[i];
+ − 2171 nitrogen_pressure[i] += (inspired_nitrogen_pressure - nitrogen_pressure[i]) * float_buehlmann_N2_factor_expositon_five_minutes[i];
+ − 2172 }
+ − 2173 calc_deco_ceiling(&deco_ceiling_depth, false);
+ − 2174 }
+ − 2175 if(deco_ceiling_depth < next_stop)
+ − 2176 {
+ − 2177 segment_time -= 5;
+ − 2178 gCNS_VPM = initial_CNS;
+ − 2179 for (i = 0; i < 16; i++) {
+ − 2180 helium_pressure[i] = initial_helium_pressure[i];
+ − 2181 nitrogen_pressure[i] = initial_nitrogen_pressure[i];
+ − 2182 }
+ − 2183 deco_ceiling_depth = next_stop +1;
+ − 2184 }
+ − 2185 buehlmann_wait = false;
+ − 2186 while (buehlmann_wait || (deco_ceiling_depth > next_stop))
+ − 2187 {
+ − 2188 //time_counter = temp_segment_time;
863
+ − 2189 segment_time += 1.0;
38
+ − 2190
863
+ − 2191 if(segment_time >= 999.0 )
38
+ − 2192 {
863
+ − 2193 segment_time = 999.0 ;
38
+ − 2194 run_time += segment_time;
+ − 2195 return;
+ − 2196 }
+ − 2197 //goto L700;
+ − 2198 initial_CNS = gCNS_VPM;
877
+ − 2199 decom_oxygen_calculate_cns_exposure(60*1,&pDiveSettings->decogaslist[mix_number],ambient_pressure/10,&gCNS_VPM);
38
+ − 2200 for (i = 0; i < 16; i++)
+ − 2201 {
+ − 2202 initial_helium_pressure[i] = helium_pressure[i];
+ − 2203 initial_nitrogen_pressure[i] = nitrogen_pressure[i];
+ − 2204 helium_pressure[i] += (inspired_helium_pressure - helium_pressure[i]) * float_buehlmann_He_factor_expositon_one_minute[i];
+ − 2205 nitrogen_pressure[i] += (inspired_nitrogen_pressure - nitrogen_pressure[i]) * float_buehlmann_N2_factor_expositon_one_minute[i];
+ − 2206 }
+ − 2207 if(!buehlmann_wait)
+ − 2208 calc_deco_ceiling(&deco_ceiling_depth, false);
+ − 2209
+ − 2210 if(buehlmannSafety && final_deco_calculation && !(deco_ceiling_depth > next_stop))
+ − 2211 {
+ − 2212 for (i = 0; i < 16; i++)
+ − 2213 {
+ − 2214 tissue_He_saturation[i] = helium_pressure[i] / 10;
+ − 2215 tissue_N2_saturation[i] = nitrogen_pressure[i] / 10;
+ − 2216 }
+ − 2217 if( (fabsf(nitrogen_pressure[15] - inspired_nitrogen_pressure) < 0.00001f) && (fabsf(helium_pressure[15] - inspired_helium_pressure) < 0.00001f)
+ − 2218 && (fabsf(nitrogen_pressure[0] - inspired_nitrogen_pressure) < 0.00001f) && (fabsf(helium_pressure[0] - inspired_helium_pressure) < 0.00001f))
+ − 2219 {
+ − 2220 buehlmann_wait_exceeded = true;
+ − 2221 break;
+ − 2222 }
+ − 2223
+ − 2224 if(decom_tissue_test_tolerance(tissue_N2_saturation, tissue_He_saturation, vpm_buehlmann_safety_gradient, (next_stop / 10.0f) + pInput->pressure_surface_bar))
+ − 2225 break;
+ − 2226
+ − 2227 buehlmann_wait = true;
+ − 2228 }
+ − 2229 }
+ − 2230 if(buehlmann_wait)
149
+ − 2231 {
38
+ − 2232 vpm_violates_buehlmann = true;
149
+ − 2233 }
+ − 2234 if(!buehlmann_wait)
38
+ − 2235 {
+ − 2236 if(deco_ceiling_depth < next_stop)
+ − 2237 {
+ − 2238 segment_time -= 1;
+ − 2239 gCNS_VPM = initial_CNS;
+ − 2240 for (i = 0; i < 16; i++) {
+ − 2241 helium_pressure[i] = initial_helium_pressure[i];
+ − 2242 nitrogen_pressure[i] = initial_nitrogen_pressure[i];
+ − 2243 }
+ − 2244 deco_ceiling_depth = next_stop +1;
+ − 2245 }
+ − 2246 while (deco_ceiling_depth > next_stop)
+ − 2247 {
+ − 2248 //time_counter = temp_segment_time;
+ − 2249 segment_time += (float) 1.0f / 3.0f;
+ − 2250 //goto L700;
+ − 2251 initial_CNS = gCNS_VPM;
+ − 2252 decom_oxygen_calculate_cns_exposure(20,&pDiveSettings->decogaslist[mix_number],ambient_pressure/10,&gCNS_VPM);
+ − 2253 for (i = 0; i < 16; i++)
+ − 2254 {
+ − 2255 helium_pressure[i] += (inspired_helium_pressure - helium_pressure[i]) * float_buehlmann_He_factor_expositon_20_seconds[i];
+ − 2256 nitrogen_pressure[i] += (inspired_nitrogen_pressure - nitrogen_pressure[i]) * float_buehlmann_N2_factor_expositon_20_seconds[i];
+ − 2257 }
+ − 2258 calc_deco_ceiling(&deco_ceiling_depth, false);
+ − 2259 }
+ − 2260 }
+ − 2261 }
+ − 2262
+ − 2263 /*float pressure_save =dive_data.pressure;
+ − 2264 dive_data.pressure = ambient_pressure/10;
+ − 2265 tissues_exposure_stage(st_deco_test,(int)(segment_time * 60), &dive_data, &gaslist);
+ − 2266 dive_data.pressure = pressure_save;*/
+ − 2267 run_time += segment_time;
+ − 2268 return;
+ − 2269 } /* decompression_stop */
+ − 2270
+ − 2271 /* =============================================================================== */
+ − 2272 // SUROUTINE BOYLES_LAW_COMPENSATION
+ − 2273 // Purpose: This subprogram calculates the reduction in allowable gradients
+ − 2274 // with decreasing ambient pressure during the decompression profile based
+ − 2275 // on Boyle's Law considerations.
+ − 2276 //===============================================================================
290
+ − 2277 static void BOYLES_LAW_COMPENSATION (float* First_Stop_Depth,
38
+ − 2278 float* Deco_Stop_Depth,
+ − 2279 float* Step_Size)
+ − 2280 {
+ − 2281 short i;
+ − 2282
+ − 2283 float Next_Stop;
+ − 2284 float Ambient_Pressure_First_Stop, Ambient_Pressure_Next_Stop;
+ − 2285 float Amb_Press_First_Stop_Pascals, Amb_Press_Next_Stop_Pascals;
+ − 2286 float A, B, C, Low_Bound, High_Bound, Ending_Radius;
+ − 2287 float Deco_Gradient_Pascals;
+ − 2288 float Allow_Grad_First_Stop_He_Pa, Radius_First_Stop_He;
+ − 2289 float Allow_Grad_First_Stop_N2_Pa, Radius_First_Stop_N2;
+ − 2290
+ − 2291 //===============================================================================
+ − 2292 // LO//AL ARRAYS
+ − 2293 //===============================================================================
+ − 2294 // float Radius1_He[16], Radius2_He[16];
+ − 2295 // float Radius1_N2[16], Radius2_N2[16];
+ − 2296 float root_factor;
+ − 2297
+ − 2298 //===============================================================================
+ − 2299 // CALCULATIONS
+ − 2300 //===============================================================================
+ − 2301 Next_Stop = *Deco_Stop_Depth - *Step_Size;
+ − 2302
+ − 2303 Ambient_Pressure_First_Stop = *First_Stop_Depth +
+ − 2304 barometric_pressure;
+ − 2305
+ − 2306 Ambient_Pressure_Next_Stop = Next_Stop + barometric_pressure;
+ − 2307
+ − 2308 Amb_Press_First_Stop_Pascals = (Ambient_Pressure_First_Stop/UNITS_FACTOR) * 101325.0f;
+ − 2309
+ − 2310 Amb_Press_Next_Stop_Pascals =
+ − 2311 (Ambient_Pressure_Next_Stop/UNITS_FACTOR) * 101325.0f;
+ − 2312 root_factor = powf(Amb_Press_First_Stop_Pascals/Amb_Press_Next_Stop_Pascals,1.0f / 3.0f);
+ − 2313
+ − 2314 for( i = 0; i < 16;i++)
+ − 2315 {
+ − 2316 Allow_Grad_First_Stop_He_Pa =
+ − 2317 (allowable_gradient_he[i]/UNITS_FACTOR) * 101325.0f;
+ − 2318
+ − 2319 Radius_First_Stop_He = (2.0f * SURFACE_TENSION_GAMMA) /
+ − 2320 Allow_Grad_First_Stop_He_Pa;
+ − 2321
+ − 2322 // Radius1_He[i] = Radius_First_Stop_He;
+ − 2323 A = Amb_Press_Next_Stop_Pascals;
+ − 2324 B = -2.0f * SURFACE_TENSION_GAMMA;
+ − 2325 C = (Amb_Press_First_Stop_Pascals + (2.0f * SURFACE_TENSION_GAMMA)/
+ − 2326 Radius_First_Stop_He)* Radius_First_Stop_He*
+ − 2327 (Radius_First_Stop_He*(Radius_First_Stop_He));
+ − 2328 Low_Bound = Radius_First_Stop_He;
+ − 2329 High_Bound = Radius_First_Stop_He * root_factor;
+ − 2330 //*pow(Amb_Press_First_Stop_Pascals/Amb_Press_Next_Stop_Pascals,1.0/3.0);
+ − 2331 //*(Amb_Press_First_Stop_Pascals/Amb_Press_Next_Stop_Pascals)**(1.0/3.0);
+ − 2332
+ − 2333 radius_root_finder(&A,&B,&C, &Low_Bound, &High_Bound,
+ − 2334 &Ending_Radius);
+ − 2335
+ − 2336 // Radius2_He[i] = Ending_Radius;
+ − 2337 Deco_Gradient_Pascals = (2.0f * SURFACE_TENSION_GAMMA) /
+ − 2338 Ending_Radius;
+ − 2339
+ − 2340 deco_gradient_he[i] = (Deco_Gradient_Pascals / 101325.0f)*
+ − 2341 UNITS_FACTOR;
+ − 2342
+ − 2343 }
+ − 2344
+ − 2345 for( i = 0; i < 16;i++)
+ − 2346 {
+ − 2347 Allow_Grad_First_Stop_N2_Pa =
+ − 2348 (allowable_gradient_n2[i]/UNITS_FACTOR) * 101325.0f;
+ − 2349
+ − 2350 Radius_First_Stop_N2 = (2.0f * SURFACE_TENSION_GAMMA) /
+ − 2351 Allow_Grad_First_Stop_N2_Pa;
+ − 2352
+ − 2353 // Radius1_N2[i] = Radius_First_Stop_N2;
+ − 2354 A = Amb_Press_Next_Stop_Pascals;
+ − 2355 B = -2.0f * SURFACE_TENSION_GAMMA;
+ − 2356 C = (Amb_Press_First_Stop_Pascals + (2.0f * SURFACE_TENSION_GAMMA)/
+ − 2357 Radius_First_Stop_N2)* Radius_First_Stop_N2*
+ − 2358 (Radius_First_Stop_N2*(Radius_First_Stop_N2));
+ − 2359 Low_Bound = Radius_First_Stop_N2;
+ − 2360 High_Bound = Radius_First_Stop_N2* root_factor;//pow(Amb_Press_First_Stop_Pascals/Amb_Press_Next_Stop_Pascals,1.0/3.0);
+ − 2361
+ − 2362 //High_Bound = Radius_First_Stop_N2*exp(log(Amb_Press_First_Stop_Pascals/Amb_Press_Next_Stop_Pascals)/3);
+ − 2363 radius_root_finder(&A,&B,&C, &Low_Bound, &High_Bound,
+ − 2364 &Ending_Radius);
+ − 2365
+ − 2366 // Radius2_N2[i] = Ending_Radius;
+ − 2367 Deco_Gradient_Pascals = (2.0f * SURFACE_TENSION_GAMMA) /
+ − 2368 Ending_Radius;
+ − 2369
+ − 2370 deco_gradient_n2[i] = (Deco_Gradient_Pascals / 101325.0f)*
+ − 2371 UNITS_FACTOR;
+ − 2372 }
+ − 2373 }
+ − 2374
+ − 2375 /* =============================================================================== */
292
+ − 2376 // vpm_calc_ndl
+ − 2377 // Purpose: This function computes NDL (time where no decostops are needed)
38
+ − 2378 //===============================================================================
291
+ − 2379 #define MAX_NDL 240
+ − 2380
292
+ − 2381 static int vpm_calc_ndl(void)
38
+ − 2382 {
+ − 2383 static float future_helium_pressure[16];
+ − 2384 static float future_nitrogen_pressure[16];
+ − 2385 static int temp_segment_time;
+ − 2386 static int mix_number;
+ − 2387 static float inspired_helium_pressure;
+ − 2388 static float inspired_nitrogen_pressure;
+ − 2389
+ − 2390 float previous_helium_pressure[16];
+ − 2391 float previous_nitrogen_pressure[16];
+ − 2392 float ambient_pressure;
+ − 2393 float fraction_helium_begin;
+ − 2394 float fraction_nitrogen_begin;
+ − 2395 int i = 0;
+ − 2396 int count = 0;
+ − 2397 int status = CALC_END;
291
+ − 2398
38
+ − 2399 for(i = 0; i < 16;i++)
+ − 2400 {
863
+ − 2401 future_helium_pressure[i] = pInput->tissue_helium_bar[i] * 10.0;//tissue_He_saturation[st_dive][i] * 10;
+ − 2402 future_nitrogen_pressure[i] = pInput->tissue_nitrogen_bar[i] * 10.0;
38
+ − 2403 }
+ − 2404 temp_segment_time = 0;
+ − 2405
+ − 2406 mix_number = 0;
877
+ − 2407 ambient_pressure = pInput->pressure_ambient_bar * 10;
+ − 2408 decom_get_inert_gases( ambient_pressure / 10, (&pDiveSettings->decogaslist[mix_number]) , &fraction_nitrogen_begin, &fraction_helium_begin );
38
+ − 2409 inspired_helium_pressure =(ambient_pressure - WATER_VAPOR_PRESSURE) * fraction_helium_begin;
+ − 2410 inspired_nitrogen_pressure =(ambient_pressure - WATER_VAPOR_PRESSURE) *fraction_nitrogen_begin;
+ − 2411
+ − 2412 status = CALC_END;
+ − 2413 while (status == CALC_END)
+ − 2414 {
+ − 2415 count++;
+ − 2416 temp_segment_time += 60;
291
+ − 2417 if(temp_segment_time >= MAX_NDL)
38
+ − 2418 {
+ − 2419 pDecoInfo->output_ndl_seconds = temp_segment_time * 60;
292
+ − 2420 return CALC_NDL;
38
+ − 2421 }
+ − 2422 run_time += 60;
+ − 2423 //goto L700;
+ − 2424 for (i = 1; i <= 16; ++i) {
+ − 2425 previous_helium_pressure[i-1] = future_helium_pressure[i - 1];
+ − 2426 previous_nitrogen_pressure[i - 1] = future_nitrogen_pressure[i - 1];
+ − 2427 future_helium_pressure[i - 1] = future_helium_pressure[i - 1] + (inspired_helium_pressure - future_helium_pressure[i - 1]) * float_buehlmann_He_factor_expositon_one_hour[i-1];
+ − 2428 future_nitrogen_pressure[i - 1] = future_nitrogen_pressure[i - 1] + (inspired_nitrogen_pressure - future_nitrogen_pressure[i - 1]) * float_buehlmann_N2_factor_expositon_one_hour[i-1];
+ − 2429 helium_pressure[i - 1] = future_helium_pressure[i - 1];
+ − 2430 nitrogen_pressure[i - 1] = future_nitrogen_pressure[i - 1];
+ − 2431 }
+ − 2432 vpm_calc_deco();
+ − 2433 while((status = vpm_calc_critcal_volume(true,true)) == CALC_CRITICAL);
+ − 2434
+ − 2435 }
+ − 2436
+ − 2437 temp_segment_time -= 60;
+ − 2438 run_time -= 60;
+ − 2439 for (i = 1; i <= 16; ++i)
+ − 2440 {
+ − 2441 future_helium_pressure[i - 1] = previous_helium_pressure[i-1];
+ − 2442 future_nitrogen_pressure[i - 1] = previous_nitrogen_pressure[i - 1];
+ − 2443 }
+ − 2444
+ − 2445 status = CALC_END;
+ − 2446 if(temp_segment_time < 60)
+ − 2447 nullzeit_unter60 = true;
+ − 2448
+ − 2449 while (status == CALC_END)
+ − 2450 {
+ − 2451 temp_segment_time += 5;
291
+ − 2452 if(temp_segment_time >= MAX_NDL)
38
+ − 2453 {
+ − 2454 pDecoInfo->output_ndl_seconds = temp_segment_time * 60;
292
+ − 2455 return CALC_NDL;
38
+ − 2456 }
+ − 2457 if(nullzeit_unter60 && temp_segment_time > 60)
+ − 2458 {
+ − 2459 nullzeit_unter60 = false;
292
+ − 2460 return CALC_NDL;
38
+ − 2461 }
+ − 2462 run_time += 5;
+ − 2463 //goto L700;
+ − 2464 for (i = 1; i <= 16; ++i) {
+ − 2465 previous_helium_pressure[i-1] = future_helium_pressure[i - 1];
+ − 2466 previous_nitrogen_pressure[i - 1] = future_nitrogen_pressure[i - 1];
+ − 2467 future_helium_pressure[i - 1] = future_helium_pressure[i - 1] + (inspired_helium_pressure - future_helium_pressure[i - 1]) * float_buehlmann_He_factor_expositon_five_minutes[i-1];
+ − 2468 future_nitrogen_pressure[i - 1] = future_nitrogen_pressure[i - 1] + (inspired_nitrogen_pressure - future_nitrogen_pressure[i - 1]) * float_buehlmann_N2_factor_expositon_five_minutes[i-1];
+ − 2469 helium_pressure[i - 1] = future_helium_pressure[i - 1];
+ − 2470 nitrogen_pressure[i - 1] = future_nitrogen_pressure[i - 1];
+ − 2471 }
+ − 2472 vpm_calc_deco();
+ − 2473 while((status =vpm_calc_critcal_volume(true,true)) == CALC_CRITICAL);
+ − 2474 }
+ − 2475 temp_segment_time -= 5;
+ − 2476 run_time -= 5;
+ − 2477 for (i = 1; i <= 16; ++i) {
+ − 2478 future_helium_pressure[i - 1] = previous_helium_pressure[i-1];
+ − 2479 future_nitrogen_pressure[i - 1] = previous_nitrogen_pressure[i - 1];
+ − 2480 }
+ − 2481 status = CALC_END;
291
+ − 2482
38
+ − 2483 if(temp_segment_time <= 20)
+ − 2484 {
+ − 2485 while (status == CALC_END)
+ − 2486 {
+ − 2487 temp_segment_time += minimum_deco_stop_time;
+ − 2488 run_time += minimum_deco_stop_time;
+ − 2489 //goto L700;
+ − 2490 for (i = 1; i <= 16; ++i) {
+ − 2491 future_helium_pressure[i - 1] = future_helium_pressure[i - 1] + (inspired_helium_pressure - future_helium_pressure[i - 1]) * float_buehlmann_He_factor_expositon_one_minute[i-1];
+ − 2492 future_nitrogen_pressure[i - 1] = future_nitrogen_pressure[i - 1] + (inspired_nitrogen_pressure - future_nitrogen_pressure[i - 1]) * float_buehlmann_N2_factor_expositon_one_minute[i-1];
+ − 2493 helium_pressure[i - 1] = future_helium_pressure[i - 1];
+ − 2494 nitrogen_pressure[i - 1] =future_nitrogen_pressure[i - 1];
+ − 2495
+ − 2496 }
+ − 2497 vpm_calc_deco();
+ − 2498 while((status =vpm_calc_critcal_volume(true,true)) == CALC_CRITICAL);
+ − 2499
+ − 2500 }
+ − 2501 }
+ − 2502 else
+ − 2503 temp_segment_time += 5;
+ − 2504 pDecoInfo->output_ndl_seconds = temp_segment_time * 60;
+ − 2505 if(temp_segment_time > 1)
292
+ − 2506 return CALC_NDL;
38
+ − 2507 else
+ − 2508 return CALC_BEGIN;
+ − 2509 }
902
+ − 2510
+ − 2511 void vpm_table_init()
+ − 2512 {
+ − 2513 vpmTable.output_time_to_surface_seconds = 0;
907
+ − 2514 vpmTableState = VPM_TABLE_INIT;
+ − 2515 }
+ − 2516 uint8_t vpm_get_decozone(void)
+ − 2517 {
+ − 2518 return((uint8_t)pVpm->depth_start_of_deco_zone_save);
+ − 2519 }
+ − 2520 SvpmTableState vpm_get_TableState(void)
+ − 2521 {
+ − 2522 return vpmTableState;
902
+ − 2523 }
+ − 2524
