Source code documentation

dive

dive class module

Each Dive represent one dive (and only one) For successive dives, it is possible to provide the parameters of the previous dive in order to calculate the next one.

exception dipplanner.dive.NothingToProcess(description='')

raised when the is no input segments to process

__init__(description='')

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

exception dipplanner.dive.InstanciationError(description='')

raised when the Dive constructor encounters a problem. In this case, it can not continue

__init__(description='')

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

exception dipplanner.dive.ProcessingError(description='')

raised when the is no input segments to process

__init__(description='')

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

exception dipplanner.dive.InfiniteDeco(description='')

raised when the deco time becomes enourmous (like infinite)

__init__(description='')

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

class dipplanner.dive.Dive(known_segments, known_tanks, previous_profile=None)

Conducts dive based on inputSegments, knownGases, and an existing model. Iterates through dive segments updating the Model. When all dive segments are processed then calls ascend(0.0) to return to the surface.

The previous_profile (Model) can be either null in which case a new model is created, or can be an existing model with tissue loadings.

Gas switching is done on the final ascent if OC deco or bailout is specified.

Outputs profile to a List of dive segments

Attributes:

• input_segments – (list) Stores enabled input dive segment objects
• output_segments – (list) Stores output segments produced by this class
• tanks – (list) Stores enabled dive tank objects
• current_tank – current tank object
• current_depth – current dive depth
• ambiant_pressure – (current) ambiant pressure
• current_f_he – current gas fraction of He
• current_f_n2 – current gas fraction of N2
• current_f_o2 – current gas fraction of O2
• model – model used for this dive
• run_time – runTime
• pp_o2 – CCR ppO2, if OC : 0.0
• is_closed_circuit – Flag to store CC or OC
• in_final_ascent – flag for final ascent
• is_repetative_dive – Flag for repetative dives
• surface_interval – for surf. int. in seconds
• no_flight_time_value – calculated no flight time
• metadata – description for the dive

__init__(known_segments, known_tanks, previous_profile=None)

Constructor for Profile class

For fist dive, instanciate the profile class with no model (profile will create one for you) For repetative dives, instanciate profile class with the previous model

Keyword Arguments:

known_segments:– list of input segments known_tanks:– list of tanks for this dive previous_profile:  (Model) – model object of the precedent dive

Return:

<nothing>

Note

the constructor should not fail. If something if wrong, it MUST still instantiate itself, with errors in his own object

__str__()

Return a human readable name of the segment

Keyword Arguments:

<none>

Return:

str – a string with the result of the calculation of the dives

using the default template

Raise:

<nothing>

__unicode__()

Return a human readable name of the segment in unicode

Keyword Arguments:

<none>

Return:

ustr – an unicode string with the result of the calculation of

the dives using the default template

Raise:

<nothing>

__cmp__(otherdive)

Compare a dive to another dive, based on run_time

Keyword arguments:

otherdive (Dive) – another dive object

Returns:

Integer – result of cmp()

Raise:

<nothing>

output(template=None)

Returns the dive profile calculated, using the template given in settings or command lines. (and not only the default template)

Keyword Arguments:

<none>

Return:

str – a string with the result of the calculation of the dives

using the choosen template

Raise:

<nothing>

do_surface_interval(time)

Conducts a surface interval by performing a constant depth calculation on air at zero meters

Keyword Arguments:

time:(int) – duration of the interval, in seconds

Returns:

<nothing>

Raise:

<Exceptions from model>

get_surface_interval()

Returns surface interval in mm:ss format

Keyword Arguments:

<nothing>

Returns:

str – surface interval time in mmm:ss format

Raise:

<nothing>

refill_tanks()

refile all tanks defined in this dive it is used for repetitive dives

Keyword Arguments:

<none>

Returns:

<nothing>

Raise:

<nothing>

is_dive_segments()

Returns true if there are loaded dive segments else false means there is nothing to process

Keyword Arguments:

<none>

Returns:

True (bool) – if there is at least one input

dive segment to process

False (bool) – if there is no dive segment to process

Raise:

<nothing>

do_dive_without_exceptions()

Call do_dive, and handle exceptions internally : do not raise any “dive related” exception : add the exception inside self.dive_exceptions instead.

Keyword Arguments:

<none>

Return:

<nothing>

Raise:

<nothing>

do_dive()

Process the dive

Keyword Arguments:

<none>

Return:

<nothing>

Raise:

NothingToProcess – if there is no input segment to process or <Exceptions from model>

get_no_flight_hhmmss()

Returns no flight time (if calculated) in hhmmss format instead of an int in seconds

Note

This method does not calculate no_flight_time you need to call no_flight_time() or no_flight_time_wo_exception() before.

Keyword Arguments:

<none>

Returns:

str – “hh:mm:ss” no flight time str – “” if no flight time is not calculated

no_flight_time_wo_exception(altitude=2450, tank=None)

Call no_flight_time, and handle exceptions internally: do not raise any “dive related” exception: add the exception inside self.dive_exceptions instead.

Keyword Arguments:

altitude:(int) – in meter : altitude used for the calculation flight_ascent_rate:  (float) – in m/s tank:(Tank) – optionnal: it is possible to provide a tank while calling no_flight_time to force “no flight deco” with another mix than air. In this case, we will ‘consume’ the tank When the tank is empty, it automatically switch to air

Returns:

int – no fight time in seconds

Raise:

<nothing>

no_flight_time(altitude=2450, tank=None)

Evaluate the no flight time by ‘ascending’ to the choosen flight altitude. Ascending will generate the necessary ‘stop’ at the current depth (which is 0m). The stop time represents the no flight time

Keyword Arguments:

altitude:(int) – in meter : altitude used for the calculation flight_ascent_rate:  (float) – in m/s tank:(Tank) – optionnal: it is possible to provide a tank while calling no_flight_time to force “no flight deco” with another mix than air. In this case, we will ‘consume’ the tank When the tank is empty, it automatically switch to air

Returns:

int – no fight time in seconds

Raise:

InfiniteDeco - if the no flight time can not achieve enough

decompression to be able to go to give altitude

ascend(target_depth)

Ascend to target depth, decompressing if necessary. If inFinalAscent then gradient factors start changing, and automatic gas selection is made.

This method is called by do_dive()

Keyword Arguments:

target_depth:(float) – in meter, target depth for the ascend

Returns: <nothing>

Raise: <Exceptions from model>

do_gas_calcs()

Estimate gas consumption for all output segments and set this into the respective gas objects

