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

Merge branch 'dev' into pre-proto

Browse Source
This commit is contained in:
Magne Sjaastad
2017-06-08 14:09:03 +02:00
parent 42563ac813 e1f4dbfcf8
commit dd912b4f97
80 changed files with 913 additions and 521 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
ApplicationCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.cpp
View File

@@ -25,7 +25,7 @@
#include "RigFractureGrid.h"
#include "RigTesselatorTools.h"
#include "RimDefines.h"
#include "RimUnitSystem.h"
#include "RimFracture.h"
#include "RimFractureTemplate.h"
#include "RimProject.h"
@@ -104,7 +104,7 @@ void RimEllipseFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* cha
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimDefines::UnitSystem fractureUnit)
void RimEllipseFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureUnit)
{
RigEllipsisTesselator tesselator(20);
@@ -117,17 +117,17 @@ void RimEllipseFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeC
b = height / 2.0f;
}
else if (fractureTemplateUnit() == RimDefines::UNITS_METRIC && fractureUnit == RimDefines::UNITS_FIELD)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_METRIC && fractureUnit == RimUnitSystem::UNITS_FIELD)
{
RiaLogging::info(QString("Converting fracture template geometry from metric to field"));
a = RimDefines::meterToFeet(halfLength);
b = RimDefines::meterToFeet(height / 2.0f);
a = RimUnitSystem::meterToFeet(halfLength);
b = RimUnitSystem::meterToFeet(height / 2.0f);
}
else if (fractureTemplateUnit() == RimDefines::UNITS_FIELD && fractureUnit == RimDefines::UNITS_METRIC)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_FIELD && fractureUnit == RimUnitSystem::UNITS_METRIC)
{
RiaLogging::info(QString("Converting fracture template geometry from field to metric"));
a = RimDefines::feetToMeter(halfLength);
b = RimDefines::feetToMeter(height / 2.0f);
a = RimUnitSystem::feetToMeter(halfLength);
b = RimUnitSystem::feetToMeter(height / 2.0f);
}
else
{
@@ -143,7 +143,7 @@ void RimEllipseFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeC
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fracturePolygon(RimDefines::UnitSystem fractureUnit)
std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fracturePolygon(RimUnitSystem::UnitSystem fractureUnit)
{
std::vector<cvf::Vec3f> polygon;
@@ -165,23 +165,23 @@ std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fracturePolygon(RimDefines::
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::changeUnits()
{
if (fractureTemplateUnit == RimDefines::UNITS_METRIC)
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
{
halfLength = RimDefines::meterToFeet(halfLength);
height = RimDefines::meterToFeet(height);
width = RimDefines::meterToInch(width);
wellDiameter = RimDefines::meterToInch(wellDiameter);
perforationLength = RimDefines::meterToFeet(perforationLength);
fractureTemplateUnit = RimDefines::UNITS_FIELD;
halfLength = RimUnitSystem::meterToFeet(halfLength);
height = RimUnitSystem::meterToFeet(height);
width = RimUnitSystem::meterToInch(width);
wellDiameter = RimUnitSystem::meterToInch(wellDiameter);
perforationLength = RimUnitSystem::meterToFeet(perforationLength);
fractureTemplateUnit = RimUnitSystem::UNITS_FIELD;
}
else if (fractureTemplateUnit == RimDefines::UNITS_FIELD)
else if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
{
halfLength = RimDefines::feetToMeter(halfLength);
height = RimDefines::feetToMeter(height);
width = RimDefines::inchToMeter(width);
wellDiameter = RimDefines::inchToMeter(wellDiameter);
perforationLength = RimDefines::feetToMeter(perforationLength);
fractureTemplateUnit = RimDefines::UNITS_METRIC;
halfLength = RimUnitSystem::feetToMeter(halfLength);
height = RimUnitSystem::feetToMeter(height);
width = RimUnitSystem::inchToMeter(width);
wellDiameter = RimUnitSystem::inchToMeter(wellDiameter);
perforationLength = RimUnitSystem::feetToMeter(perforationLength);
fractureTemplateUnit = RimUnitSystem::UNITS_METRIC;
}
this->updateConnectedEditors();
@@ -224,15 +224,15 @@ void RimEllipseFractureTemplate::setupFractureGridCells()
cellPolygon.push_back(cvf::Vec3d(X1, Y2, 0.0));
double cond = cvf::UNDEFINED_DOUBLE;
if (fractureTemplateUnit == RimDefines::UNITS_METRIC)
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
{
//Conductivity should be md-m, width is in m
cond = permeability * width;
}
else if(fractureTemplateUnit == RimDefines::UNITS_FIELD)
else if(fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
{
//Conductivity should be md-ft, but width is in inches
cond = permeability * RimDefines::inchToFeet(width);
cond = permeability * RimUnitSystem::inchToFeet(width);
}
std::vector<cvf::Vec3f> ellipseFracPolygon = fracturePolygon(fractureTemplateUnit());
@@ -294,14 +294,14 @@ void RimEllipseFractureTemplate::defineUiOrdering(QString uiConfigName, caf::Pdm
{
RimFractureTemplate::defineUiOrdering(uiConfigName, uiOrdering);
if (fractureTemplateUnit == RimDefines::UNITS_METRIC)
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
{
halfLength.uiCapability()->setUiName("Halflenght X<sub>f</sub> [m]");
height.uiCapability()->setUiName("Height [m]");
width.uiCapability()->setUiName("Width [m]");
wellDiameter.uiCapability()->setUiName("Well Diameter [m]");
}
else if (fractureTemplateUnit == RimDefines::UNITS_FIELD)
else if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
{
halfLength.uiCapability()->setUiName("Halflenght X<sub>f</sub> [Ft]");
height.uiCapability()->setUiName("Height [Ft]");

4
ApplicationCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.h
View File

@@ -54,8 +54,8 @@ public:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* polygonIndices, RimDefines::UnitSystem fractureTemplateUnit);
std::vector<cvf::Vec3f> fracturePolygon(RimDefines::UnitSystem fractureTemplateUnit);
void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* polygonIndices, RimUnitSystem::UnitSystem fractureTemplateUnit);
std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureTemplateUnit);
void changeUnits();
const RigFractureGrid* fractureGrid() const;

2
ApplicationCode/ProjectDataModel/Completions/RimFishboneWellPath.cpp
View File

@@ -36,7 +36,7 @@ RimFishboneWellPath::RimFishboneWellPath()
m_coordinates.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_measuredDepths, "MeasuredDepth", "MeasuredDepth", "", "", "");
m_measuredDepths.uiCapability()->setUiHidden(true);
m_name.uiCapability()->setUiHidden(true);
userDescriptionField()->uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_displayCoordinates, "DisplayCoordinates", "Coordinates", "", "", "");
m_displayCoordinates.registerGetMethod(this, &RimFishboneWellPath::displayCoordinates);

4
ApplicationCode/ProjectDataModel/Completions/RimFishboneWellPathCollection.cpp
View File

@@ -40,8 +40,8 @@ RimFishboneWellPathCollection::RimFishboneWellPathCollection()
{
CAF_PDM_InitObject("WellPathCompletions", ":/FishBoneGroupFromFile16x16.png", "", "");
m_name.uiCapability()->setUiHidden(true);
m_name = "Well Paths";
nameField()->uiCapability()->setUiHidden(true);
this->setName("Well Paths");
CAF_PDM_InitFieldNoDefault(&m_wellPaths, "WellPaths", "Well Paths", "", "", "");
m_wellPaths.uiCapability()->setUiHidden(true);

1
ApplicationCode/ProjectDataModel/Completions/RimFishboneWellPathCollection.h
View File

@@ -46,6 +46,7 @@ public:
std::vector<const RimFishboneWellPath*> wellPaths() const;
double holeDiameter() const { return m_pipeProperties->holeDiameter(); }
double skinFactor() const { return m_pipeProperties->skinFactor(); }
protected:
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;

32
ApplicationCode/ProjectDataModel/Completions/RimFishbonesCollection.cpp
View File

@@ -29,6 +29,7 @@
#include <QColor>
#include <algorithm>
CAF_PDM_SOURCE_INIT(RimFishbonesCollection, "FishbonesCollection");
@@ -39,8 +40,8 @@ RimFishbonesCollection::RimFishbonesCollection()
{
CAF_PDM_InitObject("Fishbones", ":/FishBones16x16.png", "", "");
m_name.uiCapability()->setUiHidden(true);
m_name = "Fishbones";
nameField()->uiCapability()->setUiHidden(true);
this->setName("Fishbones");
CAF_PDM_InitFieldNoDefault(&fishbonesSubs, "FishbonesSubs", "fishbonesSubs", "", "", "");
@@ -49,6 +50,10 @@ RimFishbonesCollection::RimFishbonesCollection()
CAF_PDM_InitFieldNoDefault(&m_wellPathCollection, "WellPathCollection", "Well Paths", "", "", "");
m_wellPathCollection = new RimFishboneWellPathCollection;
m_wellPathCollection.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_startMD, "StartMD", HUGE_VAL, "Start MD", "", "", "");
CAF_PDM_InitField(&m_mainBoreDiameter, "MainBoreDiameter", 0.0, "Main Bore Diameter", "", "", "");
CAF_PDM_InitField(&m_linerDiameter, "LinerDiameter", 0.0, "Liner Diameter", "", "", "");
}
//--------------------------------------------------------------------------------------------------
@@ -78,6 +83,8 @@ void RimFishbonesCollection::appendFishbonesSubs(RimFishbonesMultipleSubs* subs)
{
subs->fishbonesColor = nextFishbonesColor();
fishbonesSubs.push_back(subs);
recalculateStartMD();
}
//--------------------------------------------------------------------------------------------------
@@ -113,3 +120,24 @@ cvf::Color3f RimFishbonesCollection::nextFishbonesColor() const
return cvf::Color3f::fromByteColor(qFishbonesColor.red(), qFishbonesColor.green(), qFishbonesColor.blue());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFishbonesCollection::recalculateStartMD()
{
double minStartMD = HUGE_VAL;
for (const RimFishbonesMultipleSubs* sub : fishbonesSubs())
{
for (auto& index : sub->installedLateralIndices())
{
minStartMD = std::min(minStartMD, sub->measuredDepth(index.subIndex) - 13.0);
}
}
if (minStartMD < m_startMD())
{
m_startMD = minStartMD;
}
}

8
ApplicationCode/ProjectDataModel/Completions/RimFishbonesCollection.h
View File

@@ -46,11 +46,19 @@ public:
caf::PdmChildArrayField<RimFishbonesMultipleSubs*> fishbonesSubs;
void recalculateStartMD();
double startMD() const { return m_startMD(); }
protected:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
private:
cvf::Color3f nextFishbonesColor() const;
private:
caf::PdmChildField<RimFishboneWellPathCollection*> m_wellPathCollection;
caf::PdmField<double> m_startMD;
caf::PdmField<double> m_mainBoreDiameter;
caf::PdmField<double> m_linerDiameter;
};

9
ApplicationCode/ProjectDataModel/Completions/RimFishbonesMultipleSubs.cpp
View File

@@ -22,6 +22,7 @@
#include "RigWellPath.h"
#include "RimProject.h"
#include "RimWellPath.h"
#include "RimFishbonesCollection.h"
#include "cafPdmUiListEditor.h"
@@ -99,7 +100,7 @@ RimFishbonesMultipleSubs::RimFishbonesMultipleSubs()
m_pipeProperties = new RimFishbonesPipeProperties;
m_name.uiCapability()->setUiReadOnly(true);
nameField()->uiCapability()->setUiReadOnly(true);
m_rigFishbonesGeometry = std::unique_ptr<RigFisbonesGeometry>(new RigFisbonesGeometry(this));
@@ -334,6 +335,10 @@ void RimFishbonesMultipleSubs::computeRangesAndLocations()
m_locationOfSubs = validMeasuredDepths;
}
RimFishbonesCollection* collection;
this->firstAncestorOrThisOfTypeAsserted(collection);
collection->recalculateStartMD();
}
//--------------------------------------------------------------------------------------------------
@@ -463,7 +468,7 @@ void RimFishbonesMultipleSubs::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTr
CVF_ASSERT(container);
size_t index = container->index(this);
m_name = QString("Fishbone %1").arg(index);
this->setName(QString("Fishbone %1").arg(index));
}
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/ProjectDataModel/Completions/RimFishbonesMultipleSubs.h
View File

