File Coverage

blib/lib/Deco/Dive.pm

Criterion	Covered	Total	%
statement	149	153	97.3
branch	41	50	82.0
condition	7	12	58.3
subroutine	13	13	100.0
pod	8	8	100.0
total	218	236	92.3

#######################################
# Module  : Deco::Dive.pm
# Author  : Jaap Voets
# Date    : 27-05-2006
# $Revision$
#######################################
package Deco::Dive;

use strict;
use warnings;
use Carp;
use Config::General;
use Deco::Tissue;

our $VERSION = '0.4';

our @MODELS = ('haldane', 'padi', 'usnavy');

# Constructor
sub new {
    my $class = shift;
    my %args  = @_;

    my $self = {};

    # the data points for the dive, both arrays
    $self->{timepoints} = [];
    $self->{depths}     = [];

    # an array of tissues to use
    $self->{tissues}    = ();

    # super structure to remember all tissue info per timepoint
    $self->{info}       = {};

    # where can we find the config?
    $self->{config_dir} = $args{configdir} || '.';

    # theoretical tissue model we'll be using
    $self->{model}        = '';
    $self->{model_name}   = '';
    bless $self, $class;

    return $self;
}

# load the dive profile data from a file
sub load_data_from_file {
    my $self = shift;
    my %opt  = @_;

    my $file = $opt{file};
    croak "No file specified, to load dive profile" unless $file;
    # check whether the file exists
    croak "File $file does not exist" unless ( -e $file);

    # field separator
    my $sep        = $opt{separator} || ';';
    my $timefield  = $opt{timefield} || '0';
    my $depthfield = $opt{depthfield} || 1;
    my $timefactor = $opt{timefactor} || 1; # factor to get each time point in seconds

    my (@times, @depths);
    open (IN, $file) || croak "Can't open file $file for reading";
    while (my $line = ) {
	chomp($line);
	next if $line =~ /^\s*#/; # skip comment lines
	next if $line =~ /^\s+$/; # skip empty lines
	my @fields = split(/$sep/, $line);
	push @times, $timefactor * $fields[$timefield];
	my $depth = $fields[$depthfield];
	if ($depth < 0) {
	    $depth = -1 * $depth;
	}
	push @depths, $depth;
    }
    close(IN);

    $self->{depths}     = \@depths;
    $self->{timepoints} = \@times;

}

# set a time, depth point
sub point {
    my $self = shift;
    my ($time, $depth) = @_;
    push @{ $self->{depths} }, $depth;
    push @{ $self->{timepoints} }, $time;
}

# pick a model and load the corresponding config
# this will create a list of tissues
# either specify a config file and read the model from there
#  - or - specify a model and read in the default file
sub model {
    my $self = shift;
    my %opt  = @_;

    my ($config_file, $model);
    if ( $opt{config} ) {
	$config_file = $opt{config};
	# model will be read from config
    } elsif ( $opt{model} ) {
	$model = lc( $opt{model} );
	$config_file = $self->{config_dir} . "/$model.cnf";
    } else {
	croak "Please specify the config file or model to use!";
    }

    # load the config
    my $conf   = new Config::General(  -ConfigFile => $config_file,  -LowerCaseNames => 1 );
    my %config = $conf->getall;

    $model = lc($config{model});

    # remember the model we use
    $self->{model}      = $model;
    $self->{model_name} = $config{name};

    croak "Invalid model $model" unless grep { $_ eq $model } @MODELS;

    # cleanup first
    $self->{tissues} = ();

    # create all the tissues
    foreach my $num (keys %{ $config{tissue} }) {
	$self->{tissues}[$num] = new Deco::Tissue( halftime => $config{tissue}{$num}{halftime},
						   M0       => $config{tissue}{$num}{m0},
						   deltaM   => $config{tissue}{$num}{deltam} ,
						   nr       => $num,
						   );
    }

    return 1;
}