Keyword Arguments:

<none>

Returns:

<nothing>

Raise:

<Exceptions from tank>

set_deco_gas(depth)

Select appropriate deco gas for the depth specified Returns true if a gas switch occured

Keyword Arguments:

depth:(float) – target depth to make the choice

Returns:

True – if gas swich occured False – if no gas switch occured

Raise:

<Exceptions from tank>

segment

Segment classes A segment is a portion of a dive in the same depth (depth + duration)

exception dipplanner.segment.UnauthorizedMod(description)

raised when the MOD is not possible according to the depth(s) of the segment

__init__(description)

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

class dipplanner.segment.Segment

Base class for all types of segments

Attributes:

• type (str) – type of segment

  types of segments can be :

  • const = “Constant Depth”
  • ascent = “Ascent”
  • descent = “Descent”
  • deco = “Decompression”
  • waypoint = “Waypoint”
  • surf = “Surface”

• in_use (boolean) – True if segment is used

• depth (float) – depth of this segment, in meter

• time (float) – duration of this segment, in seconds

• run_time (float) – runtime (displayed in profile informations)

• setpoint (float) – setpoint for CCR

• tank (Tank) – refer to tank object used in this segment

__init__()

constructor for Segment base class, just defines all the parameters

Keyword arguments:

<none>

Returns:

<nothing>

Raise:

<nothing>

__str__()

Return a human readable name of the segment

Keyword arguments:

<none>

Returns:

str – representation of the segment in the form: (see __repr__)

Raise:

<nothing>

__unicode__()

Return a human readable name of the segment in unicode

Keyword arguments:

<none>

Returns:

str – representation of the segment in the form: (see __repr__)

Raise:

<nothing>

check()

check if it’s a valid segment Should be executed before calculating dives

the check does not return anything if nok, but raises Exceptions

Keyword arguments:

<none>

Returns:

True (bool) – if check is ok

Raise:

<DiveExceptions>

check_mod(max_ppo2=None)

checks the mod for this segment according to the used tank.

Keyword arguments:

max_ppo2:(float) – max tolerated ppo2

Returns:

True (bool) – if check is ok

Raise:

UnauthorizedMod – if segments goes below max mod or upper min mod

check_min_od()

checks the minimum od for this segment according to the used tank. (hypoxic cases)

Keyword arguments:

<none>

Returns:

True (bool) – if check is ok

Raise:

UnauthorizedMod – if segments goes below max mod or upper min mod

get_time_str()

returns segment time in the form MMM:SS

Keyword Arguments:

<none>

Returns:

string – segment time in the form MMM:SS

Raise:

<nothing>

get_run_time_str()

returns runtime in the form MMM:SS

Keyword Arguments:

<none>

Returns:

string – segment time in the form MMM:SS

Raise:

<nothing>

get_p_absolute(method='complex')

returns the absolute pression in bar (1atm = 1ATA = 1.01325 bar = 14.70psi)

Simple method : 10m = +1 bar Complex method : use real density of water, T°, etc...

Keyword arguments:

method – ‘simple’ or ‘complex’

Returns:

float – indicating the absolute pressure in bar

Raise:

ValueError – when providing a bad method

get_end()

Calculates and returns E.N.D : Equivalent Narcosis Depth

Instead of Mvplan, it uses a ‘calculation method’ based on narcosis effet of all gas used, assuming there is no trace of other gases (like argon) in the breathing gas, but compare the narcotic effect with surface gas, wich is ‘air’ and contains a small amount of argon

Keyword arguments:

<none>

Returns:

integer – Equivalent Narcosis Depth in meter

Raise:

<nothing>

gas_used()

returns the quantity (in liter) of gas used for this segment

(this method is empty)

class dipplanner.segment.SegmentDive(depth, time, tank, setpoint=0)

Specialisation of segment class for dive segments

__init__(depth, time, tank, setpoint=0)

Constructor for SegmentDive class. Look at base class for more explanations

Keyword arguments:

depth:(float) – in meter, the (constant) depth for this segment time:(float) – in second, duration of this segment tank:(Tank) – object instance of Tank class : describe the tank used in this segment setpoint:(float) – for CCR, setpoint used for this segment for OC : setpoint should be zero

Returns:

<nothing>

Raise:

UnauthorizedMod – if depth is incompatible

with either min or max mod

gas_used()

calculates returns the quantity (in liter) of gas used for this segment

Keyword arguments:

<none>

Returns:

float – in liter, quantity of gas used

__str__()

Return a human readable name of the segment

Keyword arguments:

<none>

Returns:

str – representation of the segment in the form: (see __repr__)

Raise:

<nothing>

__unicode__()

Return a human readable name of the segment in unicode

Keyword arguments:

<none>

Returns:

str – representation of the segment in the form: (see __repr__)

Raise:

<nothing>

check()

check if it’s a valid segment Should be executed before calculating dives

the check does not return anything if nok, but raises Exceptions

Keyword arguments:

<none>

Returns:

True (bool) – if check is ok

Raise:

<DiveExceptions>

check_min_od()

checks the minimum od for this segment according to the used tank. (hypoxic cases)

Keyword arguments:

<none>

Returns:

True (bool) – if check is ok

Raise:

UnauthorizedMod – if segments goes below max mod or upper min mod

check_mod(max_ppo2=None)

checks the mod for this segment according to the used tank.

Keyword arguments:

max_ppo2:(float) – max tolerated ppo2

Returns:

True (bool) – if check is ok

Raise:

UnauthorizedMod – if segments goes below max mod or upper min mod

get_end()

Calculates and returns E.N.D : Equivalent Narcosis Depth

Instead of Mvplan, it uses a ‘calculation method’ based on narcosis effet of all gas used, assuming there is no trace of other gases (like argon) in the breathing gas, but compare the narcotic effect with surface gas, wich is ‘air’ and contains a small amount of argon

Keyword arguments:

<none>

Returns:

integer – Equivalent Narcosis Depth in meter

Raise:

<nothing>

get_p_absolute(method='complex')

returns the absolute pression in bar (1atm = 1ATA = 1.01325 bar = 14.70psi)

Simple method : 10m = +1 bar Complex method : use real density of water, T°, etc...

Keyword arguments:

method – ‘simple’ or ‘complex’

Returns:

float – indicating the absolute pressure in bar

Raise:

ValueError – when providing a bad method

get_run_time_str()

returns runtime in the form MMM:SS

Keyword Arguments:

<none>

Returns:

string – segment time in the form MMM:SS