@@ -81,6 +81,7 @@ public:
double tubingDiameter() const;
double holeDiameter() const { return m_pipeProperties()->holeDiameter(); }
double skinFactor() const { return m_pipeProperties()->skinFactor(); }
double openHoleRoughnessFactor() const { return m_lateralOpenHoleRoghnessFactor(); }
double icdOrificeDiameter() const { return m_icdOrificeDiameter(); }
double icdFlowCoefficient() const { return m_icdFlowCoefficient(); }

24
ApplicationCode/ProjectDataModel/Completions/RimFracture.cpp
View File

@@ -90,7 +90,7 @@ RimFracture::RimFracture(void)
CAF_PDM_InitField(&dip, "Dip", 0.0, "Dip", "", "", "");
CAF_PDM_InitField(&tilt, "Tilt", 0.0, "Tilt", "", "", "");
CAF_PDM_InitField(&showPolygonFractureOutline, "showPolygonFractureOutline", true, "Show Polygon Outline", "", "", "");
CAF_PDM_InitField(&fractureUnit, "fractureUnit", caf::AppEnum<RimDefines::UnitSystem>(RimDefines::UNITS_METRIC), "Fracture Unit System", "", "", "");
CAF_PDM_InitField(&fractureUnit, "fractureUnit", caf::AppEnum<RimUnitSystem::UnitSystem>(RimUnitSystem::UNITS_METRIC), "Fracture Unit System", "", "", "");
CAF_PDM_InitField(&stimPlanTimeIndexToPlot, "timeIndexToPlot", 0, "StimPlan Time Step", "", "", "");
@@ -164,15 +164,15 @@ void RimFracture::fieldChangedByUi(const caf::PdmFieldHandle* changedField, cons
if (changedField == &fractureUnit)
{
if (fractureUnit == RimDefines::UNITS_METRIC)
if (fractureUnit == RimUnitSystem::UNITS_METRIC)
{
wellDiameter = RimDefines::inchToMeter(wellDiameter);
perforationLength = RimDefines::feetToMeter(perforationLength);
wellDiameter = RimUnitSystem::inchToMeter(wellDiameter);
perforationLength = RimUnitSystem::feetToMeter(perforationLength);
}
else if (fractureUnit == RimDefines::UNITS_FIELD)
else if (fractureUnit == RimUnitSystem::UNITS_FIELD)
{
wellDiameter = RimDefines::meterToInch(wellDiameter);
perforationLength = RimDefines::meterToFeet(perforationLength);
wellDiameter = RimUnitSystem::meterToInch(wellDiameter);
perforationLength = RimUnitSystem::meterToFeet(perforationLength);
}
this->updateConnectedEditors();
}
@@ -264,13 +264,13 @@ void RimFracture::computeGeometry()
//--------------------------------------------------------------------------------------------------
double RimFracture::wellRadius() const
{
if (fractureUnit == RimDefines::UNITS_METRIC)
if (fractureUnit == RimUnitSystem::UNITS_METRIC)
{
return wellDiameter / 2;
}
else if (fractureUnit == RimDefines::UNITS_FIELD)
else if (fractureUnit == RimUnitSystem::UNITS_FIELD)
{
return RimDefines::inchToFeet(wellDiameter / 2);
return RimUnitSystem::inchToFeet(wellDiameter / 2);
}
return cvf::UNDEFINED_DOUBLE;
}
@@ -398,12 +398,12 @@ QList<caf::PdmOptionItemInfo> RimFracture::calculateValueOptions(const caf::PdmF
//--------------------------------------------------------------------------------------------------
void RimFracture::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
if (fractureUnit == RimDefines::UNITS_METRIC)
if (fractureUnit == RimUnitSystem::UNITS_METRIC)
{
wellDiameter.uiCapability()->setUiName("Well Diameter [m]");
perforationLength.uiCapability()->setUiName("Perforation Length [m]");
}
else if (fractureUnit == RimDefines::UNITS_FIELD)
else if (fractureUnit == RimUnitSystem::UNITS_FIELD)
{
wellDiameter.uiCapability()->setUiName("Well Diameter [inches]");
perforationLength.uiCapability()->setUiName("Perforation Length [Ft]");

4
ApplicationCode/ProjectDataModel/Completions/RimFracture.h
View File

@@ -19,7 +19,7 @@
#pragma once
#include "RimCheckableNamedObject.h"
#include "RimDefines.h"
#include "RimUnitSystem.h"
#include "cvfBase.h"
#include "cvfObject.h"
@@ -65,7 +65,7 @@ public:
caf::PdmField<int> stimPlanTimeIndexToPlot;
caf::PdmField<bool> showPolygonFractureOutline;
caf::PdmField< caf::AppEnum< RimDefines::UnitSystem > > fractureUnit;
caf::PdmField< RimUnitSystem::UnitSystemType > fractureUnit;
double wellRadius() const;
cvf::Vec3d anchorPosition() const ;

10
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.cpp
View File

@@ -65,7 +65,7 @@ RimFractureTemplate::RimFractureTemplate(void)
CAF_PDM_InitObject("Fracture Template", ":/FractureTemplate16x16.png", "", "");
CAF_PDM_InitField(&name, "UserDescription", QString("Fracture Template"), "Name", "", "", "");
CAF_PDM_InitField(&fractureTemplateUnit, "fractureTemplateUnit", caf::AppEnum<RimDefines::UnitSystem>(RimDefines::UNITS_METRIC), "Units System", "", "", "");
CAF_PDM_InitField(&fractureTemplateUnit, "fractureTemplateUnit", caf::AppEnum<RimUnitSystem::UnitSystem>(RimUnitSystem::UNITS_METRIC), "Units System", "", "", "");
fractureTemplateUnit.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitField(&orientation, "Orientation", caf::AppEnum<FracOrientationEnum>(TRANSVERSE_WELL_PATH), "Fracture Orientation", "", "", "");
@@ -170,12 +170,12 @@ void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
void RimFractureTemplate::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
if (fractureTemplateUnit == RimDefines::UNITS_METRIC)
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
{
wellDiameter.uiCapability()->setUiName("Well Diameter [m]");
perforationLength.uiCapability()->setUiName("Perforation Length [m]");
}
else if (fractureTemplateUnit == RimDefines::UNITS_FIELD)
else if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
{
wellDiameter.uiCapability()->setUiName("Well Diameter [inches]");
perforationLength.uiCapability()->setUiName("Perforation Length [Ft]");
@@ -226,11 +226,11 @@ void RimFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandle* field
//--------------------------------------------------------------------------------------------------
void RimFractureTemplate::setDefaultWellDiameterFromUnit()
{
if (fractureTemplateUnit == RimDefines::UNITS_FIELD)
if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD)
{
wellDiameter = 8.5;
}
else if (fractureTemplateUnit == RimDefines::UNITS_METRIC)
else if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC)
{
wellDiameter = 0.216;
}

8
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RimDefines.h"
#include "RimUnitSystem.h"
#include "cafAppEnum.h"
#include "cafPdmField.h"
@@ -69,15 +69,15 @@ public:
};
caf::PdmField< caf::AppEnum< FracConductivityEnum > > fractureConductivity;
caf::PdmField< caf::AppEnum< RimDefines::UnitSystem > > fractureTemplateUnit;
caf::PdmField< RimUnitSystem::UnitSystemType > fractureTemplateUnit;
void setDefaultWellDiameterFromUnit();
virtual caf::PdmFieldHandle* userDescriptionField() override;
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
virtual void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimDefines::UnitSystem fractureTemplateUnit) = 0;
virtual std::vector<cvf::Vec3f> fracturePolygon(RimDefines::UnitSystem fractureTemplateUnit) = 0;
virtual void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureTemplateUnit) = 0;
virtual std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureTemplateUnit) = 0;
virtual const RigFractureGrid* fractureGrid() const = 0;

