OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Convert to enum class

Browse Source
This commit is contained in:
Magne Sjaastad
2020-04-24 07:13:33 +02:00
parent 83914006fd
commit f89dcf4e52
63 changed files with 513 additions and 450 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
ApplicationCode/Application/RiaApplication.cpp
View File

@@ -1208,9 +1208,9 @@ void RiaApplication::applyPreferences()
// instead of using the application font
std::map<RiaDefines::FontSettingType, RiaFontCache::FontSize> fontSizes = m_preferences->defaultFontSizes();
m_defaultSceneFont = RiaFontCache::getFont( fontSizes[RiaDefines::SCENE_FONT] );
m_defaultAnnotationFont = RiaFontCache::getFont( fontSizes[RiaDefines::ANNOTATION_FONT] );
m_defaultWellLabelFont = RiaFontCache::getFont( fontSizes[RiaDefines::WELL_LABEL_FONT] );
m_defaultSceneFont = RiaFontCache::getFont( fontSizes[RiaDefines::FontSettingType::SCENE_FONT] );
m_defaultAnnotationFont = RiaFontCache::getFont( fontSizes[RiaDefines::FontSettingType::ANNOTATION_FONT] );
m_defaultWellLabelFont = RiaFontCache::getFont( fontSizes[RiaDefines::FontSettingType::WELL_LABEL_FONT] );
if ( this->project() )
{

66
ApplicationCode/Application/RiaDefines.cpp
View File

@@ -42,66 +42,66 @@ void caf::AppEnum<RiaDefines::ResultCatType>::setUp()
template <>
void caf::AppEnum<RiaDefines::DepthUnitType>::setUp()
{
addItem( RiaDefines::UNIT_METER, "UNIT_METER", "Meter" );
addItem( RiaDefines::UNIT_FEET, "UNIT_FEET", "Feet" );
addItem( RiaDefines::UNIT_NONE, "UNIT_NONE", "None" );
addItem( RiaDefines::DepthUnitType::UNIT_METER, "UNIT_METER", "Meter" );
addItem( RiaDefines::DepthUnitType::UNIT_FEET, "UNIT_FEET", "Feet" );
addItem( RiaDefines::DepthUnitType::UNIT_NONE, "UNIT_NONE", "None" );
setDefault( RiaDefines::UNIT_METER );
setDefault( RiaDefines::DepthUnitType::UNIT_METER );
}
template <>
void caf::AppEnum<RiaDefines::DepthTypeEnum>::setUp()
{
addItem( RiaDefines::MEASURED_DEPTH, "MEASURED_DEPTH", "Measured Depth" );
addItem( RiaDefines::TRUE_VERTICAL_DEPTH, "TRUE_VERTICAL_DEPTH", "True Vertical Depth (MSL)" );
addItem( RiaDefines::PSEUDO_LENGTH, "PSEUDO_LENGTH", "Pseudo Length" );
addItem( RiaDefines::CONNECTION_NUMBER, "CONNECTION_NUMBER", "Connection Number" );
addItem( RiaDefines::TRUE_VERTICAL_DEPTH_RKB, "TRUE_VERTICAL_DEPTH_RKB", "True Vertical Depth (RKB)" );
setDefault( RiaDefines::MEASURED_DEPTH );
addItem( RiaDefines::DepthTypeEnum::MEASURED_DEPTH, "MEASURED_DEPTH", "Measured Depth" );
addItem( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH, "TRUE_VERTICAL_DEPTH", "True Vertical Depth (MSL)" );
addItem( RiaDefines::DepthTypeEnum::PSEUDO_LENGTH, "PSEUDO_LENGTH", "Pseudo Length" );
addItem( RiaDefines::DepthTypeEnum::CONNECTION_NUMBER, "CONNECTION_NUMBER", "Connection Number" );
addItem( RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB, "TRUE_VERTICAL_DEPTH_RKB", "True Vertical Depth (RKB)" );
setDefault( RiaDefines::DepthTypeEnum::MEASURED_DEPTH );
}
template <>
void caf::AppEnum<RiaDefines::PlotAxis>::setUp()
{
addItem( RiaDefines::PLOT_AXIS_LEFT, "PLOT_AXIS_LEFT", "Left" );
addItem( RiaDefines::PLOT_AXIS_RIGHT, "PLOT_AXIS_RIGHT", "Right" );
addItem( RiaDefines::PlotAxis::PLOT_AXIS_LEFT, "PLOT_AXIS_LEFT", "Left" );
addItem( RiaDefines::PlotAxis::PLOT_AXIS_RIGHT, "PLOT_AXIS_RIGHT", "Right" );
setDefault( RiaDefines::PLOT_AXIS_LEFT );
setDefault( RiaDefines::PlotAxis::PLOT_AXIS_LEFT );
}
template <>
void caf::AppEnum<RiaDefines::PhaseType>::setUp()
{
addItem( RiaDefines::OIL_PHASE, "OIL_PHASE", "Oil" );
addItem( RiaDefines::GAS_PHASE, "GAS_PHASE", "Gas" );
addItem( RiaDefines::WATER_PHASE, "WATER_PHASE", "Water" );
setDefault( RiaDefines::OIL_PHASE );
addItem( RiaDefines::PhaseType::OIL_PHASE, "OIL_PHASE", "Oil" );
addItem( RiaDefines::PhaseType::GAS_PHASE, "GAS_PHASE", "Gas" );
addItem( RiaDefines::PhaseType::WATER_PHASE, "WATER_PHASE", "Water" );
setDefault( RiaDefines::PhaseType::OIL_PHASE );
}
template <>
void caf::AppEnum<RiaDefines::WellPathComponentType>::setUp()
{
addItem( RiaDefines::WELL_PATH, "WELL_PATH", "Well Path" );
addItem( RiaDefines::PERFORATION_INTERVAL, "PERFORATION_INTERVAL", "Perforation Interval" );
addItem( RiaDefines::FISHBONES, "FISHBONES", "Fishbones" );
addItem( RiaDefines::FRACTURE, "FRACTURE", "Fracture" );
addItem( RiaDefines::ICD, "ICD", "ICD" );
addItem( RiaDefines::AICD, "AICD", "AICD" );
addItem( RiaDefines::ICV, "ICV", "ICV" );
addItem( RiaDefines::CASING, "CASING", "Casing" );
addItem( RiaDefines::LINER, "LINER", "Liner" );
addItem( RiaDefines::PACKER, "PACKER", "Packer" );
addItem( RiaDefines::UNDEFINED_COMPONENT, "UNDEFINED", "Undefined Component" );
setDefault( RiaDefines::WELL_PATH );
addItem( RiaDefines::WellPathComponentType::WELL_PATH, "WELL_PATH", "Well Path" );
addItem( RiaDefines::WellPathComponentType::PERFORATION_INTERVAL, "PERFORATION_INTERVAL", "Perforation Interval" );
addItem( RiaDefines::WellPathComponentType::FISHBONES, "FISHBONES", "Fishbones" );
addItem( RiaDefines::WellPathComponentType::FRACTURE, "FRACTURE", "Fracture" );
addItem( RiaDefines::WellPathComponentType::ICD, "ICD", "ICD" );
addItem( RiaDefines::WellPathComponentType::AICD, "AICD", "AICD" );
addItem( RiaDefines::WellPathComponentType::ICV, "ICV", "ICV" );
addItem( RiaDefines::WellPathComponentType::CASING, "CASING", "Casing" );
addItem( RiaDefines::WellPathComponentType::LINER, "LINER", "Liner" );
addItem( RiaDefines::WellPathComponentType::PACKER, "PACKER", "Packer" );
addItem( RiaDefines::WellPathComponentType::UNDEFINED_COMPONENT, "UNDEFINED", "Undefined Component" );
setDefault( RiaDefines::WellPathComponentType::WELL_PATH );
}
template <>
void caf::AppEnum<RiaDefines::MeshModeType>::setUp()
{
addItem( RiaDefines::FULL_MESH, "FULL_MESH", "All" );
addItem( RiaDefines::FAULTS_MESH, "FAULTS_MESH", "Faults only" );
addItem( RiaDefines::NO_MESH, "NO_MESH", "None" );
setDefault( RiaDefines::FULL_MESH );
addItem( RiaDefines::MeshModeType::FULL_MESH, "FULL_MESH", "All" );
addItem( RiaDefines::MeshModeType::FAULTS_MESH, "FAULTS_MESH", "Faults only" );
addItem( RiaDefines::MeshModeType::NO_MESH, "NO_MESH", "None" );
setDefault( RiaDefines::MeshModeType::FULL_MESH );
}
} // namespace caf