Raise:

<nothing>

get_time_str()

returns segment time in the form MMM:SS

Keyword Arguments:

<none>

Returns:

string – segment time in the form MMM:SS

Raise:

<nothing>

class dipplanner.segment.SegmentDeco(depth, time, tank, setpoint=0)

Specialisation of segment class for deco segments

__init__(depth, time, tank, setpoint=0)

Constructor for SegmentDeco class. Look at base class for more explanations

In deco segment, we also have to manage some new parameters :

• gf_used : which gradient factor is used
• control_compartment : who is the control compartement
• mv_max : max M-value for the compartment

Keyword arguments:

depth:(float) – in meter, the (constant) depth for this segment time:(float) – in second, duration of this segment tank:(Tank) – object instance of Tank class : describe the tank used in this segment setpoint:(float) – for CCR, setpoint used for this segment for OC : setpoint should be zero

Returns:

<nothing>

Raise:

UnauthorizedMod – if depth is incompatible

with either min or max mod

gas_used()

calculates returns the quantity (in liter) of gas used for this segment

Keyword arguments:

<none>

Returns:

float – in liter, quantity of gas used

__str__()

Return a human readable name of the segment

Keyword arguments:

<none>

Returns:

str – representation of the segment in the form: (see __repr__)

Raise:

<nothing>

__unicode__()

Return a human readable name of the segment in unicode

Keyword arguments:

<none>

Returns:

str – representation of the segment in the form: (see __repr__)

Raise:

<nothing>

check()

check if it’s a valid segment Should be executed before calculating dives

the check does not return anything if nok, but raises Exceptions

Keyword arguments:

<none>

Returns:

True (bool) – if check is ok

Raise:

<DiveExceptions>

check_min_od()

checks the minimum od for this segment according to the used tank. (hypoxic cases)

Keyword arguments:

<none>

Returns:

True (bool) – if check is ok

Raise:

UnauthorizedMod – if segments goes below max mod or upper min mod

check_mod(max_ppo2=None)

checks the mod for this segment according to the used tank.

Keyword arguments:

max_ppo2:(float) – max tolerated ppo2

Returns:

True (bool) – if check is ok

Raise:

UnauthorizedMod – if segments goes below max mod or upper min mod

get_end()

Calculates and returns E.N.D : Equivalent Narcosis Depth

Instead of Mvplan, it uses a ‘calculation method’ based on narcosis effet of all gas used, assuming there is no trace of other gases (like argon) in the breathing gas, but compare the narcotic effect with surface gas, wich is ‘air’ and contains a small amount of argon

Keyword arguments:

<none>

Returns:

integer – Equivalent Narcosis Depth in meter

Raise:

<nothing>

get_p_absolute(method='complex')

returns the absolute pression in bar (1atm = 1ATA = 1.01325 bar = 14.70psi)

Simple method : 10m = +1 bar Complex method : use real density of water, T°, etc...

Keyword arguments:

method – ‘simple’ or ‘complex’

Returns:

float – indicating the absolute pressure in bar

Raise:

ValueError – when providing a bad method

get_run_time_str()

returns runtime in the form MMM:SS

Keyword Arguments:

<none>

Returns:

string – segment time in the form MMM:SS

Raise:

<nothing>

get_time_str()

returns segment time in the form MMM:SS

Keyword Arguments:

<none>

Returns:

string – segment time in the form MMM:SS

Raise:

<nothing>

class dipplanner.segment.SegmentAscDesc(start_depth, end_depth, rate, tank, setpoint=0)

Specialisation of segment class for Ascent or Descent segments

__init__(start_depth, end_depth, rate, tank, setpoint=0)

Constructor for SegmentAscDesc class. Look at base class for more explanations in this segment, we do not specify time, but rate (of ascending or descending) and start_depth and end_depth The comparaison between start and end depth determine if asc or desc rate is given in m/min

Keyword arguments:

start_depth:(float) – in meter, the starting depth for this segment end_depth:(float) – in meter, the ending depth for this segment rate:(float) – in m/s, rate of ascending or descending tank:(Tank) – object instance of Tank class : describe the tank used in this segment setpoint:(float) – for CCR, setpoint used for this segment for OC : setpoint should be zero

Returns:

<nothing>

Raise:

UnauthorizedMod – if depth is incompatible

with either min or max mod

check_mod(max_ppo2=None)

checks the mod for this segment according to the used tank.

Keyword arguments:

max_ppo2:(float) – max tolerated ppo2

Returns:

<nothing>

Raise:

UnauthorizedMod – if segments goes below max mod or upper min mod

check_min_od()

checks the minimum od for this segment according to the used tank. (hypoxic cases)

Keyword arguments:

<none>

Returns:

<nothing>

Raise:

UnauthorizedMod – if segments goes below max mod or upper min mod

__str__()

Return a human readable name of the segment

Keyword arguments:

<none>

Returns:

str – representation of the segment in the form: (see __repr__)

Raise:

<nothing>

__unicode__()

Return a human readable name of the segment in unicode

Keyword arguments:

<none>

Returns:

str – representation of the segment in the form: (see __repr__)

Raise:

<nothing>

check()

check if it’s a valid segment Should be executed before calculating dives

the check does not return anything if nok, but raises Exceptions

Keyword arguments:

<none>

Returns:

True (bool) – if check is ok

Raise:

<DiveExceptions>

gas_used()

calc. and returns the quantity (in liter) of gas used in this segment because it’s ascend or descent, the gas is not used at the same rate during the segment Because the rate is the same during all the segment, we can use the consumption at the average depth of the segment

Keyword arguments:

<none>

Returns:

float – in liter, quantity of gas used

get_end()

Calculates and returns E.N.D : Equivalent Narcosis Depth

Instead of Mvplan, it uses a ‘calculation method’ based on narcosis effet of all gas used, assuming there is no trace of other gases (like argon) in the breathing gas, but compare the narcotic effect with surface gas, wich is ‘air’ and contains a small amount of argon

Keyword arguments:

<none>

Returns:

integer – Equivalent Narcosis Depth in meter

Raise:

<nothing>

get_p_absolute(method='complex')

returns the absolute pression in bar (1atm = 1ATA = 1.01325 bar = 14.70psi)

Simple method : 10m = +1 bar Complex method : use real density of water, T°, etc...

Keyword arguments:

method – ‘simple’ or ‘complex’

Returns:

float – indicating the absolute pressure in bar

Raise:

ValueError – when providing a bad method

get_run_time_str()