# run the simulation
sub simulate {
    my $self = shift;
    my %opt  = @_;

    # model passed to us takes precedence, if that is not present
    # we see if the model was already set, otherwise we default to haldane
    my $model = lc($opt{model}) || $self->{model} || 'haldane';
    croak "Invalid model $model" unless grep { $_ eq $model } @MODELS;

    # first load the model
    $self->model( model => $model,  config => $self->{config_dir} . '/' . $model . '.cnf');

    # then check whether we loaded data
    if ( scalar( @{ $self->{timepoints} } ) == 0 ) {
	croak "No dive profile data present, forgot to call dive->load_data_from_file() ?";
    }

    # step through all the timepoints & depths
    my $i = 0;
    my @times  = @{ $self->{timepoints} };
    my @depths = @{ $self->{depths} };
    foreach my $time ( @times ) {
	# get the corresponding depth
	my $depth = $depths[$i];
	$i++;

	my $nodeco_dive          = 1000000;
	my $leading_tissue_deco  = '';

	my $safe_depth_dive      = 0;
	my $leading_tissue_depth = '';

	# loop over all the tissues
	foreach my $tissue ( @{ $self->{tissues} } ) {
	    next if ! defined $tissue;

	    my $num  = $tissue->nr;

	    $tissue->point( $time, $depth );

	    # we like to have
	    # no_deco time, is special, it can return - for not applicable
	    my $nodeco = $tissue->nodeco_time();
	    $nodeco = undef if $nodeco eq '-';
	    $self->{info}->{$num}->{$time}->{nodeco_time}    = $nodeco;
	    if ($nodeco) {
		if ($nodeco < $nodeco_dive) {
		    $nodeco_dive         = $nodeco;
		    $leading_tissue_deco = $tissue->nr();
		}
	    }

	    # safe depth, meters, positive
	    my $safe_depth = $tissue->safe_depth();
	    $self->{info}->{$num}->{$time}->{safe_depth} =  $safe_depth;
	    if ($safe_depth > $safe_depth_dive) {
		$safe_depth_dive      = $safe_depth;
		$leading_tissue_depth = $tissue->nr();
	    }

	    # percentage filled compared to M0 pressure
	    $self->{info}->{$num}->{$time}->{percentage} =  $tissue->percentage();

	    # internal pressure
	    $self->{info}->{$num}->{$time}->{pressure}   = $tissue->internalpressure();

	    # OTU's
	    $self->{info}->{$num}->{$time}->{pressure}   = $tissue->calculate_otu();

	}
	if ($nodeco_dive == 1000000) {
	    $nodeco_dive = '-';
	}
	$self->{info}->{dive}->{$time}->{nodeco}             = $nodeco_dive;
	$self->{info}->{dive}->{$time}->{leadingtissuedeco}  = $leading_tissue_deco;
	$self->{info}->{dive}->{$time}->{safedepth}          = $safe_depth_dive;
	$self->{info}->{dive}->{$time}->{leadingtissuedepth} = $leading_tissue_depth;

    }

}

# set gas fractions
sub gas {
    my $self = shift;
    my %gaslist = @_;
    # just pass it off to each tissue
    foreach my $tissue ( @{ $self->{tissues} } ) {
        next if ! defined $tissue;

	# the tissue module will croak on setting wrong gas
	# just let it bubble up to the calling script from here
	$tissue->gas( %gaslist );
    }
}

# calculate the no-deco time for the dive
# this will be the smalles value of the nodeco times of
# the tissues of this model
#
# time is minutes, it takes the current depth and time of the tissue
# second return value is the tissue nr that gave the minimal nodeco_time
sub nodeco_time {
    my $self = shift;
    # loop over all the tissues
    my $nodeco_time = 1000000; # start with absurd high value for easy comparing
    my $tissue_nr   = '';
    foreach my $tissue ( @{ $self->{tissues} } ) {
    	next if ! defined $tissue;
        my $time = $tissue->nodeco_time();
    	if ($time ne '-') {
    	    if ($time < $nodeco_time) {
    	    	$nodeco_time = $time;
    		    $tissue_nr   = $tissue->nr();
    	    }
    	}
    }
    if ($nodeco_time == 1000000) {
    	$nodeco_time = '-';
    }
    return ($nodeco_time, $tissue_nr);
}

# return a tissue by number
sub tissue {
    my $self =shift;
    my $tissue_num = shift;

    croak "Please specify a tissue nr" unless defined $tissue_num;

    foreach my $tissue ( @{ $self->{tissues} } ) {
	    next if ! defined $tissue;
	    if ( $tissue->nr() == $tissue_num ) {
            return $tissue;
	    }
    }

    # if we make it to here the tissue is not known
    croak "Tissue nr $tissue_num is unknown";
}
1;


__END__