2
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplateCollection.cpp
View File

@@ -34,7 +34,7 @@ RimFractureTemplateCollection::RimFractureTemplateCollection(void)
{
CAF_PDM_InitObject("Fracture Templates", ":/FractureTemplates16x16.png", "", "");
CAF_PDM_InitField(&defaultUnitsForFracTemplates, "defaultUnitForFracTemplates", caf::AppEnum<RimDefines::UnitSystem>(RimDefines::UNITS_METRIC), "Default unit system for fracture templates", "", "", "");
CAF_PDM_InitField(&defaultUnitsForFracTemplates, "defaultUnitForFracTemplates", caf::AppEnum<RimUnitSystem::UnitSystem>(RimUnitSystem::UNITS_METRIC), "Default unit system for fracture templates", "", "", "");
CAF_PDM_InitFieldNoDefault(&fractureDefinitions, "FractureDefinitions", "", "", "", "");
fractureDefinitions.uiCapability()->setUiHidden(true);
}

4
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplateCollection.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RimDefines.h"
#include "RimUnitSystem.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
@@ -39,7 +39,7 @@ public:
virtual ~RimFractureTemplateCollection(void);
caf::PdmChildArrayField<RimFractureTemplate*> fractureDefinitions;
caf::PdmField< caf::AppEnum< RimDefines::UnitSystem > > defaultUnitsForFracTemplates;
caf::PdmField< RimUnitSystem::UnitSystemType > defaultUnitsForFracTemplates;
std::vector<std::pair<QString, QString> > stimPlanResultNamesAndUnits() const;
std::vector<QString> stimPlanResultNames() const;