returns runtime in the form MMM:SS

Keyword Arguments:

<none>

Returns:

string – segment time in the form MMM:SS

Raise:

<nothing>

get_time_str()

returns segment time in the form MMM:SS

Keyword Arguments:

<none>

Returns:

string – segment time in the form MMM:SS

Raise:

<nothing>

tank

Contains a Tank Class

Note

in MVPlan, this class was the ‘Gas’ class

exception dipplanner.tank.InvalidGas(description)

Exception raised when the gas informations provided for the Tank are invalid

__init__(description)

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

exception dipplanner.tank.InvalidTank(description)

Exception raised when the tank infos provided are invalid

__init__(description)

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

exception dipplanner.tank.InvalidMod(description)

Exception raised when the given MOD is incompatible with the gas provided for the tank

__init__(description)

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

exception dipplanner.tank.EmptyTank(description)

Exception raised when trying to consume more gas in tank than the remaining gas

__init__(description)

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

class dipplanner.tank.Tank(f_o2=0.21, f_he=0.0, max_ppo2=1.6, mod=None, tank_vol=12.0, tank_pressure=200, tank_rule='30b')

This class implements a representation of dive tanks wich contains breathing Gas We provide proportion of N2, O2, He, calculates MOD and volumes during the dives We can also (optionally) provide the type of tanks :

• volume
• pressure
• remaining gas warning rule

Note

About imperial unit conversion

In ‘imperial’ countries (North America), it’s common to describe a tank with the volume of air stored in the cylinder at its working pressure (if you where to release it at the surface), instead of (internal volume * pressure).

This make difficult if not impossible to switch between the two units without any approximation or implementation choices.

eg: 80-cubic-foot aluminium cylinder (AL80)

TODO: continuer le texte explicatif

Attributes:

• f_o2 (float) – fraction of oxygen in the gas in % (>= 0.0 & <= 1.0)

• f_he (float) – fraction of helium in the gas in % (>= 0.0 & <= 1.0)

• f_n2 (float) – fraction of nitrogen in the gas in %

  (>= 0.0 & <= 1.0)

• max_ppo2 (float) – maximum tolerated ppo2 for this tank

• tank_vol (float) – volume of tank in liter

• tank_pressure (float) – pressure of tank in bar

• mod (float) – maximum operating depth of the tank

• in_use (boolean) – is the tank used for the dive of not

• total_gas (float) – total gas volume of the tank in liter

• used_gas (float) – used gas in liter

• remaining_gas (float) – remaining gas in liter

• min_gas (float) – minimum remaining gas in liter

__init__(f_o2=0.21, f_he=0.0, max_ppo2=1.6, mod=None, tank_vol=12.0, tank_pressure=200, tank_rule='30b')

Constructor for Tank class

If nothing is provided, create a default ‘Air’ with 12l/200b tank and max_ppo2 to 1.6 (used to calculate mod) if mod not provided, mod is calculed based on max tolerable ppo2

Keyword arguments:

f_o2:

(float) – Fraction of O2 in the gaz in % value between 0.0 and 1.0

f_he:

(float) – Fraction of He in the gaz in % value between 0.0 and 1.0

max_ppo2:

(float) – sets the maximum ppo2 you want for this tank (default: settings.DEFAULT_MAX_PPO2)

mod:

(float) – Specify the mod you want. * if not provided, calculates the mod based on max_ppo2

• if provided and not compatible with max_ppo2: raise InvalidMod

tank_vol:

(float) – Volume of the tank in liter

tank_pressure:

(float) – Pressure of the tank, in bar

tank_rule:

(float) – rule for warning in the tank consumption must be either :

• xxxb (ex: 50b means 50 bar minimum at

  the end of the dive)

• 1/x

  • ex : 1/3 for rule of thirds:

    • 1/3 for way in,
    • 1/3 for way out,
    • 1/3 remains at the end of the dive)

  • ex2: 1/6 rule:

    • 1/6 way IN,
    • 1/6 wau OUT,
    • 2/3 remains

Returns:

<nothing>

Raise:

• InvalidGas – see validate()

• InvalidMod – if mod > max mod based on

  max_ppo2 and see validate()

• InvalidTank – see validate()

__deepcopy__(memo)

deepcopy method will be called by copy.deepcopy

Used for “cloning” the object into another new object.

Keyword Arguments:

memo:– not used here

Returns:

Tank – Tank object copy of itself

Raise:

<nothing>

calculate_real_volume(tank_vol=None, tank_pressure=None, f_o2=None, f_he=None, temp=15)

Calculate the real gas volume of the tank (in liter) based on Van der waals equation: (P+n2.a/V2).(V-n.b)=n.R.T

Keyword arguments:

tank_vol:(float) – Volume of the tank in liter optional : if not provided, use self.tank_vol tank_pressure:(float) – Pressure of the tank in bar optional : if not provided, use self.tank_pressure f_o2:(float) – fraction of O2 in the gas optional : if not provided, use self.f_o2 f_he:(float) – fraction of He in the gas optional : if not provided, use self.f_he

Returns:

float – total gas volume of the tank in liter

Raise:

<nothing>

__str__()

Return a human readable name of the tank

Keyword arguments:

<none>

Returns:

str – name of the tank in the form:

“Air” “Nitrox 80” ...

Raise:

<nothing>

__unicode__()

Return a human readable name of the tank in unicode

Keyword arguments:

<none>

Returns:

str – name of the tank in the form:

“Air” “Nitrox 80” ...

Raise:

<nothing>

__cmp__(othertank)

Compare a tank to another tank, based on MOD

Keyword arguments:

othertank (Tank) – another tank object

Returns:

integer – result of cmp()

Raise:

<nothing>

_calculate_mod(max_ppo2)

calculate and returns mod for a given ppo2 based on this tank info result in meter

Keyword arguments:

max_ppo2:– maximum ppo2 accepted (float). Any value accepted, but should be > 0.0

Returns:

integer – Maximum Operating Depth in meter

Raise:

<nothing>

_validate()

Test the validity of the tank informations inside this object if validity check fails raise an Exception ‘InvalidTank’

Keyword arguments:

<nothing>

Returns:

<nothing>

Raise:

• InvalidGas – When proportions of gas exceed

  100% for example (or negatives values)

• InvalidMod – if mod > max mod based on max_ppo2

  or ABSOLUTE_MAX_MOD.

  ABSOLUTE_MAX_MOD is a global settings which can not be exceeded.

• InvalidTank – when pressure or tank size exceed maximum

  values or are incorrect (like negatives) values

