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

Moved UnitSystem from RiaEclipseUnitTools to RiaDefines. (#7225)

Browse Source 
* Moved UnitSystem from RiaEclipseUnitTools to RiaDefines.
- Renamed UnitSystem to EclipseUnitSystem
- Replaced header includes and removed obsolete includes of RiaEclipseUnitTools.h
* Moved  result name functions into separate file.
* Minor cleanup

Co-authored-by: rubenthoms <rubenthoms@users.noreply.github.com>
Co-authored-by: Magne Sjaastad <magne.sjaastad@ceetronsolutions.com>
Co-authored-by: magnesj <magnesj@users.noreply.github.com>
This commit is contained in:
rubenthoms
2021-01-21 12:58:46 +01:00
committed by GitHub
parent c4c6eb75f2
commit bc81437435
176 changed files with 1470 additions and 1365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterItem.cpp
View File

@@ -17,6 +17,8 @@
/////////////////////////////////////////////////////////////////////////////////
#include "RimPlotDataFilterItem.h"
#include "RiaResultNames.h"
#include "RimAnalysisPlot.h"
#include "RimSummaryAddress.h"
#include "RimSummaryCaseCollection.h"
@@ -288,7 +290,7 @@ QList<caf::PdmOptionItemInfo>
QVariant::fromValue( address ) ) );
}
options.push_front( caf::PdmOptionItemInfo( RiaDefines::undefinedResultName(),
options.push_front( caf::PdmOptionItemInfo( RiaResultNames::undefinedResultName(),
QVariant::fromValue( RifEclipseSummaryAddress() ) ) );
}
}

2
ApplicationLibCode/ProjectDataModel/Annotations/RimAnnotationCollection.h
View File

@@ -18,8 +18,6 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RimAnnotationCollectionBase.h"
#include "cafPdmChildArrayField.h"

2
ApplicationLibCode/ProjectDataModel/Annotations/RimAnnotationCollectionBase.h
View File

@@ -18,8 +18,6 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmChildField.h"
#include "cafPdmField.h"

2
ApplicationLibCode/ProjectDataModel/Annotations/RimAnnotationGroupCollection.h
View File

@@ -18,8 +18,6 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"

2
ApplicationLibCode/ProjectDataModel/CellFilters/RimEclipsePropertyFilter.cpp
View File

@@ -409,7 +409,7 @@ void RimEclipsePropertyFilter::computeResultValueRange()
setCategoryNames( fnVector );
}
else if ( m_resultDefinition->resultVariable() == RiaDefines::completionTypeResultName() )
else if ( m_resultDefinition->resultVariable() == RiaResultNames::completionTypeResultName() )
{
std::vector<RiaDefines::WellPathComponentType> componentTypes =
{ RiaDefines::WellPathComponentType::WELL_PATH,

2
ApplicationLibCode/ProjectDataModel/CellFilters/RimEclipsePropertyFilterCollection.cpp
View File

@@ -127,7 +127,7 @@ bool RimEclipsePropertyFilterCollection::isUsingFormationNames() const
{
if ( propertyFilter->isActive() &&
propertyFilter->resultDefinition()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES &&
propertyFilter->resultDefinition()->resultVariable() != RiaDefines::undefinedResultName() )
propertyFilter->resultDefinition()->resultVariable() != RiaResultNames::undefinedResultName() )
return true;
}

26
ApplicationLibCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.cpp
View File

@@ -20,7 +20,7 @@
#include "RiaApplication.h"
#include "RiaCompletionTypeCalculationScheduler.h"
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RiaFractureDefines.h"
#include "RiaLogging.h"
@@ -139,13 +139,13 @@ std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fractureBorderPolygon() cons
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::changeUnits()
{
if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
convertToUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_FIELD );
convertToUnitSystem( RiaDefines::EclipseUnitSystem::UNITS_FIELD );
}
else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
convertToUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC );
convertToUnitSystem( RiaDefines::EclipseUnitSystem::UNITS_METRIC );
}
this->updateConnectedEditors();
@@ -282,7 +282,7 @@ const RigFractureGrid* RimEllipseFractureTemplate::fractureGrid() const
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::setDefaultValuesFromUnit()
{
if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_width = 0.5;
m_permeability = 80000.0;
@@ -306,12 +306,12 @@ void RimEllipseFractureTemplate::setDefaultValuesFromUnit()
double RimEllipseFractureTemplate::conductivity() const
{
double cond = cvf::UNDEFINED_DOUBLE;
if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
// Conductivity should be md-m, width is in m
cond = m_permeability * m_width;
}
else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
// Conductivity should be md-ft, but width is in inches
cond = m_permeability * RiaEclipseUnitTools::inchToFeet( m_width );
@@ -394,20 +394,20 @@ void RimEllipseFractureTemplate::onLoadDataAndUpdateGeometryHasChanged()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::UnitSystem neededUnit )
void RimEllipseFractureTemplate::convertToUnitSystem( RiaDefines::EclipseUnitSystem neededUnit )
{
if ( m_fractureTemplateUnit() == neededUnit ) return;
setUnitSystem( neededUnit );
RimFractureTemplate::convertToUnitSystem( neededUnit );
if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( neededUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_halfLength = RiaEclipseUnitTools::meterToFeet( m_halfLength );
m_height = RiaEclipseUnitTools::meterToFeet( m_height );
m_width = RiaEclipseUnitTools::meterToInch( m_width );
}
else if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
else if ( neededUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_halfLength = RiaEclipseUnitTools::feetToMeter( m_halfLength );
m_height = RiaEclipseUnitTools::feetToMeter( m_height );
@@ -420,13 +420,13 @@ void RimEllipseFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::UnitS
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_halfLength.uiCapability()->setUiName( "Halflength X<sub>f</sub> [m]" );
m_height.uiCapability()->setUiName( "Height [m]" );
m_width.uiCapability()->setUiName( "Width [m]" );
}
else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_halfLength.uiCapability()->setUiName( "Halflength X<sub>f</sub> [ft]" );
m_height.uiCapability()->setUiName( "Height [ft]" );

2
ApplicationLibCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.h
View File

@@ -62,7 +62,7 @@ public:
MinMaxAccumulator& minMaxAccumulator,
PosNegAccumulator& posNegAccumulator ) const override;
void convertToUnitSystem( RiaEclipseUnitTools::UnitSystem neededUnit ) override;
void convertToUnitSystem( RiaDefines::EclipseUnitSystem neededUnit ) override;
void loadDataAndUpdate() override;
std::vector<std::pair<QString, QString>> uiResultNamesWithUnit() const override;

4
ApplicationLibCode/ProjectDataModel/Completions/RimFishboneWellPathCollection.h
View File

@@ -23,7 +23,7 @@
#include "RimFishboneWellPath.h"
#include "RimFishbonesPipeProperties.h"
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmChildField.h"
@@ -47,7 +47,7 @@ public:
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
std::vector<const RimFishboneWellPath*> wellPaths() const;
double holeDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double holeDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
return m_pipeProperties->holeDiameter( unitSystem );
}

18
ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesCollection.cpp
View File

@@ -18,6 +18,8 @@
#include "RimFishbonesCollection.h"
#include "RiaEclipseUnitTools.h"
#include "RifWellPathImporter.h"
#include "RigWellPath.h"
@@ -116,12 +118,12 @@ void RimFishbonesCollection::defineUiOrdering( QString uiConfigName, caf::PdmUiO
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_startMD.uiCapability()->setUiName( "Start MD [m]" );
m_mainBoreDiameter.uiCapability()->setUiName( "Main Bore Diameter [m]" );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_startMD.uiCapability()->setUiName( "Start MD [ft]" );
m_mainBoreDiameter.uiCapability()->setUiName( "Main Bore Diameter [ft]" );
@@ -283,17 +285,17 @@ double RimFishbonesCollection::startMD() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFishbonesCollection::mainBoreDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimFishbonesCollection::mainBoreDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted( wellPath );
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD &&
unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return RiaEclipseUnitTools::feetToMeter( m_mainBoreDiameter() );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC &&
unitSystem == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::meterToFeet( m_mainBoreDiameter() );
}
@@ -309,7 +311,7 @@ void RimFishbonesCollection::setUnitSystemSpecificDefaults()
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_mainBoreDiameter = 0.216;
}

4
ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesCollection.h
View File

@@ -21,7 +21,7 @@
#include "RimCheckableNamedObject.h"
#include "RimMswCompletionParameters.h"
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmChildField.h"
@@ -54,7 +54,7 @@ public:
void recalculateStartMD();
double startMD() const;
double mainBoreSkinFactor() const { return m_skinFactor; }
double mainBoreDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
double mainBoreDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const;
void setUnitSystemSpecificDefaults();
protected:

32
ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesMultipleSubs.cpp
View File