16
ApplicationCode/Application/RiaDefines.h
View File

@@ -43,7 +43,7 @@ enum class ResultCatType
// WARNING: DO NOT CHANGE THE ORDER WITHOUT KNOWING WHAT YOU ARE DOING!
// You may well change the behaviour of property filters.
enum WellPathComponentType
enum class WellPathComponentType
{
// Production Tube
WELL_PATH,
@@ -61,7 +61,7 @@ enum WellPathComponentType
UNDEFINED_COMPONENT
};
enum MeshModeType
enum class MeshModeType
{
FULL_MESH,
FAULTS_MESH,
@@ -133,7 +133,7 @@ std::vector<QString> wbsAngleResultNames();
std::vector<QString> wbsDerivedResultNames();
// Units and conversions
enum DepthUnitType
enum class DepthUnitType
{
UNIT_METER,
UNIT_FEET,
@@ -141,7 +141,7 @@ enum DepthUnitType
};
// Depth types used for well log plots
enum DepthTypeEnum
enum class DepthTypeEnum
{
MEASURED_DEPTH,
TRUE_VERTICAL_DEPTH,
@@ -151,7 +151,7 @@ enum DepthTypeEnum
};
// Defines relate to plotting
enum PlotAxis
enum class PlotAxis
{
PLOT_AXIS_LEFT,
PLOT_AXIS_RIGHT,
@@ -162,7 +162,7 @@ double minimumDefaultValuePlot();
double minimumDefaultLogValuePlot();
double maximumDefaultValuePlot();
enum PhaseType
enum class PhaseType
{
OIL_PHASE,
GAS_PHASE,
@@ -186,7 +186,7 @@ enum ImportFileType
ImportFileType obtainFileTypeFromFileName( const QString& fileName );
QString defaultDirectoryLabel( ImportFileType fileTypes );
enum CaseType
enum class CaseType
{
UNDEFINED_CASE = -1,
ECLIPSE_RESULT_CASE = 1,
@@ -196,7 +196,7 @@ enum CaseType
GEOMECH_ODB_CASE = 5
};
enum FontSettingType
enum class FontSettingType
{
SCENE_FONT,
ANNOTATION_FONT,

8
ApplicationCode/Application/RiaPreferences.cpp
View File

@@ -995,10 +995,10 @@ bool RiaPreferences::openExportedPdfInViewer() const
std::map<RiaDefines::FontSettingType, RiaFontCache::FontSize> RiaPreferences::defaultFontSizes() const
{
std::map<RiaDefines::FontSettingType, RiaFontCache::FontSize> fontSizes;
fontSizes[RiaDefines::SCENE_FONT] = defaultSceneFontSize();
fontSizes[RiaDefines::ANNOTATION_FONT] = defaultAnnotationFontSize();
fontSizes[RiaDefines::WELL_LABEL_FONT] = defaultWellLabelFontSize();
fontSizes[RiaDefines::PLOT_FONT] = defaultPlotFontSize();
fontSizes[RiaDefines::FontSettingType::SCENE_FONT] = defaultSceneFontSize();
fontSizes[RiaDefines::FontSettingType::ANNOTATION_FONT] = defaultAnnotationFontSize();
fontSizes[RiaDefines::FontSettingType::WELL_LABEL_FONT] = defaultWellLabelFontSize();
fontSizes[RiaDefines::FontSettingType::PLOT_FONT] = defaultPlotFontSize();
return fontSizes;
}

22
ApplicationCode/Application/Tools/RiaColorTables.cpp
View File

@@ -511,17 +511,17 @@ cvf::Color3f RiaColorTables::undefinedCellColor()
//--------------------------------------------------------------------------------------------------
RiaColorTables::WellPathComponentColors RiaColorTables::wellPathComponentColors()
{
return {{RiaDefines::WELL_PATH, cvf::Color3::CEETRON},
{RiaDefines::PERFORATION_INTERVAL, cvf::Color3::DARK_MAGENTA},
{RiaDefines::FISHBONES, cvf::Color3::DARK_GREEN},
{RiaDefines::FRACTURE, cvf::Color3::CRIMSON},
{RiaDefines::ICD, cvf::Color3::DARK_ORANGE},
{RiaDefines::AICD, cvf::Color3::INDIGO},
{RiaDefines::ICV, cvf::Color3::ORCHID},
{RiaDefines::CASING, cvf::Color3::SEA_GREEN},
{RiaDefines::LINER, cvf::Color3::OLIVE},
{RiaDefines::PACKER, cvf::Color3::GRAY},
{RiaDefines::UNDEFINED_COMPONENT, cvf::Color3::MAGENTA}};
return {{RiaDefines::WellPathComponentType::WELL_PATH, cvf::Color3::CEETRON},
{RiaDefines::WellPathComponentType::PERFORATION_INTERVAL, cvf::Color3::DARK_MAGENTA},
{RiaDefines::WellPathComponentType::FISHBONES, cvf::Color3::DARK_GREEN},
{RiaDefines::WellPathComponentType::FRACTURE, cvf::Color3::CRIMSON},
{RiaDefines::WellPathComponentType::ICD, cvf::Color3::DARK_ORANGE},
{RiaDefines::WellPathComponentType::AICD, cvf::Color3::INDIGO},
{RiaDefines::WellPathComponentType::ICV, cvf::Color3::ORCHID},
{RiaDefines::WellPathComponentType::CASING, cvf::Color3::SEA_GREEN},
{RiaDefines::WellPathComponentType::LINER, cvf::Color3::OLIVE},
{RiaDefines::WellPathComponentType::PACKER, cvf::Color3::GRAY},
{RiaDefines::WellPathComponentType::UNDEFINED_COMPONENT, cvf::Color3::MAGENTA}};
}
//--------------------------------------------------------------------------------------------------

10
ApplicationCode/Application/Tools/RiaEclipseUnitTools.cpp
View File

@@ -67,19 +67,19 @@ RiaDefines::DepthUnitType RiaEclipseUnitTools::depthUnit( UnitSystem unit )
switch ( unit )
{
case RiaEclipseUnitTools::UNITS_METRIC:
return RiaDefines::UNIT_METER;
return RiaDefines::DepthUnitType::UNIT_METER;
break;
case RiaEclipseUnitTools::UNITS_FIELD:
return RiaDefines::UNIT_FEET;
return RiaDefines::DepthUnitType::UNIT_FEET;
break;
case RiaEclipseUnitTools::UNITS_LAB:
return RiaDefines::UNIT_NONE;
return RiaDefines::DepthUnitType::UNIT_NONE;
break;
case RiaEclipseUnitTools::UNITS_UNKNOWN:
return RiaDefines::UNIT_NONE;
return RiaDefines::DepthUnitType::UNIT_NONE;
break;
default:
return RiaDefines::UNIT_NONE;
return RiaDefines::DepthUnitType::UNIT_NONE;
break;
}
}

58
ApplicationCode/Application/Tools/RiaWellLogUnitTools.inl
View File

@@ -22,14 +22,13 @@
#include <limits>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template <typename FloatType>
const FloatType RiaWellLogUnitTools<FloatType>::gravityAcceleration()
{
return (FloatType) 9.81;
return (FloatType)9.81;
}
//--------------------------------------------------------------------------------------------------
@@ -136,14 +135,14 @@ QString RiaWellLogUnitTools<FloatType>::pascalUnitStringShort()
//--------------------------------------------------------------------------------------------------
template <typename FloatType>
std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertDepths( const std::vector<FloatType>& depthsIn,
RiaDefines::DepthUnitType unitsIn,
RiaDefines::DepthUnitType unitsOut )
RiaDefines::DepthUnitType unitsIn,
RiaDefines::DepthUnitType unitsOut )
{
if ( unitsOut == RiaDefines::UNIT_METER && unitsIn == RiaDefines::UNIT_FEET )
if ( unitsOut == RiaDefines::DepthUnitType::UNIT_METER && unitsIn == RiaDefines::DepthUnitType::UNIT_FEET )
{
return multiply( depthsIn, RiaEclipseUnitTools::feetPerMeter() );
}
else if ( unitsOut == RiaDefines::UNIT_FEET && unitsIn == RiaDefines::UNIT_METER )
else if ( unitsOut == RiaDefines::DepthUnitType::UNIT_FEET && unitsIn == RiaDefines::DepthUnitType::UNIT_METER )
{
return multiply( depthsIn, RiaEclipseUnitTools::meterPerFeet() );
}
@@ -155,10 +154,10 @@ std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertDepths( const std:
//--------------------------------------------------------------------------------------------------
template <typename FloatType>
bool RiaWellLogUnitTools<FloatType>::convertValues( const std::vector<FloatType>& tvdRKBs,
const std::vector<FloatType>& valuesIn,
std::vector<FloatType>* valuesOut,
const QString& unitsIn,
const QString& unitsOut )
const std::vector<FloatType>& valuesIn,
std::vector<FloatType>* valuesOut,
const QString& unitsIn,
const QString& unitsOut )
{
CAF_ASSERT( valuesOut );
@@ -215,7 +214,7 @@ bool RiaWellLogUnitTools<FloatType>::convertValues( const std::vector<FloatType>
}
else if ( stringsMatch( unitsIn, barUnitString() ) && stringsMatch( unitsOut, barX100UnitString() ) )
{
*valuesOut = multiply( valuesIn, (FloatType) 0.01 );
*valuesOut = multiply( valuesIn, (FloatType)0.01 );
return true;
}
else if ( ( stringsMatch( unitsIn, noUnitString() ) || stringsMatch( unitsIn, sg_emwUnitString() ) ) &&
@@ -230,12 +229,14 @@ bool RiaWellLogUnitTools<FloatType>::convertValues( const std::vector<FloatType>
*valuesOut = convertBarToNormalizedByPP( tvdRKBs, valuesIn );
return true;
}
else if ( (stringsMatch( unitsIn, pascalUnitString()) || stringsMatch( unitsIn, pascalUnitString() ) && stringsMatch( unitsOut, barUnitString() ) ))
else if ( ( stringsMatch( unitsIn, pascalUnitString() ) ||
stringsMatch( unitsIn, pascalUnitString() ) && stringsMatch( unitsOut, barUnitString() ) ) )
{
*valuesOut = multiply( valuesIn, 1.0 / pascalPerBar() );
return true;
}
else if ( stringsMatch( unitsIn, barUnitString() ) && (stringsMatch( unitsIn, pascalUnitString()) || stringsMatch( unitsIn, pascalUnitString() )) )
else if ( stringsMatch( unitsIn, barUnitString() ) &&
( stringsMatch( unitsIn, pascalUnitString() ) || stringsMatch( unitsIn, pascalUnitString() ) ) )
{
*valuesOut = multiply( valuesIn, pascalPerBar() );
return true;
@@ -248,9 +249,9 @@ bool RiaWellLogUnitTools<FloatType>::convertValues( const std::vector<FloatType>
//--------------------------------------------------------------------------------------------------
template <typename FloatType>
bool RiaWellLogUnitTools<FloatType>::convertValues( std::vector<std::pair<FloatType, FloatType>>* measuredDepthsAndValues,
const QString& unitsIn,
const QString& unitsOut,
const RigWellPath* wellPath )
const QString& unitsIn,
const QString& unitsOut,
const RigWellPath* wellPath )
{
CAF_ASSERT( measuredDepthsAndValues );
if ( unitsIn == unitsOut ) return true;
@@ -282,7 +283,8 @@ bool RiaWellLogUnitTools<FloatType>::convertValues( std::vector<std::pair<FloatT
///
//--------------------------------------------------------------------------------------------------
template <typename FloatType>
std::vector<FloatType> RiaWellLogUnitTools<FloatType>::tvdRKBs( const std::vector<FloatType>& measuredDepths, const RigWellPath* wellPath )
std::vector<FloatType>
RiaWellLogUnitTools<FloatType>::tvdRKBs( const std::vector<FloatType>& measuredDepths, const RigWellPath* wellPath )
{
std::vector<double> tvdRKBs( measuredDepths.size(), 0.0 );
for ( size_t i = 0; i < measuredDepths.size(); ++i )
@@ -290,7 +292,7 @@ std::vector<FloatType> RiaWellLogUnitTools<FloatType>::tvdRKBs( const std::vecto
cvf::Vec3d point = wellPath->interpolatedPointAlongWellPath( measuredDepths[i] );
tvdRKBs[i] = -point.z() + wellPath->rkbDiff();
}
return std::vector<FloatType>(tvdRKBs.begin(), tvdRKBs.end());
return std::vector<FloatType>( tvdRKBs.begin(), tvdRKBs.end() );
}
//--------------------------------------------------------------------------------------------------
@@ -298,7 +300,7 @@ std::vector<FloatType> RiaWellLogUnitTools<FloatType>::tvdRKBs( const std::vecto
//--------------------------------------------------------------------------------------------------
template <typename FloatType>
std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertGpcm3ToBar( const std::vector<FloatType>& tvdRKBs,
const std::vector<FloatType>& valuesInGpcm3 )
const std::vector<FloatType>& valuesInGpcm3 )
{
CAF_ASSERT( tvdRKBs.size() == valuesInGpcm3.size() );
@@ -325,7 +327,7 @@ std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertGpcm3ToBar( const
//--------------------------------------------------------------------------------------------------
template <typename FloatType>
std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertBarToGpcm3( const std::vector<FloatType>& tvdRKBs,
const std::vector<FloatType>& valuesInBar )
const std::vector<FloatType>& valuesInBar )
{
CAF_ASSERT( tvdRKBs.size() == valuesInBar.size() );
@@ -350,9 +352,10 @@ std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertBarToGpcm3( const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
template<typename FloatType>
std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertNormalizedByPPToBar( const std::vector<FloatType>& tvdRKBs,
const std::vector<FloatType>& normalizedValues )
template <typename FloatType>
std::vector<FloatType>
RiaWellLogUnitTools<FloatType>::convertNormalizedByPPToBar( const std::vector<FloatType>& tvdRKBs,
const std::vector<FloatType>& normalizedValues )
{
CAF_ASSERT( tvdRKBs.size() == normalizedValues.size() );
@@ -368,8 +371,9 @@ std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertNormalizedByPPToBa
///
//--------------------------------------------------------------------------------------------------
template <typename FloatType>
std::vector<FloatType> RiaWellLogUnitTools<FloatType>::convertBarToNormalizedByPP( const std::vector<FloatType>& tvdRKBs,
const std::vector<FloatType>& valuesInBar )
std::vector<FloatType>
RiaWellLogUnitTools<FloatType>::convertBarToNormalizedByPP( const std::vector<FloatType>& tvdRKBs,
const std::vector<FloatType>& valuesInBar )
{
CAF_ASSERT( tvdRKBs.size() == valuesInBar.size() );
@@ -410,7 +414,7 @@ FloatType RiaWellLogUnitTools<FloatType>::pascalPerBar()
template <typename FloatType>
FloatType RiaWellLogUnitTools<FloatType>::MPaPerBar()
{
return (FloatType) 1.0e-1;
return (FloatType)1.0e-1;
}
//--------------------------------------------------------------------------------------------------
@@ -419,5 +423,5 @@ FloatType RiaWellLogUnitTools<FloatType>::MPaPerBar()
template <typename FloatType>
FloatType RiaWellLogUnitTools<FloatType>::hydrostaticPorePressureBar( FloatType depth )
{
return (FloatType) 1.0 / pascalPerBar() * depth * unitWeightOfWater();
return (FloatType)1.0 / pascalPerBar() * depth * unitWeightOfWater();
}