name()

returns a Human readable name for the gaz and tanks Differnt possibilities: Air, Nitrox, Oxygen, Trimix, Heliox

Keyword arguments:

<none>

Returns:

str – name of the tank in the form:

“Air” “Nitrox” ...

Raise:

<nothing>

get_tank_info()

returns tank infos : size, remaining vol example of tank info: 15l-90% (2800/3000l)

Keyword arguments:

<none>

Returns:

str – infos of the tank in the form:

“12.0l-100.0% (2423.10/2423.10l)” ...

Raise:

<nothing>

get_mod(max_ppo2=None)

return mod (maximum operating depth) in meter if no argument provided, return the mod based on the current tank (and configured max_ppo2) if max_ppo2 is provided, returns the (new) mod based on the given ppo2

Keyword arguments:

max_ppo2:(float) – ppo2 for mod calculation

Returns:

float – mod in meter

Raise:

<nothing>

get_min_od(min_ppo2=0.16)

return in meter the minimum operating depth for the gas in the tank return 0 if diving from/to surface is ok with this gaz

Keyword arguments:

min_ppo2:(float) – minimum tolerated ppo2

Returns:

float – minimum operating depthin meter

Raise:

<nothing>

get_mod_for_given_end(end)

calculate a mod based on given end and based on gaz inside the tank

Note

end calculation is based on narcotic index for all gases.

By default, dipplanner considers that oxygen is narcotic (same narcotic index than nitrogen)

All narcotic indexes can by changed in the config file, in the [advanced] section

Keyword arguments:

end:(int) – equivalent narcotic depth in meter

Returns:

int – mod: depth in meter based on given end

Raise:

<nothing>

get_end_for_given_depth(depth)

calculate end (equivalent narcotic depth) based on given depth and based on gaz inside the tank

Note

end calculation is based on narcotic index for all gases.

By default, dipplanner considers that oxygen is narcotic (same narcotic index than nitrogen)

All narcotic indexes can by changed in the config file, in the [advanced] section

Keyword arguments:

depth – int – in meter

Returns:

end – int – equivalent narcotic depth in meter

Raise:

<nothing>

consume_gas(gas_consumed)

Consume gas inside this tank

Keyword arguments:

gas_consumed:(float) – gas consumed in liter

Returns:

float – remaining gas in liter

Raise:

<nothing>

refill()

Refill the tank

Keyword arguments:

<none>

Returns:

float – remaining gas in liter

Raise:

<nothing>

check_rule()

Checks the rule agains the remaining gas in the tank

Keyword arguments:

gas_consumed:(float) – gas consumed in liter

Returns:

bool – True is rule OK

False if rule Not OK

Raise:

<nothing>

model: buhlmann

Exceptions

Defines Exceptions for buhlmann model

exception dipplanner.model.buhlmann.model_exceptions.ModelException(description)

Generic Model Exception

__init__(description)

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

exception dipplanner.model.buhlmann.model_exceptions.ModelStateException(description)

Model State Exception

__init__(description)

constructor : call the upper constructor and set the logger

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

compartment

Defines a Buhlmann compartment

class dipplanner.model.buhlmann.compartment.Compartment(h_he=None, h_n2=None, a_he=None, b_he=None, a_n2=None, b_n2=None)

Buhlmann compartment class

Attributes:

• h_he: helium halftime
• h_n2: nitrogen halftime
• a_he: helium : a coefficient
• a_n2: nitrogen : a coefficient
• b_he: helium : b coefficient
• b_n2: nitrogen : b coefficient
• k_he: helium : k coefficient (calculated)
• k_n2: nitrogen : k coefficient (calculated)
• pp_he: partial pressure of helium
• pp_n2: partial pressure of nitrogen

__init__(h_he=None, h_n2=None, a_he=None, b_he=None, a_n2=None, b_n2=None)

Constructor for Compartment can be called without params, in this case, does not initiate anything can be called with time params and coef and in this case initate the compartment time constants

Keyword arguments:

h_he:(float) – helium halftime h_n2:(float) – nitrogen halftime a_he:(float) – helium: a coefficient b_he:(float) – helium: b coefficient a_n2:(float) – nitrogen: a coefficient b_n2:(float) – nitrogen: b coefficient

Returns:

<nothing>

Raise:

see set_compartment_time_constants method

__deepcopy__(memo)

deepcopy method will be called by copy.deepcopy

Used for “cloning” the object into another new object.

Keyword Arguments:

memo:– not used here

Returns:

Compartment – Compartment object copy of itself

Raise:

<nothing>

__str__()

Return a human readable name of the segment

Keyword Arguments:

<none>

Returns:

str – string representation of the compartment

ex: “He:0.0 N2:19.9991340314 gf:0.3 mv_at:2.98611129437 max_amb:15.8731803417 MV:6.6973840088”

Raise:

<nothing>

__unicode__()

Return a human readable name of the segment in unicode

Keyword Arguments:

<none>

Returns:

ustr – unicode string representation of the compartment

ex: u”He:0.0 N2:19.9991340314 gf:0.3 mv_at:2.98611129437 max_amb:15.8731803417 MV:6.6973840088”

Raise:

<nothing>

set_compartment_time_constants(h_he, h_n2, a_he, b_he, a_n2, b_n2)

Sets the compartment’s time constants

Keyword arguments:

h_he:(float) – Helium Halftime h_n2:(float) – Nitrogen Halftime a_he:(float) – Helium : a coefficient b_he:(float) – Helium : b coefficient a_n2:(float) – Nitrogen : a coefficient b_n2:(float) – Nitrogen : b coefficient

Returns:

<nothing>

Raise:

<nothing>

set_pp(pp_he, pp_n2)

Sets partial pressures of He and N2

Keyword arguments:

pp_he:(float) – partial pressure of Helium pp_n2:(float) – partial pressure of Nitrogen

Return:

<nothing>

Raise:

<nothing>

const_depth(pp_he_inspired, pp_n2_inspired, seg_time)

Constant depth calculations. Uses instananeous equation: P = Po + (Pi - Po)(1-e^-kt) store the new values in self.pp_he and self.pp_n2

Keyword arguments:

pp_he_inspired:(float) – partial pressure of inspired helium pp_n2_inspired:(float) – partial pressure of inspired nitrogen seg_time:(float) – segment time in seconds

Return:

<nothing>

Raise:

ModelStateException – if pp or time < 0

asc_desc(pp_he_inspired, pp_n2_inspired, rate_he, rate_n2, seg_time)