@@ -242,13 +242,13 @@ double RimFishbonesMultipleSubs::buildAngle() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFishbonesMultipleSubs::tubingDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimFishbonesMultipleSubs::tubingDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted( wellPath );
if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::inchToMeter( m_lateralTubingDiameter() );
}
@@ -257,9 +257,9 @@ double RimFishbonesMultipleSubs::tubingDiameter( RiaEclipseUnitTools::UnitSystem
return m_lateralTubingDiameter() / 1000;
}
}
else if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return RiaEclipseUnitTools::meterToFeet( m_lateralTubingDiameter() / 1000 );
}
@@ -275,7 +275,7 @@ double RimFishbonesMultipleSubs::tubingDiameter( RiaEclipseUnitTools::UnitSystem
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFishbonesMultipleSubs::effectiveDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimFishbonesMultipleSubs::effectiveDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
double innerRadius = tubingDiameter( unitSystem ) / 2;
double outerRadius = holeDiameter( unitSystem ) / 2;
@@ -292,17 +292,17 @@ double RimFishbonesMultipleSubs::effectiveDiameter( RiaEclipseUnitTools::UnitSys
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFishbonesMultipleSubs::openHoleRoughnessFactor( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimFishbonesMultipleSubs::openHoleRoughnessFactor( RiaDefines::EclipseUnitSystem unitSystem ) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted( wellPath );
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD &&
unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return RiaEclipseUnitTools::feetToMeter( m_lateralOpenHoleRoghnessFactor() );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC &&
unitSystem == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::meterToFeet( m_lateralOpenHoleRoghnessFactor() );
}
@@ -312,7 +312,7 @@ double RimFishbonesMultipleSubs::openHoleRoughnessFactor( RiaEclipseUnitTools::U
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFishbonesMultipleSubs::icdOrificeDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimFishbonesMultipleSubs::icdOrificeDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted( wellPath );
@@ -423,7 +423,7 @@ void RimFishbonesMultipleSubs::setUnitSystemSpecificDefaults()
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_lateralLength = "11";
m_lateralBuildAngle = 6.0;
@@ -432,7 +432,7 @@ void RimFishbonesMultipleSubs::setUnitSystemSpecificDefaults()
m_lateralTubingRoghnessFactor = 1e-05;
m_icdOrificeDiameter = 7;
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_lateralLength = "36";
m_lateralBuildAngle = 1.83;
@@ -560,7 +560,7 @@ void RimFishbonesMultipleSubs::defineUiOrdering( QString uiConfigName, caf::PdmU
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_lateralLength.uiCapability()->setUiName( "Length(s) [m]" );
m_lateralBuildAngle.uiCapability()->setUiName( "Build Angle [deg/m]" );
@@ -570,7 +570,7 @@ void RimFishbonesMultipleSubs::defineUiOrdering( QString uiConfigName, caf::PdmU
m_icdOrificeDiameter.uiCapability()->setUiName( "ICD Orifice Diameter [mm]" );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_lateralLength.uiCapability()->setUiName( "Length(s) [ft]" );
m_lateralBuildAngle.uiCapability()->setUiName( "Build Angle [deg/ft]" );

12
ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesMultipleSubs.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "Rim3dPropertiesInterface.h"
#include "RimCheckableNamedObject.h"
@@ -87,15 +87,15 @@ public:
double exitAngle() const;
double buildAngle() const;
double tubingDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
double holeDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double tubingDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const;
double holeDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
return m_pipeProperties()->holeDiameter( unitSystem );
}
double effectiveDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
double effectiveDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const;
double skinFactor() const { return m_pipeProperties()->skinFactor(); }
double openHoleRoughnessFactor( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
double icdOrificeDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
double openHoleRoughnessFactor( RiaDefines::EclipseUnitSystem unitSystem ) const;
double icdOrificeDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const;
double icdFlowCoefficient() const;
size_t icdCount() const;
std::vector<double> lateralLengths() const;

20
ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesPipeProperties.cpp
View File

@@ -18,6 +18,8 @@
#include "RimFishbonesPipeProperties.h"
#include "RiaEclipseUnitTools.h"
#include "RimWellPath.h"
#include <cstdlib>
@@ -45,13 +47,13 @@ RimFishbonesPipeProperties::~RimFishbonesPipeProperties()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimFishbonesPipeProperties::holeDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimFishbonesPipeProperties::holeDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted( wellPath );
if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::inchToMeter( m_lateralHoleDiameter() );
}
@@ -60,9 +62,9 @@ double RimFishbonesPipeProperties::holeDiameter( RiaEclipseUnitTools::UnitSystem
return m_lateralHoleDiameter() / 1000;
}
}
else if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return RiaEclipseUnitTools::meterToFeet( m_lateralHoleDiameter() / 1000 );
}
@@ -84,11 +86,11 @@ void RimFishbonesPipeProperties::setUnitSystemSpecificDefaults()
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_lateralHoleDiameter = 12.5;
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_lateralHoleDiameter = 0.5;
}
@@ -105,11 +107,11 @@ void RimFishbonesPipeProperties::defineUiOrdering( QString uiConfigName, caf::Pd
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_lateralHoleDiameter.uiCapability()->setUiName( "Hole Diameter [mm]" );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_lateralHoleDiameter.uiCapability()->setUiName( "Hole Diameter [in]" );
}

4
ApplicationLibCode/ProjectDataModel/Completions/RimFishbonesPipeProperties.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cvfColor3.h"
#include "cvfVector3.h"
@@ -42,7 +42,7 @@ public:
~RimFishbonesPipeProperties() override;
double skinFactor() const { return m_skinFactor(); }
double holeDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
double holeDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const;
void setUnitSystemSpecificDefaults();

20
ApplicationLibCode/ProjectDataModel/Completions/RimFracture.cpp
View File

@@ -22,7 +22,7 @@
#include "RiaApplication.h"
#include "RiaColorTables.h"
#include "RiaCompletionTypeCalculationScheduler.h"
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RiaLogging.h"
#include "Riu3DMainWindowTools.h"
@@ -138,7 +138,7 @@ RimFracture::RimFracture()
CAF_PDM_InitField( &m_fractureUnit,
"FractureUnit",
caf::AppEnum<RiaEclipseUnitTools::UnitSystem>( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC ),
caf::AppEnum<RiaDefines::EclipseUnitSystem>( RiaDefines::EclipseUnitSystem::UNITS_METRIC ),
"Fracture Unit System",
"",
"",
@@ -230,7 +230,7 @@ void RimFracture::fieldChangedByUi( const caf::PdmFieldHandle* changedField, con
{
if ( fractureUnit() != m_fractureTemplate->fractureTemplateUnit() )
{
QString fractureUnitText = RiaEclipseUnitTools::UnitSystemType::uiText( fractureUnit() );
QString fractureUnitText = caf::AppEnum<RiaDefines::EclipseUnitSystem>::uiText( fractureUnit() );
QString warningText =
QString( "Using a fracture template defined in a different unit is not supported.\n\nPlease select a "
@@ -465,11 +465,11 @@ cvf::BoundingBox RimFracture::boundingBoxInDomainCoords() const
//--------------------------------------------------------------------------------------------------
double RimFracture::wellRadius() const
{
if ( m_fractureUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( m_fractureUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return m_wellDiameter / 2.0;
}
else if ( m_fractureUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( m_fractureUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::inchToFeet( m_wellDiameter / 2.0 );
}
@@ -533,7 +533,7 @@ void RimFracture::setFractureTemplateNoUpdate( RimFractureTemplate* fractureTemp
{
if ( fractureTemplate && fractureTemplate->fractureTemplateUnit() != fractureUnit() )
{
QString fractureUnitText = RiaEclipseUnitTools::UnitSystemType::uiText( fractureUnit() );
QString fractureUnitText = caf::AppEnum<RiaDefines::EclipseUnitSystem>::uiText( fractureUnit() );
QString warningText =
QString( "Using a fracture template defined in a different unit is not supported.\n\nPlease select a "
@@ -641,12 +641,12 @@ QList<caf::PdmOptionItemInfo> RimFracture::calculateValueOptions( const caf::Pdm
//--------------------------------------------------------------------------------------------------
void RimFracture::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
if ( m_fractureUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( m_fractureUnit() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_wellDiameter.uiCapability()->setUiName( "Well Diameter [m]" );
m_perforationLength.uiCapability()->setUiName( "Perforation Length [m]" );
}
else if ( m_fractureUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( m_fractureUnit() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_wellDiameter.uiCapability()->setUiName( "Well Diameter [inches]" );
m_perforationLength.uiCapability()->setUiName( "Perforation Length [ft]" );
@@ -776,7 +776,7 @@ void RimFracture::setAnchorPosition( const cvf::Vec3d& pos )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystem RimFracture::fractureUnit() const
RiaDefines::EclipseUnitSystem RimFracture::fractureUnit() const
{
return m_fractureUnit();
}
@@ -784,7 +784,7 @@ RiaEclipseUnitTools::UnitSystem RimFracture::fractureUnit() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFracture::setFractureUnit( RiaEclipseUnitTools::UnitSystem unitSystem )
void RimFracture::setFractureUnit( RiaDefines::EclipseUnitSystem unitSystem )
{
m_fractureUnit = unitSystem;
}

24
ApplicationLibCode/ProjectDataModel/Completions/RimFracture.h
View File

@@ -19,7 +19,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "Rim3dPropertiesInterface.h"
#include "RimCheckableNamedObject.h"
@@ -83,11 +83,11 @@ public:
void setStimPlanTimeIndexToPlot( int timeIndex );
double wellRadius() const;
cvf::Vec3d anchorPosition() const;
void setAnchorPosition( const cvf::Vec3d& pos );
RiaEclipseUnitTools::UnitSystem fractureUnit() const;
void setFractureUnit( RiaEclipseUnitTools::UnitSystem unitSystem );
double wellRadius() const;
cvf::Vec3d anchorPosition() const;
void setAnchorPosition( const cvf::Vec3d& pos );
RiaDefines::EclipseUnitSystem fractureUnit() const;
void setFractureUnit( RiaDefines::EclipseUnitSystem unitSystem );
bool isEclipseCellOpenForFlow( const RigMainGrid* mainGrid,
const std::set<size_t>& reservoirCellIndicesOpenForFlow,
@@ -149,12 +149,12 @@ private:
cvf::BoundingBox boundingBoxInDomainCoords() const override;
protected:
caf::PdmPtrField<RimFractureTemplate*> m_fractureTemplate;
caf::PdmField<bool> m_editFractureTemplate;
caf::PdmField<bool> m_createEllipseFractureTemplate;
caf::PdmField<bool> m_createStimPlanFractureTemplate;
caf::PdmProxyValueField<cvf::Vec3d> m_uiAnchorPosition;
caf::PdmField<RiaEclipseUnitTools::UnitSystemType> m_fractureUnit;
caf::PdmPtrField<RimFractureTemplate*> m_fractureTemplate;
caf::PdmField<bool> m_editFractureTemplate;
caf::PdmField<bool> m_createEllipseFractureTemplate;
caf::PdmField<bool> m_createStimPlanFractureTemplate;
caf::PdmProxyValueField<cvf::Vec3d> m_uiAnchorPosition;
caf::PdmField<caf::AppEnum<RiaDefines::EclipseUnitSystem>> m_fractureUnit;
caf::PdmProxyValueField<QString> m_uiWellPathAzimuth;
caf::PdmProxyValueField<QString> m_uiWellFractureAzimuthDiff;

26
ApplicationLibCode/ProjectDataModel/Completions/RimFractureTemplate.cpp
View File

@@ -18,7 +18,9 @@
#include "RimFractureTemplate.h"
#include "RiaEclipseUnitTools.h"
#include "RiaFractureDefines.h"
#include "RigTesselatorTools.h"
#include "RimFracture.h"
@@ -120,7 +122,7 @@ RimFractureTemplate::RimFractureTemplate()
CAF_PDM_InitField( &m_fractureTemplateUnit,
"UnitSystem",
caf::AppEnum<RiaEclipseUnitTools::UnitSystem>( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN ),
caf::AppEnum<RiaDefines::EclipseUnitSystem>( RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN ),
"Units System",
"",
"",
@@ -252,7 +254,7 @@ void RimFractureTemplate::setName( const QString& name )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureTemplate::setUnitSystem( RiaEclipseUnitTools::UnitSystemType unitSystem )
void RimFractureTemplate::setUnitSystem( caf::AppEnum<RiaDefines::EclipseUnitSystem> unitSystem )
{
m_fractureTemplateUnit = unitSystem;
}
@@ -276,7 +278,7 @@ RimFractureTemplate::FracOrientationEnum RimFractureTemplate::orientationType()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimFractureTemplate::fractureTemplateUnit() const
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimFractureTemplate::fractureTemplateUnit() const
{
return m_fractureTemplateUnit();
}
@@ -475,13 +477,13 @@ void RimFractureTemplate::defineEditorAttribute( const caf::PdmFieldHandle* fiel
//--------------------------------------------------------------------------------------------------
void RimFractureTemplate::prepareFieldsForUiDisplay()
{
if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( m_fractureTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_wellDiameter.uiCapability()->setUiName( "Well Diameter [m]" );
m_perforationLength.uiCapability()->setUiName( "Perforation Length [m]" );
m_fractureWidth.uiCapability()->setUiName( "Fracture Width [m]" );
}
else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( m_fractureTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_wellDiameter.uiCapability()->setUiName( "Well Diameter [inches]" );
m_perforationLength.uiCapability()->setUiName( "Perforation Length [ft]" );
@@ -752,15 +754,15 @@ double RimFractureTemplate::computeKh( const RimFracture* fractureInstance ) con
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::UnitSystem neededUnit )
void RimFractureTemplate::convertToUnitSystem( RiaDefines::EclipseUnitSystem neededUnit )
{
if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( neededUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_perforationLength = RiaEclipseUnitTools::feetToMeter( m_perforationLength );
m_wellDiameter = RiaEclipseUnitTools::inchToMeter( m_wellDiameter );
m_fractureWidth = RiaEclipseUnitTools::feetToMeter( m_fractureWidth );
}
else if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( neededUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_perforationLength = RiaEclipseUnitTools::meterToFeet( m_perforationLength );
m_wellDiameter = RiaEclipseUnitTools::meterToInch( m_wellDiameter );
@@ -912,11 +914,11 @@ QString RimFractureTemplate::nameAndUnit() const
{
QString decoratedName;
if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( m_fractureTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
decoratedName += "[M] - ";
}
else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( m_fractureTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
decoratedName += "[F] - ";
}
@@ -979,11 +981,11 @@ float RimFractureTemplate::skinFactor() const
//--------------------------------------------------------------------------------------------------
void RimFractureTemplate::setDefaultWellDiameterFromUnit()
{
if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( m_fractureTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_wellDiameter = 8.5;
}
else if ( m_fractureTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
else if ( m_fractureTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_wellDiameter = 0.216;
}

38
ApplicationLibCode/ProjectDataModel/Completions/RimFractureTemplate.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cafAppEnum.h"
#include "cafPdmChildField.h"
@@ -127,13 +127,13 @@ public:
QString name() const;
QString nameAndUnit() const;
RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit() const;
FracOrientationEnum orientationType() const;
float azimuthAngle() const;
float skinFactor() const;
double wellDiameter() const;
FracConductivityEnum conductivityType() const;
double perforationLength() const;
caf::AppEnum<RiaDefines::EclipseUnitSystem> fractureTemplateUnit() const;
FracOrientationEnum orientationType() const;
float azimuthAngle() const;
float skinFactor() const;
double wellDiameter() const;
FracConductivityEnum conductivityType() const;
double perforationLength() const;
virtual void fractureTriangleGeometry( std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices ) const = 0;
@@ -149,12 +149,12 @@ public:
virtual std::vector<std::pair<QString, QString>> uiResultNamesWithUnit() const = 0;
void setName( const QString& name );
void setUnitSystem( RiaEclipseUnitTools::UnitSystemType unitSystem );
void setUnitSystem( caf::AppEnum<RiaDefines::EclipseUnitSystem> unitSystem );
void setDefaultWellDiameterFromUnit();
bool isNonDarcyFlowEnabled() const;
virtual void convertToUnitSystem( RiaEclipseUnitTools::UnitSystem neededUnit );
virtual void convertToUnitSystem( RiaDefines::EclipseUnitSystem neededUnit );
virtual void loadDataAndUpdate() = 0;
@@ -200,15 +200,15 @@ protected:
caf::PdmField<QString> m_name;
caf::PdmProxyValueField<QString> m_nameAndUnit;
caf::PdmField<RiaEclipseUnitTools::UnitSystemType> m_fractureTemplateUnit;
caf::PdmField<caf::AppEnum<FracOrientationEnum>> m_orientationType;
caf::PdmField<float> m_azimuthAngle;
caf::PdmField<float> m_skinFactor;
caf::PdmField<double> m_perforationLength;
caf::PdmField<double> m_perforationEfficiency;
caf::PdmField<double> m_wellDiameter;
caf::PdmField<caf::AppEnum<FracConductivityEnum>> m_conductivityType;
caf::PdmChildField<RimFractureContainment*> m_fractureContainment;
caf::PdmField<caf::AppEnum<RiaDefines::EclipseUnitSystem>> m_fractureTemplateUnit;
caf::PdmField<caf::AppEnum<FracOrientationEnum>> m_orientationType;
caf::PdmField<float> m_azimuthAngle;
caf::PdmField<float> m_skinFactor;
caf::PdmField<double> m_perforationLength;
caf::PdmField<double> m_perforationEfficiency;
caf::PdmField<double> m_wellDiameter;
caf::PdmField<caf::AppEnum<FracConductivityEnum>> m_conductivityType;
caf::PdmChildField<RimFractureContainment*> m_fractureContainment;
caf::PdmField<caf::AppEnum<NonDarcyFlowEnum>> m_nonDarcyFlowType;
caf::PdmField<double> m_userDefinedDFactor;

18
ApplicationLibCode/ProjectDataModel/Completions/RimFractureTemplateCollection.cpp
View File

@@ -54,7 +54,7 @@ RimFractureTemplateCollection::RimFractureTemplateCollection()
CAF_PDM_InitField( &m_defaultUnitsForFracTemplates,
"DefaultUnitForTemplates",
caf::AppEnum<RiaEclipseUnitTools::UnitSystem>( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC ),
caf::AppEnum<RiaDefines::EclipseUnitSystem>( RiaDefines::EclipseUnitSystem::UNITS_METRIC ),
"Default unit system for fracture templates",
"",
"",
@@ -128,7 +128,7 @@ void RimFractureTemplateCollection::addFractureTemplate( RimFractureTemplate* te
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimFractureTemplateCollection::defaultUnitSystemType() const
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimFractureTemplateCollection::defaultUnitSystemType() const
{
return m_defaultUnitsForFracTemplates;
}
@@ -141,7 +141,7 @@ void RimFractureTemplateCollection::setDefaultUnitSystemBasedOnLoadedCases()
RimProject* proj = RimProject::current();
auto commonUnitSystem = proj->commonUnitSystemForAllCases();
if ( commonUnitSystem != RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
if ( commonUnitSystem != RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN )
{
m_defaultUnitsForFracTemplates = commonUnitSystem;
}
@@ -150,7 +150,7 @@ void RimFractureTemplateCollection::setDefaultUnitSystemBasedOnLoadedCases()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimFractureTemplate* RimFractureTemplateCollection::firstFractureOfUnit( RiaEclipseUnitTools::UnitSystem unitSet ) const
RimFractureTemplate* RimFractureTemplateCollection::firstFractureOfUnit( RiaDefines::EclipseUnitSystem unitSet ) const
{
for ( RimFractureTemplate* f : m_fractureDefinitions() )
{
@@ -241,14 +241,14 @@ void RimFractureTemplateCollection::createAndAssignTemplateCopyForNonMatchingUni
caf::PdmDefaultObjectFactory::instance() ) );
auto currentUnit = fractureTemplate->fractureTemplateUnit();
auto neededUnit = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
if ( currentUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
auto neededUnit = RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
if ( currentUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
neededUnit = RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
neededUnit = RiaDefines::EclipseUnitSystem::UNITS_FIELD;
}
else if ( currentUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( currentUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
neededUnit = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
neededUnit = RiaDefines::EclipseUnitSystem::UNITS_METRIC;
}
templateWithMatchingUnit->convertToUnitSystem( neededUnit );

12
ApplicationLibCode/ProjectDataModel/Completions/RimFractureTemplateCollection.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmField.h"
@@ -44,10 +44,10 @@ public:
RimEllipseFractureTemplate* addDefaultEllipseTemplate();
void addFractureTemplate( RimFractureTemplate* templ );
RiaEclipseUnitTools::UnitSystemType defaultUnitSystemType() const;
void setDefaultUnitSystemBasedOnLoadedCases();
caf::AppEnum<RiaDefines::EclipseUnitSystem> defaultUnitSystemType() const;
void setDefaultUnitSystemBasedOnLoadedCases();
RimFractureTemplate* firstFractureOfUnit( RiaEclipseUnitTools::UnitSystem unitSet ) const;
RimFractureTemplate* firstFractureOfUnit( RiaDefines::EclipseUnitSystem unitSet ) const;
std::vector<std::pair<QString, QString>> resultNamesAndUnits() const;
void computeMinMax( const QString& uiResultName,
@@ -71,8 +71,8 @@ protected:
private:
int nextFractureTemplateId();
caf::PdmChildArrayField<RimFractureTemplate*> m_fractureDefinitions;
caf::PdmField<RiaEclipseUnitTools::UnitSystemType> m_defaultUnitsForFracTemplates;
caf::PdmChildArrayField<RimFractureTemplate*> m_fractureDefinitions;
caf::PdmField<caf::AppEnum<RiaDefines::EclipseUnitSystem>> m_defaultUnitsForFracTemplates;
caf::PdmField<int> m_nextValidFractureTemplateId; // Unique fracture template ID within a project, used to identify
// a fracture template
};

34
ApplicationLibCode/ProjectDataModel/Completions/RimMswCompletionParameters.cpp
View File

@@ -17,6 +17,8 @@
/////////////////////////////////////////////////////////////////////////////////
#include "RimMswCompletionParameters.h"
#include "RiaEclipseUnitTools.h"
#include "RimWellPath.h"
#include "cafPdmUiObjectEditorHandle.h"
@@ -123,17 +125,17 @@ double RimMswCompletionParameters::manualReferenceMD() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimMswCompletionParameters::linerDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimMswCompletionParameters::linerDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted( wellPath );
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD &&
unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return RiaEclipseUnitTools::feetToMeter( m_linerDiameter() );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC &&
unitSystem == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::meterToFeet( m_linerDiameter() );
}
@@ -143,9 +145,9 @@ double RimMswCompletionParameters::linerDiameter( RiaEclipseUnitTools::UnitSyste
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimMswCompletionParameters::defaultLinerDiameter( RiaEclipseUnitTools::UnitSystem unitSystem )
double RimMswCompletionParameters::defaultLinerDiameter( RiaDefines::EclipseUnitSystem unitSystem )
{
if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return 0.152;
}
@@ -158,17 +160,17 @@ double RimMswCompletionParameters::defaultLinerDiameter( RiaEclipseUnitTools::Un
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimMswCompletionParameters::roughnessFactor( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimMswCompletionParameters::roughnessFactor( RiaDefines::EclipseUnitSystem unitSystem ) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted( wellPath );
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD &&
unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return RiaEclipseUnitTools::feetToMeter( m_roughnessFactor() );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC &&
unitSystem == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::meterToFeet( m_roughnessFactor() );
}
@@ -178,9 +180,9 @@ double RimMswCompletionParameters::roughnessFactor( RiaEclipseUnitTools::UnitSys
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimMswCompletionParameters::defaultRoughnessFactor( RiaEclipseUnitTools::UnitSystem unitSystem )
double RimMswCompletionParameters::defaultRoughnessFactor( RiaDefines::EclipseUnitSystem unitSystem )
{
if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return 1.0e-5;
}
@@ -292,12 +294,12 @@ void RimMswCompletionParameters::defineUiOrdering( QString uiConfigName, caf::Pd
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_linerDiameter.uiCapability()->setUiName( "Liner Inner Diameter [m]" );
m_roughnessFactor.uiCapability()->setUiName( "Roughness Factor [m]" );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_linerDiameter.uiCapability()->setUiName( "Liner Inner Diameter [ft]" );
m_roughnessFactor.uiCapability()->setUiName( "Roughness Factor [ft]" );

10
ApplicationLibCode/ProjectDataModel/Completions/RimMswCompletionParameters.h
View File

@@ -17,7 +17,7 @@
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
@@ -56,10 +56,10 @@ public:
ReferenceMDType referenceMDType() const;
double manualReferenceMD() const;
double linerDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
static double defaultLinerDiameter( RiaEclipseUnitTools::UnitSystem unitSystem );
double roughnessFactor( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
static double defaultRoughnessFactor( RiaEclipseUnitTools::UnitSystem unitSystem );
double linerDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const;
static double defaultLinerDiameter( RiaDefines::EclipseUnitSystem unitSystem );
double roughnessFactor( RiaDefines::EclipseUnitSystem unitSystem ) const;
static double defaultRoughnessFactor( RiaDefines::EclipseUnitSystem unitSystem );
PressureDropEnum pressureDrop() const;
LengthAndDepthEnum lengthAndDepth() const;
double maxSegmentLength() const;

8
ApplicationLibCode/ProjectDataModel/Completions/RimMultipleValveLocations.cpp
View File

@@ -20,6 +20,8 @@
#include "RigWellPath.h"
#include "RiaEclipseUnitTools.h"
#include "RimFishbonesMultipleSubs.h"
#include "RimPerforationInterval.h"
#include "RimWellPath.h"
@@ -225,14 +227,14 @@ void RimMultipleValveLocations::defineUiOrdering( QString uiConfigName, caf::Pdm
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_locationOfValves.uiCapability()->setUiName( "Measured Depths [m]" );
m_rangeStart.uiCapability()->setUiName( "Start MD [m]" );
m_rangeEnd.uiCapability()->setUiName( "End MD [m]" );
m_rangeValveSpacing.uiCapability()->setUiName( "Spacing [m]" );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_locationOfValves.uiCapability()->setUiName( "Measured Depths [ft]" );
m_rangeStart.uiCapability()->setUiName( "Start MD [ft]" );
@@ -326,7 +328,7 @@ void RimMultipleValveLocations::fieldChangedByUi( const caf::PdmFieldHandle* cha
RimWellPath* wellPath = nullptr;
this->firstAncestorOrThisOfTypeAsserted( wellPath );
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
double minimumDistanceFeet = RiaEclipseUnitTools::meterToFeet( minimumDistanceMeter );
m_rangeValveSpacing = cvf::Math::clamp( m_rangeValveSpacing(),

2
ApplicationLibCode/ProjectDataModel/Completions/RimNonDarcyPerforationParameters.h
View File

@@ -17,8 +17,6 @@
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiaEclipseUnitTools.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmUiGroup.h"

20
ApplicationLibCode/ProjectDataModel/Completions/RimPerforationInterval.cpp
View File

@@ -20,6 +20,8 @@
#include "RimPerforationInterval.h"
#include "RiaColorTables.h"
#include "RiaEclipseUnitTools.h"
#include "RigCaseCellResultsData.h"
#include "RigWellPath.h"
@@ -131,17 +133,17 @@ void RimPerforationInterval::setSkinFactor( double skinFactor )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimPerforationInterval::diameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimPerforationInterval::diameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted( wellPath );
if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC &&
wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC &&
wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::feetToMeter( m_diameter() );
}
else if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
else if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_FIELD &&
wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return RiaEclipseUnitTools::meterToFeet( m_diameter() );
}
@@ -198,11 +200,11 @@ void RimPerforationInterval::setUnitSystemSpecificDefaults()
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_diameter = 0.216;
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_diameter = 0.709;
}
@@ -343,13 +345,13 @@ void RimPerforationInterval::defineUiOrdering( QString uiConfigName, caf::PdmUiO
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_startMD.uiCapability()->setUiName( "Start MD [m]" );
m_endMD.uiCapability()->setUiName( "End MD [m]" );
m_diameter.uiCapability()->setUiName( "Diameter [m]" );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_startMD.uiCapability()->setUiName( "Start MD [ft]" );
m_endMD.uiCapability()->setUiName( "End MD [ft]" );

4
ApplicationLibCode/ProjectDataModel/Completions/RimPerforationInterval.h
View File

@@ -23,7 +23,7 @@
#include "RimCheckableNamedObject.h"
#include "RimWellPathComponentInterface.h"
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmField.h"
@@ -55,7 +55,7 @@ public:
void setDiameter( double diameter );
void setSkinFactor( double skinFactor );
double diameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
double diameter( RiaDefines::EclipseUnitSystem unitSystem ) const;
double skinFactor() const;
bool isActiveOnDate( const QDateTime& date ) const;

27
ApplicationLibCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp
View File

@@ -20,6 +20,7 @@
#include "RiaApplication.h"
#include "RiaCompletionTypeCalculationScheduler.h"
#include "RiaEclipseUnitTools.h"
#include "RiaFractureDefines.h"
#include "RiaLogging.h"
#include "RiaWeightedGeometricMeanCalculator.h"
@@ -292,7 +293,7 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
{
setDefaultConductivityResultIfEmpty();
if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN )
{
setUnitSystem( m_stimPlanFractureDefinitionData->unitSet() );
}
@@ -306,7 +307,7 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
}
else
{
setUnitSystem( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN );
setUnitSystem( RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN );
m_readError = true;
}
@@ -432,11 +433,11 @@ void RimStimPlanFractureTemplate::computePerforationLength()
}
}
if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC && m_perforationLength < 10 )
if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_METRIC && m_perforationLength < 10 )
{
m_perforationLength = 10;
}
else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD &&
else if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_FIELD &&
m_perforationLength < RiaEclipseUnitTools::meterToFeet( 10 ) )
{
m_perforationLength = std::round( RiaEclipseUnitTools::meterToFeet( 10 ) );
@@ -447,22 +448,22 @@ void RimStimPlanFractureTemplate::computePerforationLength()
///
//--------------------------------------------------------------------------------------------------
std::vector<double>
RimStimPlanFractureTemplate::fractureGridResultsForUnitSystem( const QString& resultName,
const QString& unitName,
size_t timeStepIndex,
RiaEclipseUnitTools::UnitSystem requiredUnitSystem ) const
RimStimPlanFractureTemplate::fractureGridResultsForUnitSystem( const QString& resultName,
const QString& unitName,
size_t timeStepIndex,
RiaDefines::EclipseUnitSystem requiredUnitSystem ) const
{
auto resultValues =
m_stimPlanFractureDefinitionData->fractureGridResults( resultName, unitName, m_activeTimeStepIndex );
if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
for ( auto& v : resultValues )
{
v = RiaEclipseUnitTools::convertToMeter( v, unitName );
}
}
else if ( fractureTemplateUnit() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( fractureTemplateUnit() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
for ( auto& v : resultValues )
{
@@ -797,7 +798,7 @@ bool RimStimPlanFractureTemplate::showStimPlanMesh() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::UnitSystem neededUnit )
void RimStimPlanFractureTemplate::convertToUnitSystem( RiaDefines::EclipseUnitSystem neededUnit )
{
if ( m_fractureTemplateUnit() == neededUnit ) return;
@@ -809,11 +810,11 @@ void RimStimPlanFractureTemplate::convertToUnitSystem( RiaEclipseUnitTools::Unit
if ( m_stimPlanFractureDefinitionData.isNull() ) return;
if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( neededUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_wellPathDepthAtFracture = RiaEclipseUnitTools::meterToFeet( m_wellPathDepthAtFracture );
}
else if ( neededUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
else if ( neededUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_wellPathDepthAtFracture = RiaEclipseUnitTools::feetToMeter( m_wellPathDepthAtFracture );
}

12
ApplicationLibCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.h
View File

@@ -73,7 +73,7 @@ public:
std::vector<double> timeSteps();
std::vector<std::pair<QString, QString>> uiResultNamesWithUnit() const override;
std::vector<std::vector<double>>
resultValues( const QString& uiResultName, const QString& unitName, size_t timeStepIndex ) const;
resultValues( const QString& uiResultName, const QString& unitName, size_t timeStepIndex ) const;
std::vector<double> fractureGridResults( const QString& resultName, const QString& unitName, size_t timeStepIndex ) const;
bool hasConductivity() const;
double resultValueAtIJ( const QString& uiResultName, const QString& unitName, size_t timeStepIndex, size_t i, size_t j );
@@ -89,7 +89,7 @@ public:
bool showStimPlanMesh() const;
void convertToUnitSystem( RiaEclipseUnitTools::UnitSystem neededUnit ) override;
void convertToUnitSystem( RiaDefines::EclipseUnitSystem neededUnit ) override;
protected:
void initAfterRead() override;
@@ -109,10 +109,10 @@ private:
void computeDepthOfWellPathAtFracture();
void computePerforationLength();
std::vector<double> fractureGridResultsForUnitSystem( const QString& resultName,
const QString& unitName,
size_t timeStepIndex,
RiaEclipseUnitTools::UnitSystem requiredUnitSystem ) const;
std::vector<double> fractureGridResultsForUnitSystem( const QString& resultName,
const QString& unitName,
size_t timeStepIndex,
RiaDefines::EclipseUnitSystem requiredUnitSystem ) const;
WellFractureIntersectionData wellFractureIntersectionData( const RimFracture* fractureInstance ) const override;

14
ApplicationLibCode/ProjectDataModel/Completions/RimValveTemplate.cpp
View File

@@ -34,7 +34,7 @@ RimValveTemplate::RimValveTemplate()
CAF_PDM_InitField( &m_valveTemplateUnit,
"UnitSystem",
caf::AppEnum<RiaEclipseUnitTools::UnitSystem>( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN ),
caf::AppEnum<RiaDefines::EclipseUnitSystem>( RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN ),
"Units System",
"",
"",
@@ -73,7 +73,7 @@ void RimValveTemplate::loadDataAndUpdate()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::setUnitSystem( RiaEclipseUnitTools::UnitSystemType unitSystem )
void RimValveTemplate::setUnitSystem( caf::AppEnum<RiaDefines::EclipseUnitSystem> unitSystem )
{
m_valveTemplateUnit = unitSystem;
}
@@ -83,11 +83,11 @@ void RimValveTemplate::setUnitSystem( RiaEclipseUnitTools::UnitSystemType unitSy
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::setDefaultValuesFromUnits()
{
if ( m_valveTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( m_valveTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_orificeDiameter = 8;
}
else if ( m_valveTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( m_valveTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_orificeDiameter = 0.315;
}
@@ -115,7 +115,7 @@ void RimValveTemplate::setType( RiaDefines::WellPathComponentType type )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimValveTemplate::templateUnits() const
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimValveTemplate::templateUnits() const
{
return m_valveTemplateUnit;
}
@@ -200,11 +200,11 @@ void RimValveTemplate::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
uiOrdering.add( &m_valveTemplateUnit );
if ( m_type() == RiaDefines::WellPathComponentType::ICV || m_type() == RiaDefines::WellPathComponentType::ICD )
{
if ( m_valveTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( m_valveTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_orificeDiameter.uiCapability()->setUiName( "Orifice Diameter [mm]" );
}
else if ( m_valveTemplateUnit == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( m_valveTemplateUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_orificeDiameter.uiCapability()->setUiName( "Orifice Diameter [in]" );
}

23
ApplicationLibCode/ProjectDataModel/Completions/RimValveTemplate.h
View File

@@ -19,7 +19,6 @@
#pragma once
#include "RiaDefines.h"
#include "RiaEclipseUnitTools.h"
#include "RimCheckableNamedObject.h"
@@ -36,18 +35,18 @@ public:
~RimValveTemplate() override;
void loadDataAndUpdate();
void setUnitSystem( RiaEclipseUnitTools::UnitSystemType unitSystem );
void setUnitSystem( caf::AppEnum<RiaDefines::EclipseUnitSystem> unitSystem );
void setDefaultValuesFromUnits();
RiaDefines::WellPathComponentType type() const;
void setType( RiaDefines::WellPathComponentType type );
RiaEclipseUnitTools::UnitSystemType templateUnits() const;
double orificeDiameter() const;
double flowCoefficient() const;
const RimWellPathAicdParameters* aicdParameters() const;
QString typeLabel() const;
QString fullLabel() const;
void setUserLabel( const QString& userLabel );
RiaDefines::WellPathComponentType type() const;
void setType( RiaDefines::WellPathComponentType type );
caf::AppEnum<RiaDefines::EclipseUnitSystem> templateUnits() const;
double orificeDiameter() const;
double flowCoefficient() const;
const RimWellPathAicdParameters* aicdParameters() const;
QString typeLabel() const;
QString fullLabel() const;
void setUserLabel( const QString& userLabel );
protected:
QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
@@ -59,7 +58,7 @@ protected:
private:
typedef caf::AppEnum<RiaDefines::WellPathComponentType> CompletionTypeEnum;
caf::PdmField<RiaEclipseUnitTools::UnitSystemType> m_valveTemplateUnit;
caf::PdmField<caf::AppEnum<RiaDefines::EclipseUnitSystem>> m_valveTemplateUnit;
caf::PdmField<CompletionTypeEnum> m_type;
caf::PdmField<QString> m_userLabel;

6
ApplicationLibCode/ProjectDataModel/Completions/RimValveTemplateCollection.cpp
View File

@@ -36,7 +36,7 @@ RimValveTemplateCollection::RimValveTemplateCollection()
"",
"",
"" );
m_defaultUnitsForValveTemplates = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
m_defaultUnitsForValveTemplates = RiaDefines::EclipseUnitSystem::UNITS_METRIC;
m_valveDefinitions.uiCapability()->setUiHidden( true );
addDefaultValveTemplates();
}
@@ -81,7 +81,7 @@ void RimValveTemplateCollection::removeAndDeleteValveTemplate( RimValveTemplate*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimValveTemplateCollection::defaultUnitSystemType() const
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimValveTemplateCollection::defaultUnitSystemType() const
{
return m_defaultUnitsForValveTemplates;
}
@@ -94,7 +94,7 @@ void RimValveTemplateCollection::setDefaultUnitSystemBasedOnLoadedCases()
RimProject* proj = RimProject::current();
auto commonUnitSystem = proj->commonUnitSystemForAllCases();
if ( commonUnitSystem != RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
if ( commonUnitSystem != RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN )
{
m_defaultUnitsForValveTemplates = commonUnitSystem;
}

10
ApplicationLibCode/ProjectDataModel/Completions/RimValveTemplateCollection.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmField.h"
@@ -43,10 +43,10 @@ public:
void removeAndDeleteValveTemplate( RimValveTemplate* valveTemplate );
void addDefaultValveTemplates();
RiaEclipseUnitTools::UnitSystemType defaultUnitSystemType() const;
void setDefaultUnitSystemBasedOnLoadedCases();
caf::AppEnum<RiaDefines::EclipseUnitSystem> defaultUnitSystemType() const;
void setDefaultUnitSystemBasedOnLoadedCases();
private:
caf::PdmChildArrayField<RimValveTemplate*> m_valveDefinitions;
caf::PdmField<RiaEclipseUnitTools::UnitSystemType> m_defaultUnitsForValveTemplates;
caf::PdmChildArrayField<RimValveTemplate*> m_valveDefinitions;
caf::PdmField<caf::AppEnum<RiaDefines::EclipseUnitSystem>> m_defaultUnitsForValveTemplates;
};

2
ApplicationLibCode/ProjectDataModel/Completions/RimWellPathAicdParameters.cpp
View File

@@ -292,7 +292,7 @@ bool RimWellPathAicdParameters::isMetric() const
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
metric = true;
}

20
ApplicationLibCode/ProjectDataModel/Completions/RimWellPathValve.cpp
View File

@@ -139,7 +139,7 @@ std::vector<double> RimWellPathValve::valveLocations() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimWellPathValve::orificeDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const
double RimWellPathValve::orificeDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const
{
if ( m_valveTemplate() )
{
@@ -230,13 +230,13 @@ const RimWellPathAicdParameters* RimWellPathValve::aicdParameters() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimWellPathValve::convertOrificeDiameter( double orificeDiameterWellPathUnits,
RiaEclipseUnitTools::UnitSystem wellPathUnits,
RiaEclipseUnitTools::UnitSystem unitSystem )
double RimWellPathValve::convertOrificeDiameter( double orificeDiameterWellPathUnits,
RiaDefines::EclipseUnitSystem wellPathUnits,
RiaDefines::EclipseUnitSystem unitSystem )
{
if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
if ( wellPathUnits == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
if ( wellPathUnits == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
return RiaEclipseUnitTools::inchToMeter( orificeDiameterWellPathUnits );
}
@@ -245,9 +245,9 @@ double RimWellPathValve::convertOrificeDiameter( double
return RiaEclipseUnitTools::mmToMeter( orificeDiameterWellPathUnits );
}
}
else if ( unitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( unitSystem == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
if ( wellPathUnits == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPathUnits == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
return RiaEclipseUnitTools::meterToFeet( RiaEclipseUnitTools::mmToMeter( orificeDiameterWellPathUnits ) );
}
@@ -518,11 +518,11 @@ void RimWellPathValve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
firstAncestorOrThisOfType( wellPath );
if ( wellPath )
{
if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_METRIC )
if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
{
m_measuredDepth.uiCapability()->setUiName( "Measured Depth [m]" );
}
else if ( wellPath->unitSystem() == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
else if ( wellPath->unitSystem() == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
m_measuredDepth.uiCapability()->setUiName( "Measured Depth [ft]" );
}

10
ApplicationLibCode/ProjectDataModel/Completions/RimWellPathValve.h
View File

@@ -17,7 +17,7 @@
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RimCheckableNamedObject.h"
#include "RimValveTemplate.h"
@@ -49,16 +49,16 @@ public:
void setMeasuredDepthAndCount( double startMD, double spacing, int valveCount );
void multipleValveGeometryUpdated();
std::vector<double> valveLocations() const;
double orificeDiameter( RiaEclipseUnitTools::UnitSystem unitSystem ) const;
double orificeDiameter( RiaDefines::EclipseUnitSystem unitSystem ) const;
double flowCoefficient() const;
RimValveTemplate* valveTemplate() const;
void setValveTemplate( RimValveTemplate* valveTemplate );
void applyValveLabelAndIcon();
const RimWellPathAicdParameters* aicdParameters() const;
static double convertOrificeDiameter( double orificeDiameterUi,
RiaEclipseUnitTools::UnitSystem wellPathUnitSystem,
RiaEclipseUnitTools::UnitSystem wantedUnitSystem );
static double convertOrificeDiameter( double orificeDiameterUi,
RiaDefines::EclipseUnitSystem wellPathUnitSystem,
RiaDefines::EclipseUnitSystem wantedUnitSystem );
std::vector<std::pair<double, double>> valveSegments() const;

2
ApplicationLibCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
View File

@@ -476,7 +476,7 @@ std::map<QString, const std::vector<double>*>
//--------------------------------------------------------------------------------------------------
void RimWellAllocationPlot::updateWellFlowPlotXAxisTitle( RimWellLogTrack* plotTrack )
{
RiaEclipseUnitTools::UnitSystem unitSet = m_case->eclipseCaseData()->unitsType();
RiaDefines::EclipseUnitSystem unitSet = m_case->eclipseCaseData()->unitsType();
RimWellLogFile::WellFlowCondition condition = m_flowDiagSolution ? RimWellLogFile::WELL_FLOW_COND_RESERVOIR
: RimWellLogFile::WELL_FLOW_COND_STANDARD;

26
ApplicationLibCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
View File

@@ -805,7 +805,7 @@ std::set<RiaRftPltCurveDefinition>
///
//--------------------------------------------------------------------------------------------------
QString RimWellPlotTools::flowPlotAxisTitle( RimWellLogFile::WellFlowCondition condition,
RiaEclipseUnitTools::UnitSystem unitSystem )
RiaDefines::EclipseUnitSystem unitSystem )
{
QString axisTitle;
@@ -828,19 +828,19 @@ QString RimWellPlotTools::flowPlotAxisTitle( RimWellLogFile::WellFlowCondition c
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString flowConditionReservoirUnitText( RiaEclipseUnitTools::UnitSystem unitSystem )
QString flowConditionReservoirUnitText( RiaDefines::EclipseUnitSystem unitSystem )
{
QString unitText;
switch ( unitSystem )
{
case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
case RiaDefines::EclipseUnitSystem::UNITS_METRIC:
unitText = "[m<sup>3</sup>/day]";
break;
case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
case RiaDefines::EclipseUnitSystem::UNITS_FIELD:
unitText = "[Brl/day]";
break;
case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
case RiaDefines::EclipseUnitSystem::UNITS_LAB:
unitText = "[cm<sup>3</sup>/hr]";
break;
default:
@@ -854,7 +854,7 @@ QString flowConditionReservoirUnitText( RiaEclipseUnitTools::UnitSystem unitSyst
///
//--------------------------------------------------------------------------------------------------
QString RimWellPlotTools::flowUnitText( RimWellLogFile::WellFlowCondition condition,
RiaEclipseUnitTools::UnitSystem unitSystem )
RiaDefines::EclipseUnitSystem unitSystem )
{
QString unitText;
@@ -866,13 +866,13 @@ QString RimWellPlotTools::flowUnitText( RimWellLogFile::WellFlowCondition condit
{
switch ( unitSystem )
{
case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
case RiaDefines::EclipseUnitSystem::UNITS_METRIC:
unitText = "[Liquid Sm<sup>3</sup>/day], [Gas kSm<sup>3</sup>/day]";
break;
case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
case RiaDefines::EclipseUnitSystem::UNITS_FIELD:
unitText = "[Liquid BBL/day], [Gas BOE/day]";
break;
case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
case RiaDefines::EclipseUnitSystem::UNITS_LAB:
unitText = "[cm<sup>3</sup>/hr]";
break;
default:
@@ -887,7 +887,7 @@ QString RimWellPlotTools::flowUnitText( RimWellLogFile::WellFlowCondition condit
///
//--------------------------------------------------------------------------------------------------
QString RimWellPlotTools::curveUnitText( RimWellLogFile::WellFlowCondition condition,
RiaEclipseUnitTools::UnitSystem unitSystem,
RiaDefines::EclipseUnitSystem unitSystem,
FlowPhase flowPhase )
{
QString unitText;
@@ -900,7 +900,7 @@ QString RimWellPlotTools::curveUnitText( RimWellLogFile::WellFlowCondition condi
{
switch ( unitSystem )
{
case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
case RiaDefines::EclipseUnitSystem::UNITS_METRIC:
switch ( flowPhase )
{
case FLOW_PHASE_GAS:
@@ -916,7 +916,7 @@ QString RimWellPlotTools::curveUnitText( RimWellLogFile::WellFlowCondition condi
}
break;
case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
case RiaDefines::EclipseUnitSystem::UNITS_FIELD:
switch ( flowPhase )
{
case FLOW_PHASE_GAS:
@@ -931,7 +931,7 @@ QString RimWellPlotTools::curveUnitText( RimWellLogFile::WellFlowCondition condi
break;
}
break;
case RiaEclipseUnitTools::UnitSystem::UNITS_LAB:
case RiaDefines::EclipseUnitSystem::UNITS_LAB:
unitText = "[cm<sup>3</sup>/hr]";
break;
default:

8
ApplicationLibCode/ProjectDataModel/Flow/RimWellPlotTools.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RiaRftPltCurveDefinition.h"
#include "RifDataSourceForRftPltQMetaType.h"
@@ -121,12 +121,12 @@ public:
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults );
static QString flowPlotAxisTitle( RimWellLogFile::WellFlowCondition condition,
RiaEclipseUnitTools::UnitSystem unitSystem );
RiaDefines::EclipseUnitSystem unitSystem );
static QString flowUnitText( RimWellLogFile::WellFlowCondition condition, RiaEclipseUnitTools::UnitSystem unitSystem );
static QString flowUnitText( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString curveUnitText( RimWellLogFile::WellFlowCondition condition,
RiaEclipseUnitTools::UnitSystem unitSystem,
RiaDefines::EclipseUnitSystem unitSystem,
FlowPhase flowPhase );
static bool hasFlowData( const RimWellPath* wellPath );

39
ApplicationLibCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

@@ -7,8 +7,8 @@
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// ResInsight is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
@@ -154,7 +154,7 @@ RimWellPltPlot::~RimWellPltPlot()
//--------------------------------------------------------------------------------------------------
void RimWellPltPlot::setPlotXAxisTitles( RimWellLogTrack* plotTrack )
{
std::set<RiaEclipseUnitTools::UnitSystem> presentUnitSystems;
std::set<RiaDefines::EclipseUnitSystem> presentUnitSystems;
for ( const RifDataSourceForRftPlt& source : m_selectedSources.v() )
{
if ( source.eclCase() && source.eclCase()->eclipseCaseData() )
@@ -170,13 +170,13 @@ void RimWellPltPlot::setPlotXAxisTitles( RimWellLogTrack* plotTrack )
switch ( source.wellLogFile()->wellLogFileData()->depthUnit() )
{
case RiaDefines::DepthUnitType::UNIT_METER:
presentUnitSystems.insert( RiaEclipseUnitTools::UnitSystem::UNITS_METRIC );
presentUnitSystems.insert( RiaDefines::EclipseUnitSystem::UNITS_METRIC );
break;
case RiaDefines::DepthUnitType::UNIT_FEET:
presentUnitSystems.insert( RiaEclipseUnitTools::UnitSystem::UNITS_FIELD );
presentUnitSystems.insert( RiaDefines::EclipseUnitSystem::UNITS_FIELD );
break;
case RiaDefines::DepthUnitType::UNIT_NONE:
presentUnitSystems.insert( RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN );
presentUnitSystems.insert( RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN );
break;
}
}
@@ -190,7 +190,7 @@ void RimWellPltPlot::setPlotXAxisTitles( RimWellLogTrack* plotTrack )
if ( presentUnitSystems.empty() ) return;
RiaEclipseUnitTools::UnitSystem unitSet = *presentUnitSystems.begin();
RiaDefines::EclipseUnitSystem unitSet = *presentUnitSystems.begin();
QString axisTitle;
if ( m_useReservoirConditionCurves )
@@ -244,7 +244,8 @@ void RimWellPltPlot::updateFormationsOnPlot() const
if ( !formationNamesCase )
{
/// Set default case. Todo : Use the first of the selected cases in the plot
/// Set default case. Todo : Use the first of the selected cases in the
/// plot
std::vector<RimCase*> cases;
proj->allCases( cases );
@@ -372,7 +373,8 @@ public:
RigWellResultPoint resPoint;
resPoint.m_isOpen = true;
resPoint.m_gridIndex = 0; // Always main grid
resPoint.m_gridCellIndex = globCellIdx; // Shortcut, since we only have main grid results from RFT
resPoint.m_gridCellIndex = globCellIdx; // Shortcut, since we only have
// main grid results from RFT
resPoint.m_gasRate =
RiaEclipseUnitTools::convertSurfaceGasFlowRateToOilEquivalents( eclCase->eclipseCaseData()->unitsType(),
@@ -541,7 +543,7 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
resultPointCalc.reset( new RigSimWellResultPointCalculator( m_wellPathName, rimEclipseResultCase, timeStep ) );
}
RiaEclipseUnitTools::UnitSystem unitSet = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
RiaDefines::EclipseUnitSystem unitSet = RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
if ( rimEclipseResultCase )
{
unitSet = rimEclipseResultCase->eclipseCaseData()->unitsType();
@@ -654,13 +656,13 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
std::vector<double> depthValues = wellLogFileData->depthValues();
RiaEclipseUnitTools::UnitSystem unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
RiaDefines::EclipseUnitSystem unitSystem = RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
{
RiaDefines::DepthUnitType depthUnit = wellLogFileData->depthUnit();
if ( depthUnit == RiaDefines::DepthUnitType::UNIT_FEET )
unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_FIELD;
unitSystem = RiaDefines::EclipseUnitSystem::UNITS_FIELD;
if ( depthUnit == RiaDefines::DepthUnitType::UNIT_METER )
unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
unitSystem = RiaDefines::EclipseUnitSystem::UNITS_METRIC;
}
for ( const ChannelValNameIdxTuple& channelInfo : sortedChannels )
@@ -693,8 +695,8 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
curveGroupId,
true );
// Total flow channel will end up first, so just increment the group
// idx to make the rest of the phases group together
// Total flow channel will end up first, so just increment the
// group idx to make the rest of the phases group together
if ( RimWellPlotTools::isTotalFlowChannel( channelName ) ) curveGroupId++;
}
}
@@ -914,9 +916,10 @@ void RimWellPltPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
{
if ( !wellPath->wellPathGeometry() )
{
QString tmp =
QString( "Display of Measured Depth (MD) for Grid or RFT curves is not possible without a "
"well log path, and the curve will be hidden in this mode.\n\n" );
QString tmp = QString( "Display of Measured Depth (MD) for Grid or "
"RFT curves is not possible without a "
"well log path, and the curve will be hidden "
"in this mode.\n\n" );
RiaLogging::errorInMessageBox( nullptr, "Grid/RFT curve without MD", tmp );

4
ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlot.cpp
View File

@@ -137,7 +137,7 @@ void RimSaturationPressurePlot::assignCaseAndEquilibriumRegion( RiaDefines::Poro
RimEclipseResultDefinition* resultDefinition = new RimEclipseResultDefinition();
resultDefinition->setEclipseCase( eclipseResultCase );
resultDefinition->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
resultDefinition->setResultVariable( RiaDefines::eqlnumResultName() );
resultDefinition->setResultVariable( RiaResultNames::eqlnumResultName() );
cellFilter->setResultDefinition( resultDefinition );
}
@@ -244,7 +244,7 @@ RimPlotCellPropertyFilter*
RimEclipseResultDefinition* resultDefinition = new RimEclipseResultDefinition();
resultDefinition->setEclipseCase( eclipseResultCase );
resultDefinition->setResultType( RiaDefines::ResultCatType::STATIC_NATIVE );
resultDefinition->setResultVariable( RiaDefines::eqlnumResultName() );
resultDefinition->setResultVariable( RiaResultNames::eqlnumResultName() );
cellFilter->setResultDefinition( resultDefinition );

2
ApplicationLibCode/ProjectDataModel/GridCrossPlots/RimSaturationPressurePlotCollection.cpp
View File

@@ -65,7 +65,7 @@ std::vector<RimSaturationPressurePlot*>
std::set<int> eqlnumRegionIdsFound;
{
RigEclipseResultAddress resAdr( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::eqlnumResultName() );
RigEclipseResultAddress resAdr( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::eqlnumResultName() );
if ( results->hasResultEntry( resAdr ) )
{
results->ensureKnownResultLoaded( resAdr );

6
ApplicationLibCode/ProjectDataModel/RimCellEdgeColors.cpp
View File

@@ -215,7 +215,7 @@ QList<caf::PdmOptionItemInfo> RimCellEdgeColors::calculateValueOptions( const ca
int i;
for ( i = 0; i < varList.size(); ++i )
{
if ( RiaDefines::isPerCellFaceResult( varList[i] ) ) continue;
if ( RiaResultNames::isPerCellFaceResult( varList[i] ) ) continue;
size_t cubeFaceIdx;
for ( cubeFaceIdx = 0; cubeFaceIdx < EdgeFaceEnum::size(); ++cubeFaceIdx )
@@ -258,7 +258,7 @@ QList<caf::PdmOptionItemInfo> RimCellEdgeColors::calculateValueOptions( const ca
options.push_back( caf::PdmOptionItemInfo( optionUiName, QVariant( it->first ) ) );
}
options.push_front( caf::PdmOptionItemInfo( RiaDefines::undefinedResultName(), "" ) );
options.push_front( caf::PdmOptionItemInfo( RiaResultNames::undefinedResultName(), "" ) );
if ( useOptionsOnly ) *useOptionsOnly = true;
@@ -317,7 +317,7 @@ QStringList RimCellEdgeColors::findResultVariableNames()
int i;
for ( i = 0; i < varList.size(); ++i )
{
if ( RiaDefines::isPerCellFaceResult( varList[i] ) ) continue;
if ( RiaResultNames::isPerCellFaceResult( varList[i] ) ) continue;
if ( varList[i].startsWith( m_resultVariable ) )
{

4
ApplicationLibCode/ProjectDataModel/RimDepthTrackPlot.cpp
View File

@@ -401,10 +401,10 @@ RiaDefines::DepthUnitType RimDepthTrackPlot::caseDepthUnit() const
{
switch ( thecase->unitSystem() )
{
case RiaEclipseUnitTools::UnitSystem::UNITS_FIELD:
case RiaDefines::EclipseUnitSystem::UNITS_FIELD:
return RiaDefines::DepthUnitType::UNIT_FEET;
case RiaEclipseUnitTools::UnitSystem::UNITS_METRIC:
case RiaDefines::EclipseUnitSystem::UNITS_METRIC:
return RiaDefines::DepthUnitType::UNIT_METER;
default:

12
ApplicationLibCode/ProjectDataModel/RimEclipseCase.cpp
View File

@@ -531,7 +531,7 @@ void RimEclipseCase::updateFormationNamesData()
{
if ( eclView->cellResult()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES )
{
eclView->cellResult()->setResultVariable( RiaDefines::undefinedResultName() );
eclView->cellResult()->setResultVariable( RiaResultNames::undefinedResultName() );
eclView->cellResult()->updateConnectedEditors();
}
@@ -540,7 +540,7 @@ void RimEclipseCase::updateFormationNamesData()
{
if ( propFilter->resultDefinition()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES )
{
propFilter->resultDefinition()->setResultVariable( RiaDefines::undefinedResultName() );
propFilter->resultDefinition()->setResultVariable( RiaResultNames::undefinedResultName() );
}
}
}
@@ -948,7 +948,7 @@ bool RimEclipseCase::openReserviorCase()
// make sure the nnc transmissibilities can be addressed by this scalarResultIndex as well
RigEclipseResultAddress combinedTransmissibilityResAddr( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::combinedTransmissibilityResultName() );
RiaResultNames::combinedTransmissibilityResultName() );
if ( results->hasResultEntry( combinedTransmissibilityResAddr ) )
{
eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress( RiaDefines::propertyNameCombTrans(),
@@ -956,7 +956,7 @@ bool RimEclipseCase::openReserviorCase()
}
RigEclipseResultAddress combinedWaterFluxResAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedWaterFluxResultName() );
RiaResultNames::combinedWaterFluxResultName() );
if ( results->hasResultEntry( combinedWaterFluxResAddr ) )
{
eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress( RiaDefines::propertyNameFluxWat(),
@@ -964,14 +964,14 @@ bool RimEclipseCase::openReserviorCase()
}
RigEclipseResultAddress combinedOilFluxResAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedOilFluxResultName() );
RiaResultNames::combinedOilFluxResultName() );
if ( results->hasResultEntry( combinedOilFluxResAddr ) )
{
eclipseCaseData()->mainGrid()->nncData()->setEclResultAddress( RiaDefines::propertyNameFluxOil(),
combinedOilFluxResAddr );
}
RigEclipseResultAddress combinedGasFluxResAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedGasFluxResultName() );
RiaResultNames::combinedGasFluxResultName() );
if ( results->hasResultEntry( combinedGasFluxResAddr ) )
{

6
ApplicationLibCode/ProjectDataModel/RimEclipseCellColors.cpp
View File

@@ -100,7 +100,7 @@ void RimEclipseCellColors::fieldChangedByUi( const caf::PdmFieldHandle* changedF
changeLegendConfig( this->resultVariable() );
}
if ( newValue != RiaDefines::undefinedResultName() )
if ( newValue != RiaResultNames::undefinedResultName() )
{
if ( m_reservoirView ) m_reservoirView->hasUserRequestedAnimation = true;
}
@@ -126,7 +126,7 @@ void RimEclipseCellColors::fieldChangedByUi( const caf::PdmFieldHandle* changedF
//--------------------------------------------------------------------------------------------------
void RimEclipseCellColors::changeLegendConfig( QString resultVarNameOfNewLegend )
{
if ( resultVarNameOfNewLegend != RiaDefines::ternarySaturationResultName() )
if ( resultVarNameOfNewLegend != RiaResultNames::ternarySaturationResultName() )
{
QString legendResultVariable;
@@ -248,7 +248,7 @@ void RimEclipseCellColors::defineUiOrdering( QString uiConfigName, caf::PdmUiOrd
//--------------------------------------------------------------------------------------------------
void RimEclipseCellColors::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/ )
{
if ( this->resultVariable() == RiaDefines::ternarySaturationResultName() )
if ( this->resultVariable() == RiaResultNames::ternarySaturationResultName() )
{
uiTreeOrdering.add( m_ternaryLegendConfig() );
}

2
ApplicationLibCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@@ -318,7 +318,7 @@ bool RimEclipseResultCase::openAndReadActiveCellData( RigEclipseCaseData* mainEc
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimEclipseResultCase::unitSystem()
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimEclipseResultCase::unitSystem()
{
return m_unitSystem();
}

10
ApplicationLibCode/ProjectDataModel/RimEclipseResultCase.h
View File

@@ -20,7 +20,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RimEclipseCase.h"
@@ -61,7 +61,7 @@ public:
bool openAndReadActiveCellData( RigEclipseCaseData* mainEclipseCase );
void readGridDimensions( std::vector<std::vector<int>>& gridDimensions );
RiaEclipseUnitTools::UnitSystemType unitSystem();
caf::AppEnum<RiaDefines::EclipseUnitSystem> unitSystem();
// Overrides from RimCase
QString locationOnDisc() const override;
@@ -94,9 +94,9 @@ private:
cvf::ref<RifReaderEclipseRft> m_readerEclipseRft;
// Fields:
caf::PdmProxyValueField<RiaEclipseUnitTools::UnitSystemType> m_unitSystem;
caf::PdmChildArrayField<RimFlowDiagSolution*> m_flowDiagSolutions;
caf::PdmField<caf::FilePath> m_sourSimFileName;
caf::PdmProxyValueField<caf::AppEnum<RiaDefines::EclipseUnitSystem>> m_unitSystem;
caf::PdmChildArrayField<RimFlowDiagSolution*> m_flowDiagSolutions;
caf::PdmField<caf::FilePath> m_sourSimFileName;
// Obsolete field
caf::PdmField<QString> caseDirectory;

47
ApplicationLibCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@@ -113,7 +113,13 @@ RimEclipseResultDefinition::RimEclipseResultDefinition( caf::PdmUiItemInfo::Labe
CAF_PDM_InitScriptableFieldNoDefault( &m_porosityModel, "PorosityModelType", "Porosity", "", "", "" );
m_porosityModel.uiCapability()->setUiHidden( true );
CAF_PDM_InitScriptableField( &m_resultVariable, "ResultVariable", RiaDefines::undefinedResultName(), "Variable", "", "", "" );
CAF_PDM_InitScriptableField( &m_resultVariable,
"ResultVariable",
RiaResultNames::undefinedResultName(),
"Variable",
"",
"",
"" );
m_resultVariable.uiCapability()->setUiHidden( true );
CAF_PDM_InitFieldNoDefault( &m_flowSolution, "FlowDiagSolution", "Solution", "", "", "" );
@@ -167,7 +173,7 @@ RimEclipseResultDefinition::RimEclipseResultDefinition( caf::PdmUiItemInfo::Labe
CAF_PDM_InitField( &m_resultVariableUiField,
"MResultVariable",
RiaDefines::undefinedResultName(),
RiaResultNames::undefinedResultName(),
"Result Property",
"",
"",
@@ -769,7 +775,7 @@ QList<caf::PdmOptionItemInfo>
for ( const QString& resultName : dynamicResultNames )
{
if ( !resultName.endsWith( "F" ) || resultName == RiaDefines::completionTypeResultName() )
if ( !resultName.endsWith( "F" ) || resultName == RiaResultNames::completionTypeResultName() )
{
continue;
}
@@ -1162,7 +1168,7 @@ void RimEclipseResultDefinition::loadResult()
}
QString resultName = m_resultVariable();
std::set<QString> eclipseResultNamesWithNncData = RiaDefines::nncResultNames();
std::set<QString> eclipseResultNamesWithNncData = RiaResultNames::nncResultNames();
if ( eclipseResultNamesWithNncData.find( resultName ) != eclipseResultNamesWithNncData.end() )
{
eclipseCase()->ensureFaultDataIsComputed();
@@ -1269,12 +1275,12 @@ void RimEclipseResultDefinition::initAfterRead()
if ( m_resultVariable == "Formation Allen" )
{
m_resultVariable = RiaDefines::formationAllanResultName();
m_resultVariable = RiaResultNames::formationAllanResultName();
m_resultType = RiaDefines::ResultCatType::ALLAN_DIAGRAMS;
}
else if ( m_resultVariable == "Binary Formation Allen" )
{
m_resultVariable = RiaDefines::formationBinaryAllanResultName();
m_resultVariable = RiaResultNames::formationBinaryAllanResultName();
m_resultType = RiaDefines::ResultCatType::ALLAN_DIAGRAMS;
}
@@ -1441,8 +1447,9 @@ void RimEclipseResultDefinition::setDiffResultOptionsEnabled( bool enabled )
//--------------------------------------------------------------------------------------------------
bool RimEclipseResultDefinition::isTernarySaturationSelected() const
{
bool isTernary = ( m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) &&
( m_resultVariable().compare( RiaDefines::ternarySaturationResultName(), Qt::CaseInsensitive ) == 0 );
bool isTernary =
( m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) &&
( m_resultVariable().compare( RiaResultNames::ternarySaturationResultName(), Qt::CaseInsensitive ) == 0 );
return isTernary;
}
@@ -1453,7 +1460,7 @@ bool RimEclipseResultDefinition::isTernarySaturationSelected() const
bool RimEclipseResultDefinition::isCompletionTypeSelected() const
{
return ( m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE &&
m_resultVariable() == RiaDefines::completionTypeResultName() );
m_resultVariable() == RiaResultNames::completionTypeResultName() );
}
//--------------------------------------------------------------------------------------------------
@@ -1466,15 +1473,15 @@ bool RimEclipseResultDefinition::hasCategoryResult() const
return true;
if ( this->m_resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE &&
this->resultVariable() == RiaDefines::completionTypeResultName() )
this->resultVariable() == RiaResultNames::completionTypeResultName() )
return true;
if ( this->m_resultType() == RiaDefines::ResultCatType::FLOW_DIAGNOSTICS &&
m_resultVariable() == RIG_FLD_MAX_FRACTION_TRACER_RESNAME )
return true;
if ( this->resultVariable() == RiaDefines::formationAllanResultName() ||
this->resultVariable() == RiaDefines::formationBinaryAllanResultName() )
if ( this->resultVariable() == RiaResultNames::formationAllanResultName() ||
this->resultVariable() == RiaResultNames::formationBinaryAllanResultName() )
{
return true;
}
@@ -1724,12 +1731,12 @@ QList<caf::PdmOptionItemInfo>
for ( const QString& s : getResultNamesForResultType( resultCatType, results ) )
{
if ( s == RiaDefines::completionTypeResultName() )
if ( s == RiaResultNames::completionTypeResultName() )
{
if ( results->timeStepDates().empty() ) continue;
}
if ( RiaDefines::isPerCellFaceResult( s ) )
if ( RiaResultNames::isPerCellFaceResult( s ) )
{
cellFaceResultNames.push_back( s );
}
@@ -1775,14 +1782,14 @@ QList<caf::PdmOptionItemInfo>
if ( resultCatType == RiaDefines::ResultCatType::DYNAMIC_NATIVE && hasAtLeastOneTernaryComponent )
{
optionList.push_front( caf::PdmOptionItemInfo( RiaDefines::ternarySaturationResultName(),
RiaDefines::ternarySaturationResultName() ) );
optionList.push_front( caf::PdmOptionItemInfo( RiaResultNames::ternarySaturationResultName(),
RiaResultNames::ternarySaturationResultName() ) );
}
}
}
optionList.push_front(
caf::PdmOptionItemInfo( RiaDefines::undefinedResultName(), RiaDefines::undefinedResultName() ) );
caf::PdmOptionItemInfo( RiaResultNames::undefinedResultName(), RiaResultNames::undefinedResultName() ) );
return optionList;
}
@@ -1985,7 +1992,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
}
else if ( this->resultType() == RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{
if ( this->resultVariable() == RiaDefines::formationAllanResultName() )
if ( this->resultVariable() == RiaResultNames::formationAllanResultName() )
{
const std::vector<QString> fnVector = eclipseCaseData->formationNames();
std::vector<int> fnameIdxes;
@@ -2034,7 +2041,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
legendConfigToUpdate->setCategoryItems( categories );
}
else if ( this->resultVariable() == RiaDefines::formationBinaryAllanResultName() )
else if ( this->resultVariable() == RiaResultNames::formationBinaryAllanResultName() )
{
std::vector<std::tuple<QString, int, cvf::Color3ub>> categories;
categories.emplace_back( std::make_tuple( "Same formation", 0, cvf::Color3ub::BROWN ) );
@@ -2044,7 +2051,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
}
}
else if ( this->resultType() == RiaDefines::ResultCatType::DYNAMIC_NATIVE &&
this->resultVariable() == RiaDefines::completionTypeResultName() )
this->resultVariable() == RiaResultNames::completionTypeResultName() )
{
const std::vector<int>& visibleCategories =
cellResultsData->uniqueCellScalarValues( this->eclipseResultAddress() );

4
ApplicationLibCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@@ -131,7 +131,7 @@ RimEclipseStatisticsCase::RimEclipseStatisticsCase()
CAF_PDM_InitScriptableField( &m_wellDataSourceCase,
"WellDataSourceCase",
RiaDefines::undefinedResultName(),
RiaResultNames::undefinedResultName(),
"Well Data Source Case",
"",
"",
@@ -529,7 +529,7 @@ QList<caf::PdmOptionItemInfo>
else if ( &m_wellDataSourceCase == fieldNeedingOptions )
{
QStringList sourceCaseNames;
sourceCaseNames += RiaDefines::undefinedResultName();
sourceCaseNames += RiaResultNames::undefinedResultName();
for ( size_t i = 0; i < caseGroup()->caseCollection()->reservoirs().size(); i++ )
{

6
ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp
View File

@@ -1774,7 +1774,7 @@ void RimEclipseView::calculateCompletionTypeAndRedrawIfRequired()
cellEdgeResult()->cellEdgeMetaData( &metaData );
for ( const auto& cellEdgeMeta : metaData )
{
if ( cellEdgeMeta.m_resultVariable == RiaDefines::completionTypeResultName() )
if ( cellEdgeMeta.m_resultVariable == RiaResultNames::completionTypeResultName() )
{
isDependingOnCompletionType = true;
}
@@ -1789,7 +1789,7 @@ void RimEclipseView::calculateCompletionTypeAndRedrawIfRequired()
for ( const auto& propFilter : m_propertyFilterCollection()->propertyFilters )
{
if ( propFilter->isActive() &&
propFilter->resultDefinition()->resultVariable() == RiaDefines::completionTypeResultName() )
propFilter->resultDefinition()->resultVariable() == RiaResultNames::completionTypeResultName() )
{
isDependingOnCompletionType = true;
}
@@ -1812,7 +1812,7 @@ void RimEclipseView::calculateCompletionTypeAndRedrawIfRequired()
for ( const auto& propFilter : m_propertyFilterCollection()->propertyFilters )
{
if ( propFilter->isActive() &&
propFilter->resultDefinition()->resultVariable() == RiaDefines::completionTypeResultName() )
propFilter->resultDefinition()->resultVariable() == RiaResultNames::completionTypeResultName() )
{
propFilter->updateConnectedEditors();
}

6
ApplicationLibCode/ProjectDataModel/RimElementVectorResult.cpp
View File

@@ -535,17 +535,17 @@ bool RimElementVectorResult::resultAddressesCombined( std::vector<RigEclipseResu
if ( showOil() )
{
addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedOilFluxResultName() ) );
RiaResultNames::combinedOilFluxResultName() ) );
}
if ( showGas() )
{
addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedGasFluxResultName() ) );
RiaResultNames::combinedGasFluxResultName() ) );
}
if ( showWater() )
{
addresses.push_back( RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RiaDefines::combinedWaterFluxResultName() ) );
RiaResultNames::combinedWaterFluxResultName() ) );
}
return addresses.size() > 0;
}

9
ApplicationLibCode/ProjectDataModel/RimFaultInViewCollection.cpp
View File

@@ -21,11 +21,12 @@
#include "RiaApplication.h"
#include "RiaColorTables.h"
#include "RiaDefines.h"
#include "RiaPreferences.h"
#include "RiaResultNames.h"
#include "RigMainGrid.h"
#include "RiaDefines.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimFaultInView.h"
@@ -189,12 +190,12 @@ void RimFaultInViewCollection::syncronizeFaults()
for ( size_t i = 0; i < sortedFaults.size(); i++ )
{
QString faultName = sortedFaults[i]->name();
if ( faultName.compare( RiaDefines::undefinedGridFaultName(), Qt::CaseInsensitive ) == 0 )
if ( faultName.compare( RiaResultNames::undefinedGridFaultName(), Qt::CaseInsensitive ) == 0 )
{
undefinedFaults = sortedFaults[i];
}
if ( faultName.startsWith( RiaDefines::undefinedGridFaultName(), Qt::CaseInsensitive ) &&
if ( faultName.startsWith( RiaResultNames::undefinedGridFaultName(), Qt::CaseInsensitive ) &&
faultName.contains( "Inactive" ) )
{
undefinedFaultsWInactive = sortedFaults[i];
@@ -234,7 +235,7 @@ void RimFaultInViewCollection::syncronizeFaults()
rimFault->faultColor = colorTable.cycledColor3f( fIdx );
QString faultName = rigFaults[fIdx]->name();
if ( faultName.startsWith( RiaDefines::undefinedGridFaultName(), Qt::CaseInsensitive ) &&
if ( faultName.startsWith( RiaResultNames::undefinedGridFaultName(), Qt::CaseInsensitive ) &&
faultName.contains( "Inactive" ) )
{
rimFault->showFault = false; // Turn fault against inactive cells off by default

6
ApplicationLibCode/ProjectDataModel/RimGeoMechResultDefinition.cpp
View File

@@ -598,8 +598,8 @@ void RimGeoMechResultDefinition::loadResult()
{
if ( m_geomCase && m_geomCase->geoMechData() )
{
if ( this->resultAddress().fieldName == RiaDefines::wbsFGResult().toStdString() ||
this->resultAddress().fieldName == RiaDefines::wbsSFGResult().toStdString() )
if ( this->resultAddress().fieldName == RiaResultNames::wbsFGResult().toStdString() ||
this->resultAddress().fieldName == RiaResultNames::wbsSFGResult().toStdString() )
{
RigFemResultAddress stressResAddr( RIG_ELEMENT_NODAL, std::string( "ST" ), "" );
RigFemResultAddress porBarResAddr( RIG_ELEMENT_NODAL, std::string( "POR-Bar" ), "" );
@@ -839,7 +839,7 @@ QString RimGeoMechResultDefinition::currentResultUnits() const
}
else
{
for ( auto resultName : RiaDefines::wbsDerivedResultNames() )
for ( auto resultName : RiaResultNames::wbsDerivedResultNames() )
{
if ( resultName == this->resultFieldName() )
{

35
ApplicationLibCode/ProjectDataModel/RimHistogramCalculator.cpp
View File

@@ -409,38 +409,39 @@ void RimHistogramCalculator::updateVisCellStatsIfNeeded( RimEclipseView*
std::vector<RigEclipseResultAddress> RimHistogramCalculator::sourcesForMultiPropertyResults( const QString& resultName )
{
static const std::map<QString, std::vector<RigEclipseResultAddress>> resultsWithMultiPropertySource =
{ { RiaDefines::combinedTransmissibilityResultName(),
{ { RiaResultNames::combinedTransmissibilityResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" ) } },
{ RiaDefines::combinedMultResultName(),
{ RiaResultNames::combinedMultResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX-" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY-" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ-" ) } },
{ RiaDefines::combinedRiTranResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranZResultName() ) } },
{ RiaDefines::combinedRiMultResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultZResultName() ) } },
{ RiaDefines::combinedRiAreaNormTranResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName() ) } },
{ RiaDefines::combinedWaterFluxResultName(),
{ RiaResultNames::combinedRiTranResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riTranZResultName() ) } },
{ RiaResultNames::combinedRiMultResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riMultZResultName() ) } },
{ RiaResultNames::combinedRiAreaNormTranResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riAreaNormTranXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaResultNames::riAreaNormTranYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE,
RiaResultNames::riAreaNormTranZResultName() ) } },
{ RiaResultNames::combinedWaterFluxResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATK+" ) } },
{ RiaDefines::combinedOilFluxResultName(),
{ RiaResultNames::combinedOilFluxResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILK+" ) } },
{ RiaDefines::combinedGasFluxResultName(),
{ RiaResultNames::combinedGasFluxResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASK+" ) } } };

4
ApplicationLibCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@@ -416,8 +416,8 @@ void RimIdenticalGridCaseGroup::clearStatisticsResults()
for ( size_t j = 0; j < rimStaticsCase->reservoirViews.size(); j++ )
{
RimEclipseView* rimReservoirView = rimStaticsCase->reservoirViews[j];
rimReservoirView->cellResult()->setResultVariable( RiaDefines::undefinedResultName() );
rimReservoirView->cellEdgeResult()->setResultVariable( RiaDefines::undefinedResultName() );
rimReservoirView->cellResult()->setResultVariable( RiaResultNames::undefinedResultName() );
rimReservoirView->cellEdgeResult()->setResultVariable( RiaResultNames::undefinedResultName() );
rimReservoirView->loadDataAndUpdate();
}
}

2
ApplicationLibCode/ProjectDataModel/RimIntersectionResultDefinition.cpp
View File

@@ -445,7 +445,7 @@ void RimIntersectionResultDefinition::defineUiTreeOrdering( caf::PdmUiTreeOrderi
{
RimGeoMechCase* geomCase = dynamic_cast<RimGeoMechCase*>( m_case.value() );
if ( !geomCase && m_eclipseResultDefinition->resultVariable() == RiaDefines::ternarySaturationResultName() )
if ( !geomCase && m_eclipseResultDefinition->resultVariable() == RiaResultNames::ternarySaturationResultName() )
{
uiTreeOrdering.add( m_ternaryLegendConfig() );
}

8
ApplicationLibCode/ProjectDataModel/RimProject.cpp
View File

@@ -1303,25 +1303,25 @@ std::vector<RimValveTemplate*> RimProject::allValveTemplates() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimProject::commonUnitSystemForAllCases() const
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimProject::commonUnitSystemForAllCases() const
{
std::vector<RimCase*> rimCases;
allCases( rimCases );
RiaEclipseUnitTools::UnitSystem commonUnitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
RiaDefines::EclipseUnitSystem commonUnitSystem = RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
for ( const auto& c : rimCases )
{
auto eclipseCase = dynamic_cast<RimEclipseCase*>( c );
if ( eclipseCase && eclipseCase->eclipseCaseData() )
{
if ( commonUnitSystem == RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN )
if ( commonUnitSystem == RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN )
{
commonUnitSystem = eclipseCase->eclipseCaseData()->unitsType();
}
else if ( commonUnitSystem != eclipseCase->eclipseCaseData()->unitsType() )
{
commonUnitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
commonUnitSystem = RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
break;
}
}

5
ApplicationLibCode/ProjectDataModel/RimProject.h
View File

@@ -21,7 +21,6 @@
#pragma once
#include "RiaDefines.h"
#include "RiaEclipseUnitTools.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmChildField.h"
@@ -185,8 +184,8 @@ public:
std::vector<RimValveTemplateCollection*> allValveTemplateCollections() const;
std::vector<RimValveTemplate*> allValveTemplates() const;
RiaEclipseUnitTools::UnitSystemType commonUnitSystemForAllCases() const;
RimMeasurement* measurement() const;
caf::AppEnum<RiaDefines::EclipseUnitSystem> commonUnitSystemForAllCases() const;
RimMeasurement* measurement() const;
RimPlotTemplateFolderItem* rootPlotTemlateItem() const;

4
ApplicationLibCode/ProjectDataModel/RimRegularLegendConfig.cpp
View File

@@ -673,11 +673,11 @@ void RimRegularLegendConfig::initAfterRead()
{
if ( resultVariableName == "Binary Formation Allen" )
{
resultVariableName = RiaDefines::formationBinaryAllanResultName();
resultVariableName = RiaResultNames::formationBinaryAllanResultName();
}
else if ( resultVariableName == "Formation Allen" )
{
resultVariableName = RiaDefines::formationAllanResultName();
resultVariableName = RiaResultNames::formationAllanResultName();
}
if ( m_colorRangeMode_OBSOLETE() != RimRegularLegendConfig::ColorRangesType::UNDEFINED )

4
ApplicationLibCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@@ -481,8 +481,8 @@ void RimWellLogExtractionCurve::extractData( bool* isUsingPseudoLength,
eclExtractor->curveData( resAcc.p(), &values );
}
RiaEclipseUnitTools::UnitSystem eclipseUnitsType = eclipseCase->eclipseCaseData()->unitsType();
if ( eclipseUnitsType == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
RiaDefines::EclipseUnitSystem eclipseUnitsType = eclipseCase->eclipseCaseData()->unitsType();
if ( eclipseUnitsType == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
// See https://github.com/OPM/ResInsight/issues/538

5
ApplicationLibCode/ProjectDataModel/RimWellLogRftCurve.cpp
View File

@@ -18,6 +18,7 @@
#include "RimWellLogRftCurve.h"
#include "RiaDefines.h"
#include "RiaEclipseUnitTools.h"
#include "RiaQDateTimeTools.h"
#include "RiaSimWellBranchTools.h"
@@ -400,7 +401,7 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
return;
}
RiaEclipseUnitTools::UnitSystem unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
RiaDefines::EclipseUnitSystem unitSystem = RiaDefines::EclipseUnitSystem::UNITS_METRIC;
if ( m_eclipseResultCase )
{
unitSystem = m_eclipseResultCase->eclipseCaseData()->unitsType();
@@ -416,7 +417,7 @@ void RimWellLogRftCurve::onLoadDataAndUpdate( bool updateParentPlot )
else if ( m_observedFmuRftData )
{
// TODO: Read unit system somewhere for FMU RFT Data
unitSystem = RiaEclipseUnitTools::UnitSystem::UNITS_METRIC;
unitSystem = RiaDefines::EclipseUnitSystem::UNITS_METRIC;
perPointLabels = this->perPointLabels();
}
else

4
ApplicationLibCode/ProjectDataModel/RimWellLogTrack.cpp
View File

@@ -2570,7 +2570,7 @@ void RimWellLogTrack::updateFormationNamesOnPlot()
RiaDefines::PorosityModelType::MATRIX_MODEL,
0,
RigEclipseResultAddress( RiaDefines::ResultCatType::FORMATION_NAMES,
RiaDefines::activeFormationNamesResultName() ) );
RiaResultNames::activeFormationNamesResultName() ) );
curveData = RimWellLogTrack::curveSamplingPointData( eclWellLogExtractor, resultAccessor.p() );
}
@@ -2581,7 +2581,7 @@ void RimWellLogTrack::updateFormationNamesOnPlot()
dynamic_cast<RimGeoMechCase*>( m_formationCase() ) );
if ( !geoMechWellLogExtractor ) return;
std::string activeFormationNamesResultName = RiaDefines::activeFormationNamesResultName().toStdString();
std::string activeFormationNamesResultName = RiaResultNames::activeFormationNamesResultName().toStdString();
curveData = RimWellLogTrack::curveSamplingPointData( geoMechWellLogExtractor,
RigFemResultAddress( RIG_FORMATION_NAMES,
activeFormationNamesResultName,

4
ApplicationLibCode/ProjectDataModel/RimWellPath.cpp
View File

@@ -709,7 +709,7 @@ double RimWellPath::combinedScaleFactor() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPath::setUnitSystem( RiaEclipseUnitTools::UnitSystem unitSystem )
void RimWellPath::setUnitSystem( RiaDefines::EclipseUnitSystem unitSystem )
{
m_unitSystem = unitSystem;
@@ -719,7 +719,7 @@ void RimWellPath::setUnitSystem( RiaEclipseUnitTools::UnitSystem unitSystem )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystem RimWellPath::unitSystem() const
RiaDefines::EclipseUnitSystem RimWellPath::unitSystem() const
{
return m_unitSystem();
}

8
ApplicationLibCode/ProjectDataModel/RimWellPath.h
View File

@@ -20,7 +20,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RimWellPathComponentInterface.h"
@@ -87,8 +87,8 @@ public:
virtual void updateFilePathsFromProjectPath( const QString& newProjectPath, const QString& oldProjectPath );
void setUnitSystem( RiaEclipseUnitTools::UnitSystem unitSystem );
RiaEclipseUnitTools::UnitSystem unitSystem() const;
void setUnitSystem( RiaDefines::EclipseUnitSystem unitSystem );
RiaDefines::EclipseUnitSystem unitSystem() const;
double airGap() const;
double datumElevation() const;
@@ -173,7 +173,7 @@ private:
caf::PdmField<QString> m_simWellName;
caf::PdmField<int> m_branchIndex;
caf::PdmField<RiaEclipseUnitTools::UnitSystemType> m_unitSystem;
caf::PdmField<caf::AppEnum<RiaDefines::EclipseUnitSystem>> m_unitSystem;
caf::PdmField<caf::FilePath> m_wellPathFormationFilePath;
caf::PdmField<QString> m_formationKeyInFile;

6
ApplicationLibCode/ProjectDataModel/RimWellPathCollection.cpp
View File

@@ -904,13 +904,13 @@ RimWellPathGroup* RimWellPathCollection::findOrCreateWellPathGroup( gsl::not_nul
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimWellPathCollection::findUnitSystemForWellPath( const RimWellPath* wellPath )
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimWellPathCollection::findUnitSystemForWellPath( const RimWellPath* wellPath )
{
RimProject* project;
firstAncestorOrThisOfTypeAsserted( project );
if ( project->activeOilField()->analysisModels->cases.empty() )
{
return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
return RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
}
const RigEclipseCaseData* eclipseCaseData = project->activeOilField()->analysisModels->cases()[0]->eclipseCaseData();
@@ -925,7 +925,7 @@ RiaEclipseUnitTools::UnitSystemType RimWellPathCollection::findUnitSystemForWell
{
return eclipseCaseData->unitsType();
}
return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
return RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/RimWellPathCollection.h
View File

@@ -20,7 +20,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "cafAppEnum.h"
#include "cafPdmChildArrayField.h"
@@ -146,7 +146,7 @@ private:
RimWellPathGroup* findOrCreateWellPathGroup( gsl::not_null<RimWellPath*> wellPath,
const std::vector<RimWellPath*>& wellPathsToGroupWith );
RiaEclipseUnitTools::UnitSystemType findUnitSystemForWellPath( const RimWellPath* wellPath );
caf::AppEnum<RiaDefines::EclipseUnitSystem> findUnitSystemForWellPath( const RimWellPath* wellPath );
std::unique_ptr<RifWellPathImporter> m_wellPathImporter;
std::unique_ptr<RifWellPathFormationsImporter> m_wellPathFormationsImporter;

6
ApplicationLibCode/ProjectDataModel/RimWellPathLateralGeometryDef.cpp
View File

@@ -407,12 +407,13 @@ RiaLineArcWellPathCalculator RimWellPathLateralGeometryDef::lineArcWellPathCalcu
std::vector<RiaLineArcWellPathCalculator::WellTarget> targetDatas;
auto [pointVector, measuredDepths] = m_parentGeometry->clippedPointSubset( 0.0, m_connectionMdOnParentWellPath );
cvf::Vec3d connectionPoint = anchorPointXyz();
cvf::Vec3d connectionPoint = anchorPointXyz();
auto N = pointVector.size();
if ( N >= 2u )
{
targetDatas = createTargetsFromPoints( { pointVector[N - 2] - connectionPoint, pointVector[N - 1] - connectionPoint} );
targetDatas =
createTargetsFromPoints( { pointVector[N - 2] - connectionPoint, pointVector[N - 1] - connectionPoint } );
}
std::vector<RimWellPathTarget*> activeTargets = activeWellTargets();
@@ -422,7 +423,6 @@ RiaLineArcWellPathCalculator RimWellPathLateralGeometryDef::lineArcWellPathCalcu
targetDatas.push_back( wellTarget->wellTargetData() );
}
RiaLineArcWellPathCalculator wellPathCalculator( connectionPoint, targetDatas );
const std::vector<RiaLineArcWellPathCalculator::WellTargetStatus>& targetStatuses =

1
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModel.cpp
View File

@@ -20,7 +20,6 @@
#include "RiaApplication.h"
#include "RiaCompletionTypeCalculationScheduler.h"
#include "RiaEclipseUnitTools.h"
#include "RiaFractureDefines.h"
#include "RiaLogging.h"
#include "RiaStimPlanModelDefines.h"

1
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModelCalculator.cpp
View File

@@ -18,6 +18,7 @@
#include "RimStimPlanModelCalculator.h"
#include "RiaDefines.h"
#include "RiaEclipseUnitTools.h"
#include "RiaLogging.h"
#include "RiaStimPlanModelDefines.h"

4
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModelCurve.cpp
View File

@@ -147,8 +147,8 @@ void RimStimPlanModelCurve::performDataExtraction( bool* isUsingPseudoLength )
return;
}
RiaEclipseUnitTools::UnitSystem eclipseUnitsType = eclipseCase->eclipseCaseData()->unitsType();
if ( eclipseUnitsType == RiaEclipseUnitTools::UnitSystem::UNITS_FIELD )
RiaDefines::EclipseUnitSystem eclipseUnitsType = eclipseCase->eclipseCaseData()->unitsType();
if ( eclipseUnitsType == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
{
// See https://github.com/OPM/ResInsight/issues/538

2
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModelElasticPropertyCalculator.cpp
View File

@@ -125,7 +125,7 @@ bool RimStimPlanModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
RiaDefines::PorosityModelType::MATRIX_MODEL,
0,
RigEclipseResultAddress( RiaDefines::ResultCatType::FORMATION_NAMES,
RiaDefines::activeFormationNamesResultName() ) );
RiaResultNames::activeFormationNamesResultName() ) );
if ( !formationResultAccessor.notNull() )
{
RiaLogging::error( QString( "No formation result found." ) );

2
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModelLayerCalculator.cpp
View File

@@ -97,7 +97,7 @@ bool RimStimPlanModelLayerCalculator::calculate( RiaDefines::CurveProperty curve
RiaDefines::PorosityModelType::MATRIX_MODEL,
0,
RigEclipseResultAddress( RiaDefines::ResultCatType::FORMATION_NAMES,
RiaDefines::activeFormationNamesResultName() ) );
RiaResultNames::activeFormationNamesResultName() ) );
if ( !formationResultAccessor.notNull() )
{
RiaLogging::error( QString( "No formation result found." ) );

1
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModelStressCalculator.cpp
View File

@@ -18,6 +18,7 @@
#include "RimStimPlanModelStressCalculator.h"
#include "RiaDefines.h"
#include "RiaEclipseUnitTools.h"
#include "RiaLogging.h"
#include "RiaStimPlanModelDefines.h"

1
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModelTemplate.cpp
View File

@@ -20,7 +20,6 @@
#include "RiaColorTables.h"
#include "RiaCompletionTypeCalculationScheduler.h"
#include "RiaEclipseUnitTools.h"
#include "RiaFractureDefines.h"
#include "RiaLogging.h"
#include "RiaStimPlanModelDefines.h"

1
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModelTemplate.h
View File

@@ -18,7 +18,6 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaStimPlanModelDefines.h"
#include "RimNamedObject.h"

4
ApplicationLibCode/ProjectDataModel/Summary/RimCalculatedSummaryCurveReader.cpp
View File

@@ -106,7 +106,7 @@ RimSummaryCalculation*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystem RifCalculatedSummaryCurveReader::unitSystem() const
RiaDefines::EclipseUnitSystem RifCalculatedSummaryCurveReader::unitSystem() const
{
return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
return RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
}

2
ApplicationLibCode/ProjectDataModel/Summary/RimCalculatedSummaryCurveReader.h
View File

@@ -41,7 +41,7 @@ public:
void buildMetaData();
RiaEclipseUnitTools::UnitSystem unitSystem() const override;
RiaDefines::EclipseUnitSystem unitSystem() const override;
private:
RimSummaryCalculation* findCalculationByName( const RifEclipseSummaryAddress& resultAddress ) const;

3
ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@@ -21,6 +21,7 @@
#include "RiaColorTools.h"
#include "RiaGuiApplication.h"
#include "RiaPreferences.h"
#include "RiaResultNames.h"
#include "RiaStatisticsTools.h"
#include "RiaSummaryCurveAnalyzer.h"
#include "RiaSummaryCurveDefinition.h"
@@ -1282,7 +1283,7 @@ void RimEnsembleCurveSet::appendOptionItemsForSummaryAddresses( QList<caf::PdmOp
options->push_back( caf::PdmOptionItemInfo( s, QVariant::fromValue( addr ) ) );
}
options->push_front( caf::PdmOptionItemInfo( RiaDefines::undefinedResultName(),
options->push_front( caf::PdmOptionItemInfo( RiaResultNames::undefinedResultName(),
QVariant::fromValue( RifEclipseSummaryAddress() ) ) );
}

4
ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.cpp
View File

@@ -203,13 +203,13 @@ void RimEnsembleStatisticsCase::calculate( const std::vector<RimSummaryCase*> su
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystem RimEnsembleStatisticsCase::unitSystem() const
RiaDefines::EclipseUnitSystem RimEnsembleStatisticsCase::unitSystem() const
{
if ( m_curveSet )
{
return m_curveSet->summaryCaseCollection()->unitSystem();
}
return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
return RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/Summary/RimEnsembleStatisticsCase.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RifEclipseSummaryAddress.h"
#include "RimSummaryCase.h"
@@ -54,7 +54,7 @@ public:
const RimEnsembleCurveSet* curveSet() const;
void calculate( const std::vector<RimSummaryCase*>& sumCases, bool includeIncompleteCurves );
RiaEclipseUnitTools::UnitSystem unitSystem() const;
RiaDefines::EclipseUnitSystem unitSystem() const;
private:
void calculate( const std::vector<RimSummaryCase*> sumCases,

4
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCase.cpp
View File

@@ -234,14 +234,14 @@ QString RimSummaryCase::nativeCaseName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimSummaryCase::unitsSystem()
caf::AppEnum<RiaDefines::EclipseUnitSystem> RimSummaryCase::unitsSystem()
{
RifSummaryReaderInterface* reader = summaryReader();
if ( reader )
{
return reader->unitSystem();
}
return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
return RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
}
//--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCase.h
View File

@@ -17,7 +17,7 @@
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RigCaseRealizationParameters.h"
#include "RimCaseDisplayNameTools.h"
@@ -57,7 +57,7 @@ public:
void setCaseId( int caseId );
int caseId() const;
RiaEclipseUnitTools::UnitSystemType unitsSystem();
caf::AppEnum<RiaDefines::EclipseUnitSystem> unitsSystem();
void setDisplayNameOption( RimCaseDisplayNameTools::DisplayName displayNameOption );
void updateAutoShortName();

4
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCaseCollection.cpp
View File

@@ -961,11 +961,11 @@ bool RimSummaryCaseCollection::operator<( const RimSummaryCaseCollection& rhs )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystem RimSummaryCaseCollection::unitSystem() const
RiaDefines::EclipseUnitSystem RimSummaryCaseCollection::unitSystem() const
{
if ( m_cases.empty() )
{
return RiaEclipseUnitTools::UnitSystem::UNITS_UNKNOWN;
return RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN;
}
return m_cases[0]->unitsSystem();
}

4
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCaseCollection.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RiaEclipseUnitTools.h"
#include "RiaDefines.h"
#include "RifEclipseRftAddress.h"
#include "RifEclipseSummaryAddress.h"
#include "RifReaderEnsembleStatisticsRft.h"
@@ -144,7 +144,7 @@ public:
static bool validateEnsembleCases( const std::vector<RimSummaryCase*> cases );
bool operator<( const RimSummaryCaseCollection& rhs ) const;
RiaEclipseUnitTools::UnitSystem unitSystem() const;
RiaDefines::EclipseUnitSystem unitSystem() const;
private:
EnsembleParameter createEnsembleParameter( const QString& paramName ) const;

2
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCurve.cpp
View File

@@ -817,7 +817,7 @@ void RimSummaryCurve::appendOptionItemsForSummaryAddresses( QList<caf::PdmOption
}
}
options->push_front( caf::PdmOptionItemInfo( RiaDefines::undefinedResultName(),
options->push_front( caf::PdmOptionItemInfo( RiaResultNames::undefinedResultName(),
QVariant::fromValue( RifEclipseSummaryAddress() ) ) );
}
}

4
ApplicationLibCode/ProjectDataModel/Surfaces/RimSurfaceResultDefinition.cpp
View File

@@ -19,6 +19,7 @@
#include "RimSurfaceResultDefinition.h"
#include "RiaDefines.h"
#include "RiaResultNames.h"
#include "RigStatisticsMath.h"
#include "RigSurface.h"
@@ -176,7 +177,8 @@ QList<caf::PdmOptionItemInfo>
if ( fieldNeedingOptions == &m_propertyName )
{
options.push_back( caf::PdmOptionItemInfo( RiaDefines::undefinedResultName(), RiaDefines::undefinedResultName() ) );
options.push_back(
caf::PdmOptionItemInfo( RiaResultNames::undefinedResultName(), RiaResultNames::undefinedResultName() ) );
RigSurface* surfData = surfaceData();
if ( surfData )