4
ApplicationCode/ProjectDataModel/Completions/RimPerforationCollection.cpp
View File

@@ -40,8 +40,8 @@ RimPerforationCollection::RimPerforationCollection()
{
CAF_PDM_InitObject("Perforations", ":/PerforationIntervals16x16.png", "", "");
m_name.uiCapability()->setUiHidden(true);
m_name = "Perforations";
nameField()->uiCapability()->setUiHidden(true);
this->setName("Perforations");
CAF_PDM_InitFieldNoDefault(&m_perforations, "Perforations", "Perforations", "", "", "");
m_perforations.uiCapability()->setUiHidden(true);

4
ApplicationCode/ProjectDataModel/Completions/RimPerforationInterval.cpp
View File

@@ -46,7 +46,7 @@ RimPerforationInterval::RimPerforationInterval()
CAF_PDM_InitFieldNoDefault(&m_date, "StartDate", "Start Date", "", "", "");
m_date.uiCapability()->setUiEditorTypeName(caf::PdmUiLineEditor::uiEditorTypeName());
m_name.uiCapability()->setUiReadOnly(true);
nameField()->uiCapability()->setUiReadOnly(true);
}
//--------------------------------------------------------------------------------------------------
@@ -153,7 +153,7 @@ void RimPerforationInterval::fieldChangedByUi(const caf::PdmFieldHandle* changed
//--------------------------------------------------------------------------------------------------
void RimPerforationInterval::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
{
m_name = QString("%1 - %2").arg(m_startMD).arg(m_endMD);
this->setName(QString("%1 - %2").arg(m_startMD).arg(m_endMD));
}
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/Completions/RimSimWellFracture.cpp
View File

@@ -184,7 +184,7 @@ void RimSimWellFracture::defineUiOrdering(QString uiConfigName, caf::PdmUiOrderi
RimFracture::defineUiOrdering(uiConfigName, uiOrdering);
fractureUnit.uiCapability()->setUiReadOnly(true);
uiOrdering.add(&m_name);
uiOrdering.add(nameField());
uiOrdering.add(&showPolygonFractureOutline);
caf::PdmUiGroup* locationGroup = uiOrdering.addNewGroup("Location / Orientation");

40
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp
View File

@@ -245,12 +245,12 @@ void RimStimPlanFractureTemplate::readStimPlanXMLFile(QString * errorMessage)
{
if (unit == "md-ft")
{
fractureTemplateUnit = RimDefines::UNITS_FIELD;
fractureTemplateUnit = RimUnitSystem::UNITS_FIELD;
RiaLogging::info(QString("Setting unit system to Field for StimPlan fracture template %1").arg(name));
}
if (unit == "md-m")
{
fractureTemplateUnit = RimDefines::UNITS_METRIC;
fractureTemplateUnit = RimUnitSystem::UNITS_METRIC;
RiaLogging::info(QString("Setting unit system to Metric for StimPlan fracture template %1").arg(name));
}
}
@@ -617,7 +617,7 @@ QString RimStimPlanFractureTemplate::getAttributeValueString(QXmlStreamReader &x
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimDefines::UnitSystem fractureUnit)
void RimStimPlanFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureUnit)
{
if (m_stimPlanFractureDefinitionData.isNull())
@@ -636,17 +636,17 @@ void RimStimPlanFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* node
RiaLogging::debug(QString("No conversion necessary for %1").arg(name));
}
else if (fractureTemplateUnit() == RimDefines::UNITS_METRIC && fractureUnit == RimDefines::UNITS_FIELD)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_METRIC && fractureUnit == RimUnitSystem::UNITS_FIELD)
{
RiaLogging::info(QString("Converting StimPlan geometry from metric to field for fracture template %1").arg(name));
for (double& value : adjustedDepths) value = RimDefines::meterToFeet(value);
for (double& value : xCoords) value = RimDefines::meterToFeet(value);
for (double& value : adjustedDepths) value = RimUnitSystem::meterToFeet(value);
for (double& value : xCoords) value = RimUnitSystem::meterToFeet(value);
}
else if (fractureTemplateUnit() == RimDefines::UNITS_FIELD && fractureUnit == RimDefines::UNITS_METRIC)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_FIELD && fractureUnit == RimUnitSystem::UNITS_METRIC)
{
RiaLogging::info(QString("Converting StimPlan geometry from field to metric for fracture template %1").arg(name));
for (double& value : adjustedDepths) value = RimDefines::feetToMeter(value);
for (double& value : xCoords) value = RimDefines::feetToMeter(value);
for (double& value : adjustedDepths) value = RimUnitSystem::feetToMeter(value);
for (double& value : xCoords) value = RimUnitSystem::feetToMeter(value);
}
else
{
@@ -827,8 +827,8 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
std::vector<std::vector<double>> displayPropertyValuesAtTimeStep = getMirroredDataAtTimeIndex(resultNameFromColors, resultUnitFromColors, activeTimeStepIndex);
QString condUnit;
if (fractureTemplateUnit == RimDefines::UNITS_METRIC) condUnit = "md-m";
if (fractureTemplateUnit == RimDefines::UNITS_FIELD) condUnit = "md-ft";
if (fractureTemplateUnit == RimUnitSystem::UNITS_METRIC) condUnit = "md-m";
if (fractureTemplateUnit == RimUnitSystem::UNITS_FIELD) condUnit = "md-ft";
std::vector<std::vector<double>> conductivityValuesAtTimeStep = getMirroredDataAtTimeIndex("CONDUCTIVITY", condUnit, activeTimeStepIndex);
std::vector<double> depthCoordsAtNodes = adjustedDepthCoordsAroundWellPathPosition();
@@ -952,7 +952,7 @@ std::vector<cvf::Vec3d> RimStimPlanFractureTemplate::getStimPlanColPolygon(size_
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3f> RimStimPlanFractureTemplate::fracturePolygon(RimDefines::UnitSystem fractureUnit)
std::vector<cvf::Vec3f> RimStimPlanFractureTemplate::fracturePolygon(RimUnitSystem::UnitSystem fractureUnit)
{
std::vector<cvf::Vec3f> polygon;
@@ -1012,25 +1012,25 @@ std::vector<cvf::Vec3f> RimStimPlanFractureTemplate::fracturePolygon(RimDefines:
RiaLogging::debug(QString("No conversion necessary for %1").arg(name));
}
else if (fractureTemplateUnit() == RimDefines::UNITS_METRIC && fractureUnit == RimDefines::UNITS_FIELD)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_METRIC && fractureUnit == RimUnitSystem::UNITS_FIELD)
{
RiaLogging::info(QString("Converting StimPlan geometry from metric to field for fracture template %1").arg(name));
for (cvf::Vec3f& node : polygon)
{
float x = RimDefines::meterToFeet(node.x());
float y = RimDefines::meterToFeet(node.y());
float z = RimDefines::meterToFeet(node.z());
float x = RimUnitSystem::meterToFeet(node.x());
float y = RimUnitSystem::meterToFeet(node.y());
float z = RimUnitSystem::meterToFeet(node.z());
node = cvf::Vec3f(x, y, z);
}
}
else if (fractureTemplateUnit() == RimDefines::UNITS_FIELD && fractureUnit == RimDefines::UNITS_METRIC)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_FIELD && fractureUnit == RimUnitSystem::UNITS_METRIC)
{
RiaLogging::info(QString("Converting StimPlan geometry from field to metric for fracture template %1").arg(name));
for (cvf::Vec3f& node : polygon)
{
float x = RimDefines::feetToMeter(node.x());
float y = RimDefines::feetToMeter(node.y());
float z = RimDefines::feetToMeter(node.z());
float x = RimUnitSystem::feetToMeter(node.x());
float y = RimUnitSystem::feetToMeter(node.y());
float z = RimUnitSystem::feetToMeter(node.z());
node = cvf::Vec3f(x, y, z);
}
}

4
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.h
View File

@@ -66,8 +66,8 @@ public:
const QString& fileName();
QString fileNameWithOutPath();
void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimDefines::UnitSystem fractureUnit) override;
std::vector<cvf::Vec3f> fracturePolygon(RimDefines::UnitSystem fractureUnit);
void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureUnit) override;
std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureUnit);
void sortPolygon(std::vector<cvf::Vec3f> &polygon);
std::vector<double> getStimPlanTimeValues();

2
ApplicationCode/ProjectDataModel/Completions/RimWellPathFracture.cpp
View File

@@ -159,7 +159,7 @@ void RimWellPathFracture::defineUiOrdering(QString uiConfigName, caf::PdmUiOrder
{
RimFracture::defineUiOrdering(uiConfigName, uiOrdering);
uiOrdering.add(&m_name);
uiOrdering.add(nameField());
uiOrdering.add(&showPolygonFractureOutline);
caf::PdmUiGroup* locationGroup = uiOrdering.addNewGroup("Location / Orientation");