Ascend or descent calculations. Uses equation : P=Pio+R(t -1/k)-[Pio-Po-(R/k)]e^-kt store the new values in self.pp_he and self.pp_n2

Keyword arguments:

pp_he_inspired:(float) – partial pressure of inspired helium pp_n2_inspired:(float) – partial pressure of inspired nitrogen rate_he:(float) – rate of change of pp_he rate_n2:(float) – rate of change of pp_n2 seg_time:(float) – segment time in seconds

Return:

<nothing>

Raise:

ModelStateException – if pp or time < 0

get_m_value_at(pressure)

Gets M-Value for given ambient pressure using the Buhlmann equation Pm = Pa/b +a where:

• Pm = M-Value pressure,
• Pa = ambiant pressure
• a,b co-efficients

Note

Not used for decompression but for display of M-value limit line

Note

this method does not use gradient factors.

Keyword arguments:

pressure:(float) – ambient pressure (in bar)

Return:

float – M_value: maximum tolerated pressure in bar

Raise:

<nothing>

get_max_amb(gf)

Gets Tolerated Absolute Pressure for the compartment for current pp of He and N2

Keyword arguments:

gf:(float) – gradient factor : 0.1 to 1.0, typical 0.2 - 0.95

Return:

float – maximum tolerated pressure (absolute) in bar

Raise:

<nothing>

get_mv(p_amb)

Gets M-Value for a compartment, given an ambient pressure

Keyword arguments:

p_amb:(float) – ambiant pressure

Return:

float – M-value

Raise:

<nothing>

gradient

gradient module

class dipplanner.model.buhlmann.gradient.Gradient(gf_low, gf_high)

Defines a Gradient Factor object

A GF Object maintains a low and high setting and is able to determine a GF for any depth between its initialisation depth (see setGfAtDepth()) and the surface.

Attributes (self.):

• gf_low (float) – low Gradient factor, from 0.0 to 1.0
• gf_high (float) – high Gradient factor, from 0.0 to 1.0
• gf (float) – current gf
• gf_slope (float) – slope of the linear equation
• gf_set (float) – Indicates that gf Slope has been initialised

__init__(gf_low, gf_high)

Constructor for Gradient object

Keyword arguments:

gf_low:(float) – low Gradient factor, from 0.0 to 1.0 gf_high:(float) – high Gradient factor, from 0.0 to 1.0

Returns:

<nothing>

Raise:

ValueError – if either gf_low of gf_high has wrong value

__deepcopy__(memo)

deepcopy method will be called by copy.deepcopy

Used for “cloning” the object into another new object.

Keyword Arguments:

memo:– not used here

Returns:

Gradient – Gradient object copy of itself

Raise:

<nothing>

get_gradient_factor()

Returns current GF with bounds checking if gf < gf_low, returns gf_low

Keyword arguments:

<none>

Returns:

float – gf

Raise:

<nothing>

set_gf_at_depth(depth)

Sets the gf for a given depth. Must be called after setGfSlope() has initialised slope

Keyword arguments:

depth:(float) – current depth, in meter

Returns:

<nothing>

Raise:

<nothing>

set_gf_slope_at_depth(depth)

Set gf Slope at specified depth. Typically called once to initialise the GF slope.

Keyword arguments:

depth:(float) – current depth, in meter

Returns:

<nothing>

Raise:

<nothing>

set_gf_low(value)

Sets gf low setting

Keyword arguments:

value:(float) – low Gf, between 0.0 and 1.0

Returns:

<nothing>

Raise:

ValueError – if either gf_low of gf_high has wrong value

set_gf_high(value)

Sets gf high setting

Keyword arguments:

value:(float) – high Gf, between 0.0 and 1.0

Returns:

<nothing>

Raise:

ValueError – if gf_high has wrong value

__str__

x.__str__() <==> str(x)

oxygen toxicity

Oxygen Toxicity model

class dipplanner.model.buhlmann.oxygen_toxicity.OxTox

Defines a Oxygen Toxicity model

Attributes:

