mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-30 22:20:21 +00:00
Code Issues Projects Releases Packages Wiki Activity

CCR patch: Adapt pressure interpolation for CCR (2)

Browse source 
This is the second pathch in this series of four, allowing the calculation
of cylinder pressures for CCR equipment.

Change function fill_missing_tank_pressures in order to enable working
with the diuent gas, comprising a complete set of pressures kept separate
from all other tank pressures.
Flag diluent_flag indicates calculations for the diluent cylinder.

[Dirk Hohndel: serious whitespace cleanup]

Signed-off-by: willem ferguson <willemferguson@zoology.up.ac.za>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
This commit is contained in:
willem ferguson 2014-08-28 07:51:16 +02:00 committed by Dirk Hohndel
parent 3925aed5ea
commit b701bc612b
1 changed files with 51 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

83
gaspressures.c
View file

@ -156,7 +156,7 @@ void dump_pr_interpolate(int i, pr_interpolate_t interpolate_pr)
static struct pr_interpolate_struct get_pr_interpolate_data(pr_track_t *segment, struct plot_info *pi, int cur, int diluent_flag) static struct pr_interpolate_struct get_pr_interpolate_data(pr_track_t *segment, struct plot_info *pi, int cur, int diluent_flag)
{ // cur = index to pi->entry corresponding to t_end of segment; diluent_flag=1 indicates diluent cylinder { // cur = index to pi->entry corresponding to t_end of segment; diluent_flag=1 indicates diluent cylinder
struct pr_interpolate_struct interpolate; struct pr_interpolate_struct interpolate;
int i; int i;
struct plot_data *entry; struct plot_data *entry;
@ -212,58 +212,76 @@ static struct pr_interpolate_struct get_pr_interpolate_data(pr_track_t *segment,
return interpolate; return interpolate;
} }
static void fill_missing_tank_pressures(struct dive *dive, struct plot_info *pi, pr_track_t **track_pr) static void fill_missing_tank_pressures(struct dive *dive, struct plot_info *pi, pr_track_t **track_pr, int diluent_flag)
{ {
int cyl, i; int cyl, i;
struct plot_data *entry; struct plot_data *entry;
int cur_pr[MAX_CYLINDERS]; int cur_pr[MAX_CYLINDERS]; // cur_pr[MAX_CYLINDERS] is the CCR diluent cylinder
int diluent_flag = 0;
#ifdef DEBUG_PR_TRACK
/* another great debugging tool */
dump_pr_track(track_pr);
#endif
for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) { for (cyl = 0; cyl < MAX_CYLINDERS; cyl++) {
if (!track_pr[cyl]) { if (!track_pr[cyl]) {
/* no segment where this cylinder is used */ /* no segment where this cylinder is used */
cur_pr[cyl] = -1; cur_pr[cyl] = -1;
continue; continue;
} }
fill_missing_segment_pressures(track_pr[cyl]); fill_missing_segment_pressures(track_pr[cyl]); // Interpolate the missing tank pressure values ..
cur_pr[cyl] = track_pr[cyl]->start; cur_pr[cyl] = track_pr[cyl]->start; // in the pr_track_t lists of structures
} } // and keep the starting pressure for each cylinder.
/* The first two are "fillers", but in case we don't have a sample #ifdef DEBUG_PR_TRACK
* at time 0 we need to process the second of them here */ /* another great debugging tool */
for (i = 1; i < pi->nr; i++) { dump_pr_track(track_pr);
#endif
/* Transfer interpolated cylinder pressures from pr_track strucktures to plotdata
* Go down the list of tank pressures in plot_info. Align them with the start &
* end times of each profile segment represented by a pr_track_t structure. Get
* the accumulated pressure_depths from the pr_track_t structures and then
* interpolate the pressure where these do not exist in the plot_info pressure
* variables. Pressure values are transferred from the pr_track_t structures
* to the plot_info structure, allowing us to plot the tank pressure.
*
* The first two pi structures are "fillers", but in case we don't have a sample
* at time 0 we need to process the second of them here, therefore i=1 */
for (i = 1; i < pi->nr; i++) { // For each point on the profile:
double magic; double magic;
pr_track_t *segment; pr_track_t *segment;
pr_interpolate_t interpolate; pr_interpolate_t interpolate;
int pressure;
int *save_pressure, *save_interpolated;
entry = pi->entry + i; entry = pi->entry + i;
cyl = entry->cylinderindex;
if (SENSOR_PRESSURE(entry)) { if (diluent_flag) { // Find the cylinder index (cyl) ..
cur_pr[cyl] = SENSOR_PRESSURE(entry); cyl = DILUENT_CYLINDER; // .. as well as the cylinder pressure
continue; pressure = DILUENT_PRESSURE(entry);
save_pressure = &(entry->diluentpressure[SENSOR_PR]);
save_interpolated = &(entry->diluentpressure[INTERPOLATED_PR]);
} else {
pressure = SENSOR_PRESSURE(entry);
save_pressure = &(entry->pressure[SENSOR_PR]);
save_interpolated = &(entry->pressure[INTERPOLATED_PR]);
cyl = entry->cylinderindex;
} }
/* Find the right pressure segment for this entry.. */ if (pressure) { // If there is a valid pressure value,
cur_pr[cyl] = pressure; // set current pressure
continue; // and skip to next point.
}
// If there is NO valid pressure value..
// Find the pressure segment corresponding to this entry..
segment = track_pr[cyl]; segment = track_pr[cyl];
while (segment && segment->t_end < entry->sec) while (segment && segment->t_end < entry->sec) // Find the track_pr with end time..
segment = segment->next; segment = segment->next; // ..that matches the plot_info time (entry->sec)
/* No (or empty) segment? Just use our current pressure */ if (!segment || !segment->pressure_time) { // No (or empty) segment?
if (!segment || !segment->pressure_time) { *save_pressure = cur_pr[cyl]; // Just use our current pressure
SENSOR_PRESSURE(entry) = cur_pr[cyl]; continue; // and skip to next point.
continue;
} }
// If there is a valid segment but no tank pressure ..
interpolate = get_pr_interpolate_data(segment, pi, i, diluent_flag); // Set up an interpolation structure
interpolate = get_pr_interpolate_data(segment, pi, i, diluent_flag); /* if this segment has pressure_time, then calculate a new interpolated pressure */
#ifdef DEBUG_PR_INTERPOLATE
dump_pr_interpolate(i, interpolate);
#endif
/* if this segment has pressure time, calculate a new interpolated pressure */
if (interpolate.pressure_time) { if (interpolate.pressure_time) {
/* Overall pressure change over total pressure-time for this segment*/ /* Overall pressure change over total pressure-time for this segment*/
magic = (interpolate.end - interpolate.start) / (double)interpolate.pressure_time; magic = (interpolate.end - interpolate.start) / (double)interpolate.pressure_time;
@ -271,10 +289,11 @@ static void fill_missing_tank_pressures(struct dive *dive, struct plot_info *pi,
/* Use that overall pressure change to update the current pressure */ /* Use that overall pressure change to update the current pressure */
cur_pr[cyl] = rint(interpolate.start + magic * interpolate.acc_pressure_time); cur_pr[cyl] = rint(interpolate.start + magic * interpolate.acc_pressure_time);
} }
INTERPOLATED_PRESSURE(entry) = cur_pr[cyl]; *save_interpolated = cur_pr[cyl]; // and store the interpolated data in plot_info
} }
} }
/* /*
* What's the pressure-time between two plot data entries? * What's the pressure-time between two plot data entries?
* We're calculating the integral of pressure over time by * We're calculating the integral of pressure over time by
@ -342,7 +361,7 @@ void populate_pressure_information(struct dive *dive, struct divecomputer *dc, s
} }
if (missing_pr) { if (missing_pr) {
fill_missing_tank_pressures(dive, pi, track_pr); fill_missing_tank_pressures(dive, pi, track_pr, 0);
} }
for (i = 0; i < MAX_CYLINDERS; i++) for (i = 0; i < MAX_CYLINDERS; i++)
list_free(track_pr[i]); list_free(track_pr[i]);