|
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
|