• cns (float) – central nervous system toxicity

  (see http://en.wikipedia.org/wiki/Oxygen_toxicity#Signs_and_symptoms)

• otu (float- – Oxygen toxicity Units

• max_ox (float) – maximum ppo2

__init__()

Constructor for OxTox class

Keyword arguments:

<none>

Returns:

<nothing>

Raise:

<nothing>

__deepcopy__(memo)

deepcopy method will be called by copy.deepcopy

Used for “cloning” the object into another new object.

Keyword Arguments:

memo:– not used here

Returns:

Gradient – Gradient object copy of itself

Raise:

<nothing>

add_o2(time, pp_o2)

Adds oxygen load into model.

Uses NOAA lookup table to add percentage based on time and ppO2. Calculate OTU using formula OTU= T * (0.5/(pO2-0.5))^-(5/6)

this OTU formula need T (time) in minutes, so we need to convert the time in second to minutes while using this formula

Keyword arguments:

pp_o2:(float) – partial pressure of oxygen time:(float) – time of segment (in seconds)

Returns:

<nothing>

Raise:

<nothing>

remove_o2(time)

Removes oxygen load from model during surface intervals

Keyword arguments:

time:(float) – time of segment (in seconds)

Returns:

<nothing>

Raise:

<nothing>

__str__

x.__str__() <==> str(x)

model

Buhlmann model module

Contains: Model – class

class dipplanner.model.buhlmann.model.Model

Represents a Buhlmann model. Composed of a tissue array of Compartment[] Has an OxTox and Gradient object

Can throw a ModelStateException propagated from a Compartment if pressures or time is out of bounds.

Models are initialised by initModel() if they are new models, or validated by validateModel() if they are rebuild from a saved model.

The model is capable of ascending or descending via ascDec() using the ascDec() method of Compartment, or accounting for a constant depth using the constDepth() method of Compartment.

Attributes:

• tissues (list)– a list of Compartments
• gradient (Gradient) – gradient factor object
• ox_tox (OxTox) – OxTox object
• metadata (str) – Stores infos about where the model was created
• units (str) – only ‘metric’ allowed
• COMPS (int) – static info : number of compartments
• MODEL_VALIDATION_SUCCESS (int) – static const for validation success
• MODEL_VALIDATION_FAILURE (int) – static const for validation failure

__init__()

Constructor for model class

Keyword arguments:

<none>

Returns:

<nothing>

Raise:

<nothing>

__deepcopy__(memo)

deepcopy method will be called by copy.deepcopy

Used for “cloning” the object into another new object.

Keyword Arguments:

memo:– not used here

Returns:

Model – Model object copy of itself

Raise:

<nothing>

__str__()

Return a human readable name of the segment

Keyword Arguments:

<none>

Returns:

str – string representation of the model

Raise:

<nothing>

__unicode__()

Return a human readable name of the segment in unicode

Keyword Arguments:

<none>

Returns:

ustr – unicode string representation of the model

Raise:

<nothing>

init_gradient()

Initialise the gradient attribute uses the default settings parameters for gf_low and high

Keyword arguments:

<none>

Returns:

<nothing>

Raise:

<nothing>

set_time_constants(deco_model='ZHL16c')

Initialize time constants in buhlmann tissue list Only for metric values

Keyword arguments:

deco_model:(str) – “ZHL16b” or “ZHL16c”

Returns:

<nothing>

Raise:

<nothing>

validate_model()

Validate model - checks over the model and looks for corruption

This is needed to check a model that has been loaded from XML Resets time constants

Keyword arguments:

<none>

Returns:

self.MODEL_VALIDATION_SUCCESS – if OK self.MODEL_VALIDATION_FAILURE – if not OK

Raise:

<nothing>

control_compartment()

Determine the controlling compartment at ceiling (1-16)

Keyword arguments:

<none>

Returns:

integer – reference number of the controlling

compartment (between 1 to 16)

Raise:

<nothing>

ceiling()

Determine the current ceiling depth

Keyword arguments:

<none>

Returns:

float – ceiling depth in meter

Raise:

<nothing>

ceiling_in_pabs()

Determine the current ceiling

Keyword arguments:

<none>

Returns:

float – ceiling in bar (absolute pressure)

Raise:

<nothing>

m_value(pressure)

Determine the maximum M-Value for a given depth (pressure)

Keyword arguments:

pressure:(float) – in bar

Returns

float – max M-Value

Raise:

<nothing>

const_depth(pressure, seg_time, f_he, f_n2, pp_o2)

Constant depth profile. Calls Compartment.constDepth for each compartment to update the model.

Keyword arguments:

pressure:(float)– pressure of this depth of segment in bar seg_time:(float) – Time of segment in seconds f_he:(float) – fraction of inert gas Helium in inspired gas mix f_n2:(float) – fraction of inert gas Nitrogen in inspired gas mix pp_o2:(float) – For CCR mode, partial pressure of oxygen in bar. If == 0.0, then open circuit

Returns:

<nothing>

Raise:

ModelStateException

asc_desc(start, finish, rate, f_he, f_n2, pp_o2)

Ascend/Descend profile. Calls Compartment.asc_desc to update compartments

Keyword arguments:

start:(float) – start pressure of this segment in bar (WARNING: not meter ! it’s a pressure) finish:(float) – finish pressure of this segment in bar (WARNING: not meter ! it’s a pressure) rate:(float) – rate of ascent or descent in m/s f_he:(float) – Fraction of inert gas Helium in inspired gas mix f_n2:(float) – Fraction of inert gas Nitrogen in inspired gas mix pp_o2:(float) – For CCR mode, partial pressure of oxygen in bar. If == 0.0, then open circuit

Returns:

<nothing>

Raise:

ModelStateException

Exceptions

Base Class for exceptions for dipplanner module

exception dipplanner.dipp_exception.DipplannerException(description)

Base exception class for dipplanner

__init__(description)

DipplannerException constructor

Keyword Arguments:

description:(str) – text describing the error

Return:

<nothing>

Raise:

<nothing>

__str__()

String representing the object

Keyword Arguments:

<none>

Return:

str – a string describing the Exception

Raise:

<nothing>

__unicode__()

unicode string representing the object

Keyword Arguments:

<none>

Return:

ustr – a unicode string describing the Exception

Raise:

<nothing>

tools

tools modules

This modules contains some utility functions like unit conversions, etc...

dipplanner.tools.safe_eval_calculator(text_to_eval)

Small an safe eval function usable only for simple calculation (only the basic operators)

Keyword Arguments:

text_to_eval:(float) – the text (formula) that should be evaluated

Returns:

float – the result of the calculation.

Raise:

ValueError: when given expression is not constitued of only

numbers and operators

SyntaxError: when the given expression is incorrect

dipplanner.tools.seconds_to_mmss(seconds)

Convert a value in seconds into a string representing the time in minutes and seconds (like 2:06) It does returns only minutes and seconds, not hours, minutes and seconds

Keyword Arguments:

seconds:(float) – the duration in seconds

Returns:

str – the time in minutes and seconds

ex: ” 23:45” “112:33” ...

Raise:

ValueError: when bad time values

dipplanner.tools.seconds_to_hhmmss(seconds)

Convert a value in seconds into a string representing the time in hour:minutes and seconds like 22:34:44

Keyword Arguments:

seconds:(float) – the duration in seconds

Returns:

str – the time in hour - minutes and seconds

ex: “00:23:45” “01:52:33”

Raise:

ValueError: when bad time values is given

dipplanner.tools.altitude_or_depth_to_absolute_pressure(altitude_or_depth)

output absolute pressure for give “depth” in meter.

• If depth is positive it’s considered altitude depth
• If depth is negative it’s considered depth in water

Keyword Arguments:

altitude_or_depth:  (float (signed)) – in meter

Returns:

float – resulting absolute pressure in bar

Raise:

ValueError if altitude > 10000m

dipplanner.tools.altitude_to_pressure(altitude)

Convert a given altitude in pressure in bar uses the formula: p = 101325.(1-2.25577.10^-5.h)^5.25588

Keyword Arguments:

altitude:(float) – current altitude in meter

Returns:

float – resulting pressure in bar

Raise:

ValueError: when bad altitude is given (bad or <0 or > 10000 m)

dipplanner.tools.depth_to_pressure(depth, method='complex')

Calculates depth pressure based on depth using a more complex method than only /10

Keyword Arguments:

depth:(float) – in meter

Returns:

float – depth pressure in bar

Raise:

<nothing>

dipplanner.tools.pressure_to_depth(pressure, method='complex')

Calculates depth based on give pressure using a more complex method than only *10

Keyword Arguments:

pressure:(float) – pressure in bar

Returns:

float – depth in meter

Raise:

<nothing>

dipplanner.tools.calculate_pp_h2o_surf(temperature=20)

Calculates and return vapor pressure of water at surface using Antoine equation (http://en.wikipedia.org/wiki/Vapour_pressure_of_water)

Keyword Arguments:

temperature:(float) [OPTIONNAL] – in ° Celcius

Returns:

float – ppH2O in bar

Raise:

ValueError – when temperature exceed maximum value for calculation

(>=374 °C)

dipplanner.tools.convert_bar_to_psi(value)

SI –> imperial pressure conversion function

Keyword Arguments:

value:(float) – pressure in bar

Returns:

float – pressure in psi

Raise:

<nothing>

dipplanner.tools.convert_psi_to_bar(value)

imperial –> SI pressure conversion function

Keyword Arguments:

value:(float) – pressure in psi

Returns:

float – pressure in bar

Raise:

<nothing>

dipplanner.tools.convert_liter_to_cubicfeet(value)

SI –> imperial volume conversion function

Keyword Arguments:

value:(float) – volume in liter

Returns:

float – volume in cubicfeet

Raise:

<nothing>

dipplanner.tools.convert_cubicfeet_to_liter(value)

imperial –> SI volume conversion function

Keyword Arguments:

value:(float) – volume in cubicfeet

Returns:

float – volume in liter

Raise:

<nothing>

dipplanner.tools.convert_meter_to_feet(value)

SI –> imperial distance conversion function

Keyword Arguments:

value:(float) – volume in cubicfeet

Returns:

float – volume in liter

Raise:

<nothing>

dipplanner.tools.convert_feet_to_meter(value)

imperial –> SI distance conversion function

Keyword Arguments:

value:(float) – volume in cubicfeet

Returns:

float – volume in liter

Raise:

<nothing>

main

main dipplanner module for command line usage.

This module is used by the only “executable” of the project: bin/dipplanner (which is an empty shell)

runs in command line and output resulting dive profile also initiate log files

dipplanner.main.activate_debug()

setup the default debug parameters

it’s mainly used for test cases who needs also logging to be set

Keyword Arguments:

<none>

Return:

<nothing>

Raise:

<nothing>

dipplanner.main.activate_debug_for_tests()

setup the default debug parameters

it’s mainly used for test cases who needs also logging to be set

Keyword Arguments:

<none>

Return:

<nothing>

Raise:

<nothing>

dipplanner.main.main(cli_arguments=['/home/docs/sites/readthedocs.org/checkouts/readthedocs.org/user_builds/dipplanner/envs/latest/bin/sphinx-build', '-E', '-b', 'html', '.', '_build/html'])

main uses the parameters, tanks and dives given in config file(s) and/or command line, calculates the dives and return the output in stdout.

Keyword Arguments:

arguments (list of string) – list of arguments, like sys.argv

Return:

<nothing>

Raise:

<nothing>

settings

Global settings for dipplannerand their default values

All the settings can be changed by dipplanner command-line documentation and/or dipplanner config file documentation

dipplanner.settings.FRESH_WATER_DENSITY = 1.0

water density kg/l

dipplanner.settings.SEA_WATER_DENSITY = 1.03

water density kg/l

dipplanner.settings.ABSOLUTE_MAX_PPO2 = 2.0

in bar

dipplanner.settings.ABSOLUTE_MIN_PPO2 = 0.16

in bar

dipplanner.settings.ABSOLUTE_MAX_TANK_PRESSURE = 300

in bar

dipplanner.settings.ABSOLUTE_MAX_TANK_SIZE = 40

in liter

dipplanner.settings.SURFACE_TEMP = 20

Temperature at surface. Used to calculate PP_H2O_SURFACE

dipplanner.settings.HE_NARCOTIC_VALUE = 0.23

helium narcotic value

dipplanner.settings.N2_NARCOTIC_VALUE = 1.0

nitrogen narcotic value

dipplanner.settings.O2_NARCOTIC_VALUE = 1.0

oxygen narcotic value

dipplanner.settings.AR_NARCOTIC_VALUE = 2.33

argon narcotic value

dipplanner.settings.STOP_DEPTH_INCREMENT = 3

in meter

dipplanner.settings.LAST_STOP_DEPTH = 3

in meter : last stop before surfacing

dipplanner.settings.STOP_TIME_INCREMENT = 1

in second

dipplanner.settings.FORCE_ALL_STOPS = True

once deco stop begun, force to stop to each deco depth stop

dipplanner.settings.AMBIANT_PRESSURE_SEA_LEVEL = 1.01325

surface pressure (in bar)

dipplanner.settings.METHOD_FOR_DEPTH_CALCULATION = 'complex'

either simple (/10) or complex

dipplanner.settings.TRAVEL_SWITCH = 'late'

“late” or “early”

dipplanner.settings.FLIGHT_ALTITUDE = 2450

in meter practicly, this value can not be bigger than about 2850m because breathing air at 0m will only ‘prepare the body’ to a decompression until this value. To go higher, another ‘stop’ is needed between.

dipplanner.settings.TEMPLATE = 'default-color.tpl'

template should be in templates/ directory

dipplanner.settings.DECO_MODEL = 'ZHL16c'

ZHL16c or ZHL16b

dipplanner.settings.WATER_DENSITY = 1.03

water density kg/l

dipplanner.settings.AMBIANT_PRESSURE_SURFACE = 1.01325

surface pressure (in bar)

dipplanner.settings.DEFAULT_MAX_PPO2 = 1.6

in bar

dipplanner.settings.DEFAULT_MIN_PPO2 = 0.21

in bar

dipplanner.settings.DEFAULT_MAX_END = 30

in meter

dipplanner.settings.DIVE_CONSUMPTION_RATE = 0.2833333333333333

liter/s

dipplanner.settings.DECO_CONSUMPTION_RATE = 0.2

liter/s

dipplanner.settings.DESCENT_RATE = 0.3333333333333333

m/s

dipplanner.settings.ASCENT_RATE = 0.16666666666666666

m/s

dipplanner.settings.RUN_TIME = True

Warning : if RUN-TIME is True, the segment duration must

include descent time

if the duration is too small dipplanner will raise an error if True: segments represents runtime, if false, segments represents segtime

dipplanner.settings.USE_OC_DECO = True

if True, use enabled gases of decomp in oc or bailout

dipplanner.settings.GF_LOW = 0.3

% between 0.0 and 1.0

dipplanner.settings.GF_HIGH = 0.8

% between 0.0 and 1.0

dipplanner.settings.MULTILEVEL_MODE = False

TO CHECK

dipplanner.settings.AUTOMATIC_TANK_REFILL = True

automatic refill of tanks between dives