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

#3884 Implemented Valve Templates for MSW parameters

Browse Source
This commit is contained in:
Gaute Lindkvist
2018-12-13 19:49:37 +01:00
parent c575e1d29e
commit 3adb1cc4bd
39 changed files with 1117 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ApplicationCode/Application/RiaDefines.cpp
View File

@@ -72,6 +72,7 @@ namespace caf
addItem(RiaDefines::CASING, "CASING", "Casing");
addItem(RiaDefines::LINER, "LINER", "Liner");
addItem(RiaDefines::PACKER, "PACKER", "Packer");
addItem(RiaDefines::UNDEFINED_COMPONENT, "UNDEFINED", "Undefined Component");
setDefault(RiaDefines::WELL_PATH);
}
}

3
ApplicationCode/Application/RiaDefines.h
View File

@@ -55,7 +55,8 @@ namespace RiaDefines
// Well path construction features
CASING,
LINER,
PACKER
PACKER,
UNDEFINED_COMPONENT
};
bool isPerCellFaceResult(const QString& resultName);

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

@@ -515,7 +515,7 @@ cvf::Color3f RiaColorTables::undefinedCellColor()
//--------------------------------------------------------------------------------------------------
RiaColorTables::WellPathComponentColors RiaColorTables::wellPathComponentColors()
{
return {{RiaDefines::WELL_PATH, cvf::Color3::CEETRON},
return {{RiaDefines::WELL_PATH, cvf::Color3::CEETRON},
{RiaDefines::PERFORATION_INTERVAL, cvf::Color3::DARK_MAGENTA},
{RiaDefines::FISHBONES, cvf::Color3::DARK_GREEN},
{RiaDefines::FRACTURE, cvf::Color3::CRIMSON},
@@ -524,7 +524,8 @@ RiaColorTables::WellPathComponentColors RiaColorTables::wellPathComponentColors(
{RiaDefines::ICV, cvf::Color3::ORCHID},
{RiaDefines::CASING, cvf::Color3::SEA_GREEN},
{RiaDefines::LINER, cvf::Color3::OLIVE},
{RiaDefines::PACKER, cvf::Color3::GRAY}};
{RiaDefines::PACKER, cvf::Color3::GRAY},
{RiaDefines::UNDEFINED_COMPONENT, cvf::Color3::MAGENTA}};
}
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/Application/Tools/RiaImportEclipseCaseTools.cpp
View File

@@ -30,12 +30,12 @@
#include "RigGridManager.h"
#include "RimCaseCollection.h"
#include "RimCompletionTemplateCollection.h"
#include "RimEclipseCaseCollection.h"
#include "RimEclipseCellColors.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimFileSummaryCase.h"
#include "RimFractureTemplateCollection.h"
#include "RimGridSummaryCase.h"
#include "RimIdenticalGridCaseGroup.h"
#include "RimMainPlotCollection.h"
@@ -159,7 +159,7 @@ bool RiaImportEclipseCaseTools::openEclipseCasesFromFile(const QStringList& file
RiaLogging::error(errorMessage);
}
project->activeOilField()->fractureDefinitionCollection()->setDefaultUnitSystemBasedOnLoadedCases();
project->activeOilField()->completionTemplateCollection()->setDefaultUnitSystemBasedOnLoadedCases();
RiuPlotMainWindowTools::refreshToolbars();

2
ApplicationCode/Commands/CompletionCommands/CMakeLists_files.cmake
View File

@@ -7,6 +7,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicNewFishbonesSubsFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicNewPerforationIntervalFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicNewPerforationIntervalAtMeasuredDepthFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicNewValveFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicNewValveTemplateFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicWellPathImportCompletionsFileFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicWellPathImportPerforationIntervalsFeature.h
)
@@ -19,6 +20,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicNewFishbonesSubsFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNewPerforationIntervalFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNewPerforationIntervalAtMeasuredDepthFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNewValveFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNewValveTemplateFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicWellPathImportCompletionsFileFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicWellPathImportPerforationIntervalsFeature.cpp
)

16
ApplicationCode/Commands/CompletionCommands/RicNewValveFeature.cpp
View File

@@ -3,6 +3,7 @@
#include "RiaApplication.h"
#include "RimPerforationInterval.h"
#include "RimProject.h"
#include "RimWellPathValve.h"
#include "RimWellPathCollection.h"
@@ -18,7 +19,7 @@ CAF_CMD_SOURCE_INIT(RicNewValveFeature, "RicNewValveFeature");
bool RicNewValveFeature::isCommandEnabled()
{
const RimPerforationInterval* perfInterval = caf::SelectionManager::instance()->selectedItemOfType<RimPerforationInterval>();
return perfInterval != nullptr && RiaApplication::enableDevelopmentFeatures();
return perfInterval != nullptr;
}
//--------------------------------------------------------------------------------------------------
@@ -30,6 +31,19 @@ void RicNewValveFeature::onActionTriggered(bool isChecked)
if (perfInterval)
{
RimWellPathValve* valve = new RimWellPathValve;
RimProject* project = nullptr;
perfInterval->firstAncestorOrThisOfTypeAsserted(project);
std::vector<RimWellPathValve*> existingValves = perfInterval->valves();
valve->setName(QString("Valve #%1").arg(existingValves.size() + 1));
std::vector<RimValveTemplate*> allValveTemplates = project->allValveTemplates();
if (!allValveTemplates.empty())
{
valve->setValveTemplate(allValveTemplates.front());
}
perfInterval->addValve(valve);
valve->setMeasuredDepthAndCount(perfInterval->startMD(), perfInterval->endMD() - perfInterval->startMD(), 1);

106
ApplicationCode/Commands/CompletionCommands/RicNewValveTemplateFeature.cpp Normal file
View File

@@ -0,0 +1,106 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016- Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// 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
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RicNewValveTemplateFeature.h"
#include "RiaApplication.h"
#include "RimEclipseView.h"
#include "RimValveTemplate.h"
#include "RimValveTemplateCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "Riu3DMainWindowTools.h"
#include "cafSelectionManager.h"
#include "cvfAssert.h"
#include <QAction>
CAF_CMD_SOURCE_INIT(RicNewValveTemplateFeature, "RicNewValveTemplateFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicNewValveTemplateFeature::selectValveTemplateAndUpdate(RimValveTemplateCollection* templateCollection,
RimValveTemplate* valveTemplate)
{
valveTemplate->loadDataAndUpdate();
templateCollection->updateConnectedEditors();
RimProject* project = RiaApplication::instance()->project();
std::vector<Rim3dView*> views;
project->allVisibleViews(views);
for (Rim3dView* view : views)
{
if (dynamic_cast<RimEclipseView*>(view))
{
view->updateConnectedEditors();
}
}
Riu3DMainWindowTools::selectAsCurrentItem(valveTemplate);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicNewValveTemplateFeature::onActionTriggered(bool isChecked)
{
RimProject* project = RiaApplication::instance()->project();
CVF_ASSERT(project);
RimOilField* oilfield = project->activeOilField();
if (oilfield == nullptr) return;
RimValveTemplateCollection* valveTemplateColl = oilfield->valveTemplateCollection();
if (valveTemplateColl)
{
RimValveTemplate* valveTemplate = new RimValveTemplate();
QString userLabel = QString("Valve Template #%1").arg(valveTemplateColl->valveTemplates().size() + 1);
valveTemplate->setUserLabel(userLabel);
valveTemplateColl->addValveTemplate(valveTemplate);
valveTemplate->setUnitSystem(valveTemplateColl->defaultUnitSystemType());
valveTemplate->setDefaultValuesFromUnits();
selectValveTemplateAndUpdate(valveTemplateColl, valveTemplate);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicNewValveTemplateFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setIcon(QIcon(":/ICDValve16x16.png"));
actionToSetup->setText("New Valve Template");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicNewValveTemplateFeature::isCommandEnabled()
{
return true;
}

43
ApplicationCode/Commands/CompletionCommands/RicNewValveTemplateFeature.h Normal file
View File

@@ -0,0 +1,43 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// 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
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cafCmdFeature.h"
#include <vector>
class RimValveTemplate;
class RimValveTemplateCollection;
//==================================================================================================
///
//==================================================================================================
class RicNewValveTemplateFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
public:
static void selectValveTemplateAndUpdate(RimValveTemplateCollection* templateCollection,
RimValveTemplate* valveTemplate);
protected:
void onActionTriggered(bool isChecked) override;
void setupActionLook(QAction* actionToSetup) override;
bool isCommandEnabled() override;
};

42
ApplicationCode/Commands/CompletionExportCommands/RicMswValveAccumulators.cpp
View File

@@ -69,7 +69,7 @@ void RicMswICDAccumulator::applyToSuperValve(std::shared_ptr<RicMswValve> valve)
///
//--------------------------------------------------------------------------------------------------
RicMswAICDAccumulator::RicMswAICDAccumulator(RiaEclipseUnitTools::UnitSystem unitSystem)
: RicMswValveAccumulator(unitSystem), m_valid(false), m_deviceOpen(false)
: RicMswValveAccumulator(unitSystem), m_valid(false), m_deviceOpen(false), m_accumulatedLength(0.0)
{
}
@@ -86,26 +86,28 @@ bool RicMswAICDAccumulator::accumulateValveParameters(const RimWellPathValve* we
{
m_valid = true;
m_deviceOpen = m_deviceOpen || params->isOpen();
std::array<double, AICD_NUM_PARAMS> values = params->doubleValues();
for (size_t i = 0; i < (size_t)AICD_NUM_PARAMS; ++i)
if (params->isOpen())
{
if (RiaStatisticsTools::isValidNumber(values[i]))
std::array<double, AICD_NUM_PARAMS> values = params->doubleValues();
for (size_t i = 0; i < (size_t)AICD_NUM_PARAMS; ++i)
{
m_meanCalculators[i].addValueAndWeight(values[i], contributionFraction);
if (RiaStatisticsTools::isValidNumber(values[i]))
{
m_meanCalculators[i].addValueAndWeight(values[i], contributionFraction);
}
}
std::pair<double, double> valveSegment = wellPathValve->valveSegments()[subValve];
double valveSegmentLength = std::fabs(valveSegment.second - valveSegment.first);
const RimPerforationInterval* perfInterval = nullptr;
wellPathValve->firstAncestorOrThisOfTypeAsserted(perfInterval);
double perfIntervalLength = std::fabs(perfInterval->endMD() - perfInterval->startMD());
double lengthFraction = 1.0;
if (perfIntervalLength > 1.0e-8)
{
lengthFraction = valveSegmentLength / perfIntervalLength;
}
m_accumulatedLength += lengthFraction * contributionFraction;
}
std::pair<double, double> valveSegment = wellPathValve->valveSegments()[subValve];
double valveSegmentLength = std::fabs(valveSegment.second - valveSegment.first);
const RimPerforationInterval* perfInterval = nullptr;
wellPathValve->firstAncestorOrThisOfTypeAsserted(perfInterval);
double perfIntervalLength = std::fabs(perfInterval->endMD() - perfInterval->startMD());
double lengthFraction = 1.0;
if (perfIntervalLength > 1.0e-8)
{
lengthFraction = valveSegmentLength / perfIntervalLength;
}
m_lengthCalculator.addValueAndWeight(lengthFraction, contributionFraction);
}
return true;
}
@@ -136,10 +138,8 @@ void RicMswAICDAccumulator::applyToSuperValve(std::shared_ptr<RicMswValve> valve
}
aicd->setIsValid(m_valid);
aicd->setIsOpen(m_deviceOpen);
if (m_lengthCalculator.validAggregatedWeight())
{
aicd->setLength(m_lengthCalculator.weightedMean());
}
aicd->setLength(m_accumulatedLength);
aicd->values() = values;
}
}

2
ApplicationCode/Commands/CompletionExportCommands/RicMswValveAccumulators.h
View File

@@ -70,5 +70,5 @@ private:
bool m_valid;
bool m_deviceOpen;
std::array<RiaWeightedMeanCalculator<double>, AICD_NUM_PARAMS> m_meanCalculators;
RiaWeightedMeanCalculator<double> m_lengthCalculator;
double m_accumulatedLength;
};

2
ApplicationCode/Commands/FractureCommands/RicCreateMultipleFracturesOptionItemUi.cpp
View File

@@ -138,7 +138,7 @@ QList<caf::PdmOptionItemInfo>
if (fieldNeedingOptions == &m_fractureTemplate)
{
RimOilField* oilField = proj->activeOilField();
if (oilField && oilField->fractureDefinitionCollection)
if (oilField && oilField->fractureDefinitionCollection())
{
RimFractureTemplateCollection* fracDefColl = oilField->fractureDefinitionCollection();

2
ApplicationCode/Commands/FractureCommands/RicNewEllipseFractureTemplateFeature.cpp
View File

@@ -81,7 +81,7 @@ void RicNewEllipseFractureTemplateFeature::onActionTriggered(bool isChecked)
fracDefColl->addFractureTemplate(ellipseFractureTemplate);
ellipseFractureTemplate->setName("Ellipse Fracture Template");
ellipseFractureTemplate->setFractureTemplateUnit(fracDefColl->defaultUnitSystemType());
ellipseFractureTemplate->setUnitSystem(fracDefColl->defaultUnitSystemType());
ellipseFractureTemplate->setDefaultValuesFromUnit();
selectFractureTemplateAndUpdate(fracDefColl, ellipseFractureTemplate);

2
ApplicationCode/Commands/FractureCommands/RicNewSimWellFractureAtPosFeature.cpp
View File

@@ -105,7 +105,7 @@ void RicNewSimWellFractureAtPosFeature::onActionTriggered(bool isChecked)
fracture->setFractureUnit(unitSet);
}
RimFractureTemplate* fracDef = oilfield->fractureDefinitionCollection->firstFractureOfUnit(unitSet);
RimFractureTemplate* fracDef = oilfield->fractureDefinitionCollection()->firstFractureOfUnit(unitSet);
fracture->setFractureTemplate(fracDef);
simWell->updateConnectedEditors();

2
ApplicationCode/Commands/FractureCommands/RicNewSimWellFractureFeature.cpp
View File

@@ -92,7 +92,7 @@ void RicNewSimWellFractureFeature::onActionTriggered(bool isChecked)
fracture->setFractureUnit(unitSet);
}
RimFractureTemplate* fracDef = oilfield->fractureDefinitionCollection->firstFractureOfUnit(unitSet);
RimFractureTemplate* fracDef = oilfield->fractureDefinitionCollection()->firstFractureOfUnit(unitSet);
fracture->setFractureTemplate(fracDef);
fracture->updateFracturePositionFromLocation();

2
ApplicationCode/Commands/FractureCommands/RicNewWellPathFractureFeature.cpp
View File

@@ -89,7 +89,7 @@ void RicNewWellPathFractureFeature::addFracture(RimWellPath* wellPath, double me
auto unitSet = wellPath->unitSystem();
fracture->setFractureUnit(unitSet);
RimFractureTemplate* fracDef = oilfield->fractureDefinitionCollection->firstFractureOfUnit(unitSet);
RimFractureTemplate* fracDef = oilfield->fractureDefinitionCollection()->firstFractureOfUnit(unitSet);
fracture->setFractureTemplate(fracDef);
wellPath->updateConnectedEditors();

6
ApplicationCode/Commands/RicDeleteItemExec.cpp
View File

@@ -51,6 +51,7 @@
#include "RiuPlotMainWindow.h"
#include "RimFractureTemplateCollection.h"
#include "RimValveTemplateCollection.h"
#include "cafNotificationCenter.h"
@@ -154,9 +155,12 @@ void RicDeleteItemExec::redo()
view->scheduleCreateDisplayModelAndRedraw();
}
RimValveTemplateCollection* valveTemplateColl;
RimFractureTemplateCollection* fracTemplateColl;
parentObj->firstAncestorOrThisOfType(fracTemplateColl);
if (fracTemplateColl)
parentObj->firstAncestorOrThisOfType(valveTemplateColl);
if (fracTemplateColl || valveTemplateColl)
{
RimProject* proj = nullptr;
parentObj->firstAncestorOrThisOfType(proj);

3
ApplicationCode/Commands/RicDeleteItemFeature.cpp
View File

@@ -60,10 +60,12 @@
#include "RimSimWellFracture.h"
#include "RimSimWellFractureCollection.h"
#include "RimStimPlanFractureTemplate.h"
#include "RimValveTemplate.h"
#include "RimWellPathFracture.h"
#include "RimWellPathFractureCollection.h"
#include "cafCmdExecCommandManager.h"
#include "cafCmdSelectionHelper.h"
#include "cafPdmChildArrayField.h"
@@ -121,6 +123,7 @@ bool isDeletable(caf::PdmUiItem* uiItem)
if (dynamic_cast<RimWellPathFracture*>(uiItem)) return true;
if (dynamic_cast<RimEllipseFractureTemplate*>(uiItem)) return true;
if (dynamic_cast<RimStimPlanFractureTemplate*>(uiItem)) return true;
if (dynamic_cast<RimValveTemplate*>(uiItem)) return true;
if (dynamic_cast<RimSimWellFractureCollection*>(uiItem)) return true;
if (dynamic_cast<RimSimWellFracture*>(uiItem)) return true;
if (dynamic_cast<RimEnsembleCurveSet*>(uiItem)) return true;

7
ApplicationCode/ProjectDataModel/Completions/CMakeLists_files.cmake
View File

@@ -15,7 +15,10 @@ ${CMAKE_CURRENT_LIST_DIR}/RimFractureContainment.h
${CMAKE_CURRENT_LIST_DIR}/RimFractureContainmentTools.h
${CMAKE_CURRENT_LIST_DIR}/RimFractureExportSettings.h
${CMAKE_CURRENT_LIST_DIR}/RimFractureTemplate.h
${CMAKE_CURRENT_LIST_DIR}/RimCompletionTemplateCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimFractureTemplateCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimValveTemplateCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimValveTemplate.h
${CMAKE_CURRENT_LIST_DIR}/RimSimWellFracture.h
${CMAKE_CURRENT_LIST_DIR}/RimSimWellFractureCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimStimPlanFractureTemplate.h
@@ -28,6 +31,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimWellPathComponentInterface.h
${CMAKE_CURRENT_LIST_DIR}/RimWellPathValve.h
${CMAKE_CURRENT_LIST_DIR}/RimMultipleValveLocations.h
${CMAKE_CURRENT_LIST_DIR}/RimWellPathAicdParameters.h
)
@@ -47,7 +51,10 @@ ${CMAKE_CURRENT_LIST_DIR}/RimFractureContainment.cpp
${CMAKE_CURRENT_LIST_DIR}/RimFractureContainmentTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RimFractureExportSettings.cpp
${CMAKE_CURRENT_LIST_DIR}/RimFractureTemplate.cpp
${CMAKE_CURRENT_LIST_DIR}/RimCompletionTemplateCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimFractureTemplateCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimValveTemplateCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimValveTemplate.cpp
${CMAKE_CURRENT_LIST_DIR}/RimSimWellFracture.cpp
${CMAKE_CURRENT_LIST_DIR}/RimSimWellFractureCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimStimPlanFractureTemplate.cpp

110
ApplicationCode/ProjectDataModel/Completions/RimCompletionTemplateCollection.cpp Normal file
View File

@@ -0,0 +1,110 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// 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
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimCompletionTemplateCollection.h"
#include "RimFractureTemplateCollection.h"
#include "RimValveTemplateCollection.h"
#include "cafPdmUiTreeOrdering.h"
#include "cvfAssert.h"
CAF_PDM_SOURCE_INIT(RimCompletionTemplateCollection, "CompletionTemplateCollection");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCompletionTemplateCollection::RimCompletionTemplateCollection()
{
CAF_PDM_InitObject("Completion Templates", ":/CompletionsSymbol16x16.png", "", "");
CAF_PDM_InitFieldNoDefault(&m_fractureTemplates, "FractureTemplates", "", "", "", "");
m_fractureTemplates = new RimFractureTemplateCollection;
CAF_PDM_InitFieldNoDefault(&m_valveTemplates, "ValveTemplates", "", "", "", "");
m_valveTemplates = new RimValveTemplateCollection;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCompletionTemplateCollection::~RimCompletionTemplateCollection()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimFractureTemplateCollection* RimCompletionTemplateCollection::fractureTemplateCollection()
{
return m_fractureTemplates;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimFractureTemplateCollection* RimCompletionTemplateCollection::fractureTemplateCollection() const
{
return m_fractureTemplates;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimValveTemplateCollection* RimCompletionTemplateCollection::valveTemplateCollection()
{
return m_valveTemplates;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimValveTemplateCollection* RimCompletionTemplateCollection::valveTemplateCollection() const
{
return m_valveTemplates;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCompletionTemplateCollection::setDefaultUnitSystemBasedOnLoadedCases()
{
m_fractureTemplates->setDefaultUnitSystemBasedOnLoadedCases();
m_valveTemplates->setDefaultUnitSystemBasedOnLoadedCases();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCompletionTemplateCollection::setFractureTemplateCollection(RimFractureTemplateCollection* fractureTemplateCollection)
{
CVF_ASSERT(!m_fractureTemplates->fractureTemplates().empty());
m_fractureTemplates = fractureTemplateCollection;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCompletionTemplateCollection::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
{
uiTreeOrdering.add(m_fractureTemplates);
uiTreeOrdering.add(m_valveTemplates);
uiTreeOrdering.skipRemainingChildren(true);
}

51
ApplicationCode/ProjectDataModel/Completions/RimCompletionTemplateCollection.h Normal file
View File

@@ -0,0 +1,51 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// 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
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cafPdmChildField.h"
#include "cafPdmObject.h"
class RimOilField;
class RimValveTemplateCollection;
class RimFractureTemplateCollection;
class RimCompletionTemplateCollection : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RimCompletionTemplateCollection();
~RimCompletionTemplateCollection() override;
RimFractureTemplateCollection* fractureTemplateCollection();
const RimFractureTemplateCollection* fractureTemplateCollection() const;
RimValveTemplateCollection* valveTemplateCollection();
const RimValveTemplateCollection* valveTemplateCollection() const;
void setDefaultUnitSystemBasedOnLoadedCases();
private:
friend class RimOilField;
void setFractureTemplateCollection(RimFractureTemplateCollection* fractureTemplateCollection);
caf::PdmChildField<RimFractureTemplateCollection*> m_fractureTemplates;
caf::PdmChildField<RimValveTemplateCollection*> m_valveTemplates;
protected:
virtual void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "") override;
};

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

@@ -394,7 +394,7 @@ void RimEllipseFractureTemplate::convertToUnitSystem(RiaEclipseUnitTools::UnitSy
{
if (m_fractureTemplateUnit() == neededUnit) return;
setFractureTemplateUnit(neededUnit);
setUnitSystem(neededUnit);
RimFractureTemplate::convertToUnitSystem(neededUnit);
if (neededUnit == RiaEclipseUnitTools::UNITS_FIELD)

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

@@ -537,7 +537,7 @@ QList<caf::PdmOptionItemInfo> RimFracture::calculateValueOptions(const caf::PdmF
if (fieldNeedingOptions == &m_fractureTemplate)
{
RimOilField* oilField = proj->activeOilField();
if (oilField && oilField->fractureDefinitionCollection)
if (oilField && oilField->fractureDefinitionCollection())
{
RimFractureTemplateCollection* fracDefColl = oilField->fractureDefinitionCollection();

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

@@ -208,7 +208,7 @@ void RimFractureTemplate::setName(const QString& name)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimFractureTemplate::setFractureTemplateUnit(RiaEclipseUnitTools::UnitSystemType unitSystem)
void RimFractureTemplate::setUnitSystem(RiaEclipseUnitTools::UnitSystemType unitSystem)
{
m_fractureTemplateUnit = unitSystem;
}

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

@@ -153,7 +153,7 @@ public:
virtual std::vector<std::pair<QString, QString>> uiResultNamesWithUnit() const = 0;
void setName(const QString& name);
void setFractureTemplateUnit(RiaEclipseUnitTools::UnitSystemType unitSystem);
void setUnitSystem(RiaEclipseUnitTools::UnitSystemType unitSystem);
void setDefaultWellDiameterFromUnit();
bool isNonDarcyFlowEnabled() const;

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

@@ -268,14 +268,14 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_UNKNOWN)
{
setFractureTemplateUnit(m_stimPlanFractureDefinitionData->unitSet());
setUnitSystem(m_stimPlanFractureDefinitionData->unitSet());
}
m_readError = false;
}
else
{
setFractureTemplateUnit(RiaEclipseUnitTools::UNITS_UNKNOWN);
setUnitSystem(RiaEclipseUnitTools::UNITS_UNKNOWN);
m_readError = true;
}
@@ -716,7 +716,7 @@ void RimStimPlanFractureTemplate::convertToUnitSystem(RiaEclipseUnitTools::UnitS
{
if (m_fractureTemplateUnit() == neededUnit) return;
setFractureTemplateUnit(neededUnit);
setUnitSystem(neededUnit);
RimFractureTemplate::convertToUnitSystem(neededUnit);
m_readError = false;

260
ApplicationCode/ProjectDataModel/Completions/RimValveTemplate.cpp Normal file
View File

@@ -0,0 +1,260 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// 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
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimValveTemplate.h"
#include "RimWellPathAicdParameters.h"
#include "RimWellPathValve.h"
#include "cafPdmUiTreeOrdering.h"
CAF_PDM_SOURCE_INIT(RimValveTemplate, "ValveTemplate");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimValveTemplate::RimValveTemplate()
{
CAF_PDM_InitObject("Valve Template", ":/ICDValve16x16.png", "", "");
CAF_PDM_InitField(&m_valveTemplateUnit, "UnitSystem", caf::AppEnum<RiaEclipseUnitTools::UnitSystem>(RiaEclipseUnitTools::UNITS_UNKNOWN), "Units System", "", "", "");
m_valveTemplateUnit.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault(&m_type, "CompletionType", "Type", "", "", "");
m_type = RiaDefines::ICD;
CAF_PDM_InitField(&m_userLabel, "UserLabel", QString("Template"), "Name", "", "", "");
this->setName(fullLabel());
CAF_PDM_InitField(&m_orificeDiameter, "OrificeDiameter", 8.0, "Orifice Diameter [mm]", "", "", "");
CAF_PDM_InitField(&m_flowCoefficient, "FlowCoefficient", 0.7, "Flow Coefficient", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_aicdParameters, "AICDParameters", "AICD Parameters", "", "", "");
m_aicdParameters = new RimWellPathAicdParameters;
m_aicdParameters.uiCapability()->setUiTreeHidden(true);
m_aicdParameters.uiCapability()->setUiTreeChildrenHidden(true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimValveTemplate::~RimValveTemplate()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::loadDataAndUpdate()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::setUnitSystem(RiaEclipseUnitTools::UnitSystemType unitSystem)
{
m_valveTemplateUnit = unitSystem;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::setDefaultValuesFromUnits()
{
if (m_valveTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
m_orificeDiameter = 8;
}
else if (m_valveTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
m_orificeDiameter = 0.315;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaDefines::WellPathComponentType RimValveTemplate::type() const
{
return m_type();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimValveTemplate::templateUnits() const
{
return m_valveTemplateUnit;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimValveTemplate::orificeDiameter() const
{
return m_orificeDiameter;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimValveTemplate::flowCoefficient() const
{
return m_flowCoefficient;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimWellPathAicdParameters* RimValveTemplate::aicdParameters() const
{
return m_aicdParameters;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimValveTemplate::typeLabel() const
{
return m_type().uiText();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimValveTemplate::fullLabel() const
{
QString label = QString("%1 (%2)").arg(m_userLabel()).arg(typeLabel());
return label;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::setUserLabel(const QString& userLabel)
{
m_userLabel = userLabel;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimValveTemplate::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly)
{
QList<caf::PdmOptionItemInfo> options;
if (fieldNeedingOptions == &m_type)
{
std::set<RiaDefines::WellPathComponentType> supportedTypes = {RiaDefines::ICD, RiaDefines::AICD, RiaDefines::ICV};
for (RiaDefines::WellPathComponentType type : supportedTypes)
{
options.push_back(caf::PdmOptionItemInfo(CompletionTypeEnum::uiText(type), type));
}
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&m_type);
uiOrdering.add(&m_userLabel);
if (m_type() == RiaDefines::ICV || m_type() == RiaDefines::ICD)
{
if (m_valveTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC)
{
m_orificeDiameter.uiCapability()->setUiName("Orifice Diameter [mm]");
}
else if (m_valveTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD)
{
m_orificeDiameter.uiCapability()->setUiName("Orifice Diameter [in]");
}
}
if (m_type() == RiaDefines::ICV || m_type() == RiaDefines::ICD)
{
caf::PdmUiGroup* group = uiOrdering.addNewGroup("MSW Valve Parameters");
group->add(&m_orificeDiameter);
group->add(&m_flowCoefficient);
}
else
{
caf::PdmUiGroup* group = uiOrdering.addNewGroup("MSW AICD Parameters");
m_aicdParameters->uiOrdering(uiConfigName, *group);
}
bool readOnly = uiConfigName == QString("InsideValve");
m_type.uiCapability()->setUiReadOnly(readOnly);
m_userLabel.uiCapability()->setUiReadOnly(readOnly);
m_orificeDiameter.uiCapability()->setUiReadOnly(readOnly);
m_flowCoefficient.uiCapability()->setUiReadOnly(readOnly);
uiOrdering.skipRemainingFields(true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
const QVariant& oldValue,
const QVariant& newValue)
{
if (changedField == &m_type || changedField == &m_userLabel)
{
this->setName(fullLabel());
}
if (changedField == &m_type)
{
if (m_type() == RiaDefines::ICV)
{
this->setUiIcon(QIcon(":/ICVValve16x16.png"));
}
else if (m_type() == RiaDefines::ICD)
{
this->setUiIcon(QIcon(":/ICDValve16x16.png"));
}
else if (m_type() == RiaDefines::AICD)
{
this->setUiIcon(QIcon(":/AICDValve16x16.png"));
}
std::vector<caf::PdmFieldHandle*> referringFields;
this->referringPtrFields(referringFields);
for (caf::PdmFieldHandle* field : referringFields)
{
RimWellPathValve* valve = dynamic_cast<RimWellPathValve*>(field->ownerObject());
valve->templateUpdated();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplate::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
{
this->setName(fullLabel());
}

73
ApplicationCode/ProjectDataModel/Completions/RimValveTemplate.h Normal file
View File

@@ -0,0 +1,73 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// 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
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiaDefines.h"
#include "RiaEclipseUnitTools.h"
#include "RimCheckableNamedObject.h"
#include "cafPdmChildField.h"
class RimWellPathAicdParameters;
class RimValveTemplate : public RimNamedObject
{
CAF_PDM_HEADER_INIT;
public:
RimValveTemplate();
~RimValveTemplate() override;
void loadDataAndUpdate();
void setUnitSystem(RiaEclipseUnitTools::UnitSystemType unitSystem);
void setDefaultValuesFromUnits();
RiaDefines::WellPathComponentType type() const;
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);
protected:
QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly) override;
void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "") override;
private:
typedef caf::AppEnum<RiaDefines::WellPathComponentType> CompletionTypeEnum;
caf::PdmField<RiaEclipseUnitTools::UnitSystemType> m_valveTemplateUnit;
caf::PdmField<CompletionTypeEnum> m_type;
caf::PdmField<QString> m_userLabel;
// ICD and ICVs only
caf::PdmField<double> m_orificeDiameter;
caf::PdmField<double> m_flowCoefficient;
// AICDs
caf::PdmChildField<RimWellPathAicdParameters*> m_aicdParameters;
};

90
ApplicationCode/ProjectDataModel/Completions/RimValveTemplateCollection.cpp Normal file
View File

@@ -0,0 +1,90 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// 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
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimValveTemplateCollection.h"
#include "RiaApplication.h"
#include "RimProject.h"
#include "RimValveTemplate.h"
CAF_PDM_SOURCE_INIT(RimValveTemplateCollection, "ValveTemplateCollection");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimValveTemplateCollection::RimValveTemplateCollection()
{
CAF_PDM_InitObject("Valve Templates", ":/ICDValve16x16.png", "", "");
CAF_PDM_InitFieldNoDefault(&m_valveDefinitions, "ValveDefinitions", "", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_defaultUnitsForValveTemplates, "ValveUnits", "", "", "", "");
m_defaultUnitsForValveTemplates = RiaEclipseUnitTools::UNITS_METRIC;
m_valveDefinitions.uiCapability()->setUiHidden(true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimValveTemplateCollection::~RimValveTemplateCollection()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimValveTemplate*> RimValveTemplateCollection::valveTemplates() const
{
std::vector<RimValveTemplate*> templates;
for (auto& templ : m_valveDefinitions)
{
templates.push_back(templ);
}
return templates;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplateCollection::addValveTemplate(RimValveTemplate* valveTemplate)
{
m_valveDefinitions.push_back(valveTemplate);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaEclipseUnitTools::UnitSystemType RimValveTemplateCollection::defaultUnitSystemType() const
{
return m_defaultUnitsForValveTemplates;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimValveTemplateCollection::setDefaultUnitSystemBasedOnLoadedCases()
{
RimProject* proj = RiaApplication::instance()->project();
auto commonUnitSystem = proj->commonUnitSystemForAllCases();
if (commonUnitSystem != RiaEclipseUnitTools::UNITS_UNKNOWN)
{
m_defaultUnitsForValveTemplates = commonUnitSystem;
}
}

50
ApplicationCode/ProjectDataModel/Completions/RimValveTemplateCollection.h Normal file
View File

@@ -0,0 +1,50 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// 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
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiaEclipseUnitTools.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmChildArrayField.h"
class RimValveTemplate;
//==================================================================================================
///
///
//==================================================================================================
class RimValveTemplateCollection : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RimValveTemplateCollection();
~RimValveTemplateCollection() override;
std::vector<RimValveTemplate*> valveTemplates() const;
void addValveTemplate(RimValveTemplate* valveTemplate);
RiaEclipseUnitTools::UnitSystemType defaultUnitSystemType() const;
void setDefaultUnitSystemBasedOnLoadedCases();
private:
caf::PdmChildArrayField<RimValveTemplate*> m_valveDefinitions;
caf::PdmField< RiaEclipseUnitTools::UnitSystemType > m_defaultUnitsForValveTemplates;
};

12
ApplicationCode/ProjectDataModel/Completions/RimWellPathAicdParameters.cpp
View File

@@ -154,19 +154,23 @@ std::array<double, AICD_NUM_PARAMS> RimWellPathAicdParameters::doubleValues() co
//--------------------------------------------------------------------------------------------------
void RimWellPathAicdParameters::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* requiredGroup = uiOrdering.addNewGroup("Required Parameters");
requiredGroup->add(&m_deviceOpen);
bool readOnly = uiConfigName == QString("InsideValve");
uiOrdering.add(&m_deviceOpen);
m_deviceOpen.uiCapability()->setUiReadOnly(readOnly);
for (int i = 0; i < (int)AICD_NUM_REQ_PARAMS; ++i)
{
requiredGroup->add(&m_aicdParameterFields[(AICDParameters) i]);
uiOrdering.add(&m_aicdParameterFields[(AICDParameters) i]);
m_aicdParameterFields[(AICDParameters) i].uiCapability()->setUiReadOnly(readOnly);
}
caf::PdmUiGroup* additionalGroup = uiOrdering.addNewGroup("Additional Parameters");
for (int i = (int)AICD_NUM_REQ_PARAMS; i < (int)AICD_NUM_PARAMS; ++i)
{
additionalGroup->add(&m_aicdParameterFields[(AICDParameters) i]);
m_aicdParameterFields[(AICDParameters)i].uiCapability()->setUiReadOnly(readOnly);
}
additionalGroup->setCollapsedByDefault(true);
additionalGroup->setCollapsedByDefault(true);
}
//--------------------------------------------------------------------------------------------------

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

@@ -56,6 +56,7 @@ public:
std::array<double, AICD_NUM_PARAMS> doubleValues() const;
protected:
void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute) override;

212
ApplicationCode/ProjectDataModel/Completions/RimWellPathValve.cpp
View File

@@ -27,6 +27,7 @@
#include "RimMultipleValveLocations.h"
#include "RimPerforationInterval.h"
#include "RimProject.h"
#include "RimValveTemplate.h"
#include "RimWellPath.h"
#include "cafPdmUiDoubleSliderEditor.h"
@@ -40,8 +41,7 @@ RimWellPathValve::RimWellPathValve()
{
CAF_PDM_InitObject("WellPathValve", ":/ICDValve16x16.png", "", "");
CAF_PDM_InitFieldNoDefault(&m_type, "CompletionType", "Type ", "", "", "");
m_type = RiaDefines::ICD;
CAF_PDM_InitFieldNoDefault(&m_valveTemplate, "ValveTemplate", "Valve Template", "", "", "");
CAF_PDM_InitField(&m_measuredDepth, "StartMeasuredDepth", 0.0, "Start MD", "", "", "");
m_measuredDepth.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
@@ -52,13 +52,6 @@ RimWellPathValve::RimWellPathValve()
m_multipleValveLocations.uiCapability()->setUiTreeChildrenHidden(true);
nameField()->uiCapability()->setUiReadOnly(true);
CAF_PDM_InitField(&m_orificeDiameter, "OrificeDiameter", 8.0, "Orifice Diameter [mm]", "", "", "");
CAF_PDM_InitField(&m_flowCoefficient, "FlowCoefficient", 0.7, "Flow Coefficient", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_aicdParameters, "AICDParameters", "AICD Parameters", "", "", "");
m_aicdParameters = new RimWellPathAicdParameters;
m_aicdParameters.uiCapability()->setUiTreeHidden(true);
m_aicdParameters.uiCapability()->setUiTreeChildrenHidden(true);
}
//--------------------------------------------------------------------------------------------------
@@ -74,7 +67,7 @@ RimWellPathValve::~RimWellPathValve()
//--------------------------------------------------------------------------------------------------
void RimWellPathValve::perforationIntervalUpdated()
{
if (m_type() == RiaDefines::ICV)
if (componentType() == RiaDefines::ICV)
{
const RimPerforationInterval* perfInterval = nullptr;
this->firstAncestorOrThisOfType(perfInterval);
@@ -82,7 +75,7 @@ void RimWellPathValve::perforationIntervalUpdated()
double endMD = perfInterval->endMD();
m_measuredDepth = cvf::Math::clamp(m_measuredDepth(), startMD, endMD);
}
else
else if (componentType() == RiaDefines::ICD || componentType() == RiaDefines::AICD)
{
m_multipleValveLocations->perforationIntervalUpdated();
}
@@ -120,11 +113,11 @@ void RimWellPathValve::multipleValveGeometryUpdated()
std::vector<double> RimWellPathValve::valveLocations() const
{
std::vector<double> valveDepths;
if (m_type() == RiaDefines::ICV)
if (componentType() == RiaDefines::ICV)
{
valveDepths.push_back(m_measuredDepth);
}
else
else if (componentType() == RiaDefines::ICD || componentType() == RiaDefines::AICD)
{
valveDepths = m_multipleValveLocations->valveLocations();
}
@@ -136,9 +129,12 @@ std::vector<double> RimWellPathValve::valveLocations() const
//--------------------------------------------------------------------------------------------------
double RimWellPathValve::orificeDiameter(RiaEclipseUnitTools::UnitSystem unitSystem) const
{
RimWellPath* wellPath;
firstAncestorOrThisOfTypeAsserted(wellPath);
return convertOrificeDiameter(m_orificeDiameter(), wellPath->unitSystem(), unitSystem);
if (m_valveTemplate())
{
double templateDiameter = m_valveTemplate()->orificeDiameter();
return convertOrificeDiameter(templateDiameter, m_valveTemplate()->templateUnits(), unitSystem);
}
return 0.0;
}
//--------------------------------------------------------------------------------------------------
@@ -146,26 +142,56 @@ double RimWellPathValve::orificeDiameter(RiaEclipseUnitTools::UnitSystem unitSys
//--------------------------------------------------------------------------------------------------
double RimWellPathValve::flowCoefficient() const
{
return m_flowCoefficient();
if (m_valveTemplate())
{
double templateCoefficient = m_valveTemplate()->orificeDiameter();
return templateCoefficient;
}
return 0.0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPathValve::setUnitSpecificDefaults()
void RimWellPathValve::setValveTemplate(RimValveTemplate* valveTemplate)
{
RimWellPath* wellPath;
firstAncestorOrThisOfType(wellPath);
if (wellPath)
m_valveTemplate = valveTemplate;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPathValve::applyValveLabelAndIcon()
{
if (componentType() == RiaDefines::ICV)
{
if (wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC)
{
m_orificeDiameter = 8;
}
else if (wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD)
{
m_orificeDiameter = 0.315;
}
this->setUiIcon(QIcon(":/ICVValve16x16.png"));
QString fullName = QString("%1: %2").arg(componentLabel()).arg(m_measuredDepth());
this->setName(fullName);
}
else if (componentType() == RiaDefines::ICD)
{
this->setUiIcon(QIcon(":/ICDValve16x16.png"));
QString fullName = QString("%1 %2: %3 - %4")
.arg(m_multipleValveLocations->valveLocations().size())
.arg(componentLabel())
.arg(m_multipleValveLocations->rangeStart())
.arg(m_multipleValveLocations->rangeEnd());
this->setName(fullName);
}
else if (componentType() == RiaDefines::AICD)
{
this->setUiIcon(QIcon(":/AICDValve16x16.png"));
QString fullName = QString("%1 %2: %3 - %4")
.arg(m_multipleValveLocations->valveLocations().size())
.arg(componentLabel())
.arg(m_multipleValveLocations->rangeStart())
.arg(m_multipleValveLocations->rangeEnd());
this->setName(fullName);
}
else
{
this->setName("Unspecified Valve");
}
}
@@ -174,7 +200,11 @@ void RimWellPathValve::setUnitSpecificDefaults()
//--------------------------------------------------------------------------------------------------
const RimWellPathAicdParameters* RimWellPathValve::aicdParameters() const
{
return m_aicdParameters();
if (m_valveTemplate())
{
return m_valveTemplate()->aicdParameters();
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
@@ -257,7 +287,11 @@ bool RimWellPathValve::isEnabled() const
//--------------------------------------------------------------------------------------------------
RiaDefines::WellPathComponentType RimWellPathValve::componentType() const
{
return m_type();
if (m_valveTemplate())
{
return m_valveTemplate()->type();
}
return RiaDefines::UNDEFINED_COMPONENT;
}
//--------------------------------------------------------------------------------------------------
@@ -265,7 +299,14 @@ RiaDefines::WellPathComponentType RimWellPathValve::componentType() const
//--------------------------------------------------------------------------------------------------
QString RimWellPathValve::componentLabel() const
{
return m_type().uiText();
if (componentType() == RiaDefines::ICD || componentType() == RiaDefines::AICD)
{
if (m_multipleValveLocations->valveLocations().size() > 1)
{
return "Valves";
}
}
return "Valve";
}
//--------------------------------------------------------------------------------------------------
@@ -273,7 +314,7 @@ QString RimWellPathValve::componentLabel() const
//--------------------------------------------------------------------------------------------------
QString RimWellPathValve::componentTypeLabel() const
{
return m_type().uiText();
return "Valve";
}
//--------------------------------------------------------------------------------------------------
@@ -289,7 +330,7 @@ cvf::Color3f RimWellPathValve::defaultComponentColor() const
//--------------------------------------------------------------------------------------------------
double RimWellPathValve::startMD() const
{
if (m_type() == RiaDefines::ICV)
if (componentType() == RiaDefines::ICV)
{
return m_measuredDepth;
}
@@ -308,7 +349,7 @@ double RimWellPathValve::startMD() const
//--------------------------------------------------------------------------------------------------
double RimWellPathValve::endMD() const
{
if (m_type() == RiaDefines::ICV)
if (componentType() == RiaDefines::ICV)
{
return m_measuredDepth + 0.5;
}
@@ -322,6 +363,22 @@ double RimWellPathValve::endMD() const
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPathValve::templateUpdated()
{
applyValveLabelAndIcon();
RimPerforationInterval* perfInterval;
this->firstAncestorOrThisOfTypeAsserted(perfInterval);
perfInterval->updateAllReferringTracks();
RimProject* proj;
this->firstAncestorOrThisOfTypeAsserted(proj);
proj->reloadCompletionTypeResultsInAllViews();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -329,14 +386,14 @@ QList<caf::PdmOptionItemInfo> RimWellPathValve::calculateValueOptions(const caf:
{
QList<caf::PdmOptionItemInfo> options;
if (fieldNeedingOptions == &m_type)
RimProject* project = nullptr;
this->firstAncestorOrThisOfTypeAsserted(project);
std::vector<RimValveTemplate*> allTemplates = project->allValveTemplates();
for (RimValveTemplate* valveTemplate : allTemplates)
{
std::set<RiaDefines::WellPathComponentType> supportedTypes = { RiaDefines::ICD, RiaDefines::AICD, RiaDefines::ICV };
for (RiaDefines::WellPathComponentType type : supportedTypes)
{
options.push_back(caf::PdmOptionItemInfo(CompletionTypeEnum::uiText(type), type));
}
options.push_back(caf::PdmOptionItemInfo(valveTemplate->name(), valveTemplate));
}
return options;
}
@@ -345,6 +402,12 @@ QList<caf::PdmOptionItemInfo> RimWellPathValve::calculateValueOptions(const caf:
//--------------------------------------------------------------------------------------------------
void RimWellPathValve::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &m_valveTemplate)
{
applyValveLabelAndIcon();
this->updateConnectedEditors();
}
RimPerforationInterval* perfInterval;
this->firstAncestorOrThisOfTypeAsserted(perfInterval);
perfInterval->updateAllReferringTracks();
@@ -359,55 +422,45 @@ void RimWellPathValve::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
//--------------------------------------------------------------------------------------------------
void RimWellPathValve::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&m_type);
uiOrdering.skipRemainingFields(true);
if (m_type() == RiaDefines::ICV || m_type() == RiaDefines::ICD)
{
RimWellPath* wellPath;
firstAncestorOrThisOfType(wellPath);
if (wellPath)
uiOrdering.add(&m_valveTemplate);
if (componentType() == RiaDefines::UNDEFINED_COMPONENT) return;
if (componentType() == RiaDefines::ICV || componentType() == RiaDefines::ICD)
{
if (componentType() == RiaDefines::ICV)
{
if (wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC)
RimWellPath* wellPath;
firstAncestorOrThisOfType(wellPath);
if (wellPath)
{
if (m_type() == RiaDefines::ICV)
if (wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_METRIC)
{
m_measuredDepth.uiCapability()->setUiName("Measured Depth [m]");
m_measuredDepth.uiCapability()->setUiName("Measured Depth [m]");
}
m_orificeDiameter.uiCapability()->setUiName("Orifice Diameter [mm]");
}
else if (wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD)
{
if (m_type() == RiaDefines::ICV)
else if (wellPath->unitSystem() == RiaEclipseUnitTools::UNITS_FIELD)
{
m_measuredDepth.uiCapability()->setUiName("Measured Depth [ft]");
}
m_orificeDiameter.uiCapability()->setUiName("Orifice Diameter [in]");
}
}
if (m_type() == RiaDefines::ICV)
{
uiOrdering.add(&m_measuredDepth);
}
}
if (m_type() == RiaDefines::ICD || m_type() == RiaDefines::AICD)
if (componentType() == RiaDefines::ICD || componentType() == RiaDefines::AICD)
{
caf::PdmUiGroup* group = uiOrdering.addNewGroup("Multiple Valve Locations");
m_multipleValveLocations->uiOrdering(uiConfigName, *group);
}
if (m_type() == RiaDefines::ICV || m_type() == RiaDefines::ICD)
if (m_valveTemplate)
{
caf::PdmUiGroup* group = uiOrdering.addNewGroup("MSW Valve Parameters");
group->add(&m_orificeDiameter);
group->add(&m_flowCoefficient);
caf::PdmUiGroup* group = uiOrdering.addNewGroup("Parameters from Template");
m_valveTemplate->uiOrdering("InsideValve", *group);
}
else
{
caf::PdmUiGroup* group = uiOrdering.addNewGroup("MSW AICD Parameters");
m_aicdParameters->uiOrdering(uiConfigName, *group);
}
uiOrdering.skipRemainingFields(true);
}
//--------------------------------------------------------------------------------------------------
@@ -455,22 +508,5 @@ void RimWellPathValve::defineEditorAttribute(const caf::PdmFieldHandle* field, Q
//--------------------------------------------------------------------------------------------------
void RimWellPathValve::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
{
if ( m_type() == RiaDefines::ICV )
{
this->setUiIcon(QIcon(":/ICVValve16x16.png"));
QString fullName = QString("%1: %2").arg(componentLabel()).arg(m_measuredDepth());
this->setName(fullName);
}
else if ( m_type() == RiaDefines::ICD )
{
this->setUiIcon(QIcon(":/ICDValve16x16.png"));
QString fullName = QString("%1: %2 - %3").arg(componentLabel()).arg(m_multipleValveLocations->rangeStart()).arg(m_multipleValveLocations->rangeEnd());
this->setName(fullName);
}
else if ( m_type() == RiaDefines::AICD )
{
this->setUiIcon(QIcon(":/AICDValve16x16.png"));
QString fullName = QString("%1: %2 - %3").arg(componentLabel()).arg(m_multipleValveLocations->rangeStart()).arg(m_multipleValveLocations->rangeEnd());
this->setName(fullName);
}
applyValveLabelAndIcon();
}

17
ApplicationCode/ProjectDataModel/Completions/RimWellPathValve.h
View File

@@ -22,12 +22,14 @@
#include "RimCheckableNamedObject.h"
#include "RimWellPathAicdParameters.h"
#include "RimWellPathComponentInterface.h"
#include "RimValveTemplate.h"
#include "cafPdmObject.h"
#include "cafAppEnum.h"
#include "cafPdmChildField.h"
#include "cafPdmField.h"
#include "cafPdmPtrField.h"
#include <QList>
#include <QString>
@@ -38,9 +40,7 @@ class RimWellPath;
class RimWellPathValve : public RimCheckableNamedObject, public RimWellPathComponentInterface
{
CAF_PDM_HEADER_INIT;
public:
typedef caf::AppEnum<RiaDefines::WellPathComponentType> CompletionTypeEnum;
public:
RimWellPathValve();
~RimWellPathValve() override;
@@ -50,8 +50,8 @@ public:
std::vector<double> valveLocations() const;
double orificeDiameter(RiaEclipseUnitTools::UnitSystem unitSystem) const;
double flowCoefficient() const;
void setUnitSpecificDefaults();
void setValveTemplate(RimValveTemplate* valveTemplate);
void applyValveLabelAndIcon();
const RimWellPathAicdParameters* aicdParameters() const;
static double convertOrificeDiameter(double orificeDiameterUi,
@@ -70,6 +70,7 @@ public:
double startMD() const override;
double endMD() const override;
void templateUpdated();
private:
QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly) override;
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
@@ -78,15 +79,11 @@ private:
void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "") override;
private:
caf::PdmField<CompletionTypeEnum> m_type;
caf::PdmPtrField<RimValveTemplate*> m_valveTemplate;
caf::PdmField<double> m_measuredDepth;
caf::PdmChildField<RimMultipleValveLocations*> m_multipleValveLocations;
// ICD and ICVs only
caf::PdmField<double> m_orificeDiameter;
caf::PdmField<double> m_flowCoefficient;
caf::PdmChildField<RimWellPathAicdParameters*> m_aicdParameters;
};

6
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@@ -100,6 +100,8 @@
#include "RimWellPathFracture.h"
#include "RimWellPathFractureCollection.h"
#include "RimModeledWellPath.h"
#include "RimValveTemplate.h"
#include "RimValveTemplateCollection.h"
#include "RiuMainWindow.h"
@@ -651,6 +653,10 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
{
menuBuilder << "RicNewSimWellFractureFeature";
}
else if (dynamic_cast<RimValveTemplateCollection*>(uiItem))
{
menuBuilder << "RicNewValveTemplateFeature";
}
else if (dynamic_cast<RimFractureTemplateCollection*>(uiItem))
{
menuBuilder << "RicPasteEllipseFractureFeature";

2
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@@ -1589,7 +1589,7 @@ void RimEclipseView::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering
CVF_ASSERT(project);
RimOilField* oilfield = project->activeOilField();
if (oilfield && oilfield->fractureDefinitionCollection().notNull())
if (oilfield && oilfield->fractureDefinitionCollection())
{
if (!oilfield->fractureDefinitionCollection()->fractureTemplates().empty())
{

64
ApplicationCode/ProjectDataModel/RimOilField.cpp
View File

@@ -21,9 +21,11 @@
#include "RimOilField.h"
#include "RimAnnotationCollection.h"
#include "RimCompletionTemplateCollection.h"
#include "RimEclipseCaseCollection.h"
#include "RimFormationNamesCollection.h"
#include "RimFractureTemplateCollection.h"
#include "RimValveTemplateCollection.h"
#include "RimGeoMechModels.h"
#include "RimObservedData.h"
#include "RimObservedDataCollection.h"
@@ -44,7 +46,7 @@ RimOilField::RimOilField(void)
CAF_PDM_InitFieldNoDefault(&geoMechModels, "GeoMechModels", "Geo Mech Models", ":/GridModels.png", "", "");
CAF_PDM_InitFieldNoDefault(&wellPathCollection, "WellPathCollection", "Well Paths", ":/WellCollection.png", "", "");
CAF_PDM_InitFieldNoDefault(&fractureDefinitionCollection, "FractureDefinitionCollection", "Defenition of Fractures", "", "", "");
CAF_PDM_InitFieldNoDefault(&completionTemplateCollection, "CompletionTemplateCollection", "", "", "", "");
CAF_PDM_InitFieldNoDefault(&summaryCaseMainCollection,"SummaryCaseCollection","Summary Cases",":/GridModels.png","","");
CAF_PDM_InitFieldNoDefault(&formationNamesCollection,"FormationNamesCollection","Formations","","","");
@@ -52,13 +54,19 @@ RimOilField::RimOilField(void)
CAF_PDM_InitFieldNoDefault(&annotationCollection, "AnnotationCollection", "Annotations", "", "", "");
fractureDefinitionCollection = new RimFractureTemplateCollection();
CAF_PDM_InitFieldNoDefault(
&m_fractureTemplateCollection_OBSOLETE, "FractureDefinitionCollection", "Defenition of Fractures", "", "", "");
completionTemplateCollection = new RimCompletionTemplateCollection;
analysisModels = new RimEclipseCaseCollection();
wellPathCollection = new RimWellPathCollection();
summaryCaseMainCollection = new RimSummaryCaseMainCollection();
observedDataCollection = new RimObservedDataCollection();
formationNamesCollection = new RimFormationNamesCollection();
annotationCollection = new RimAnnotationCollection();
m_fractureTemplateCollection_OBSOLETE = new RimFractureTemplateCollection;
m_fractureTemplateCollection_OBSOLETE.xmlCapability()->setIOWritable(false);
}
//--------------------------------------------------------------------------------------------------
@@ -66,15 +74,38 @@ RimOilField::RimOilField(void)
//--------------------------------------------------------------------------------------------------
RimOilField::~RimOilField(void)
{
if (wellPathCollection()) delete wellPathCollection();
}
if (fractureDefinitionCollection()) delete fractureDefinitionCollection();
if (geoMechModels()) delete geoMechModels();
if (analysisModels()) delete analysisModels();
if (summaryCaseMainCollection()) delete summaryCaseMainCollection();
if (formationNamesCollection()) delete formationNamesCollection();
if (observedDataCollection()) delete observedDataCollection();
if (annotationCollection()) delete annotationCollection();
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimFractureTemplateCollection* RimOilField::fractureDefinitionCollection()
{
return completionTemplateCollection()->fractureTemplateCollection();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimFractureTemplateCollection* RimOilField::fractureDefinitionCollection() const
{
return completionTemplateCollection()->fractureTemplateCollection();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimValveTemplateCollection* RimOilField::valveTemplateCollection()
{
return completionTemplateCollection()->valveTemplateCollection();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimValveTemplateCollection* RimOilField::valveTemplateCollection() const
{
return completionTemplateCollection()->valveTemplateCollection();
}
//--------------------------------------------------------------------------------------------------
@@ -145,3 +176,16 @@ QString RimOilField::uniqueShortNameForCase(RimSummaryCase* summaryCase)
return shortName;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimOilField::initAfterRead()
{
RimFractureTemplateCollection* fractureTemplateCollection = m_fractureTemplateCollection_OBSOLETE.value();
if (!fractureTemplateCollection->fractureTemplates().empty())
{
m_fractureTemplateCollection_OBSOLETE.removeChildObject(fractureTemplateCollection);
completionTemplateCollection->setFractureTemplateCollection(fractureTemplateCollection);
}
}

17
ApplicationCode/ProjectDataModel/RimOilField.h
View File

@@ -28,6 +28,8 @@
class RimEclipseCaseCollection;
class RimFormationNamesCollection;
class RimFractureTemplateCollection;
class RimCompletionTemplateCollection;
class RimValveTemplateCollection;
class RimGeoMechModels;
class RimObservedDataCollection;
class RimSummaryCase;
@@ -47,14 +49,27 @@ public:
RimOilField(void);
~RimOilField(void) override;
RimFractureTemplateCollection* fractureDefinitionCollection();
const RimFractureTemplateCollection* fractureDefinitionCollection() const;
RimValveTemplateCollection* valveTemplateCollection();
const RimValveTemplateCollection* valveTemplateCollection() const;
QString uniqueShortNameForCase(RimSummaryCase* summaryCase);
caf::PdmChildField<RimEclipseCaseCollection*> analysisModels;
caf::PdmChildField<RimGeoMechModels*> geoMechModels;
caf::PdmChildField<RimWellPathCollection*> wellPathCollection;
caf::PdmChildField<RimFractureTemplateCollection*> fractureDefinitionCollection;
caf::PdmChildField<RimCompletionTemplateCollection*> completionTemplateCollection;
caf::PdmChildField<RimSummaryCaseMainCollection*> summaryCaseMainCollection;
caf::PdmChildField<RimObservedDataCollection*> observedDataCollection;
caf::PdmChildField<RimFormationNamesCollection*> formationNamesCollection;
caf::PdmChildField<RimAnnotationCollection*> annotationCollection;
protected:
virtual void initAfterRead() override;
private:
caf::PdmChildField<RimFractureTemplateCollection*> m_fractureTemplateCollection_OBSOLETE;
};

37
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@@ -38,6 +38,7 @@
#include "RimCase.h"
#include "RimCaseCollection.h"
#include "RimCommandObject.h"
#include "RimCompletionTemplateCollection.h"
#include "RimContextCommandBuilder.h"
#include "RimDialogData.h"
#include "RimEclipseCase.h"
@@ -46,6 +47,8 @@
#include "RimFormationNamesCollection.h"
#include "RimFractureTemplate.h"
#include "RimFractureTemplateCollection.h"
#include "RimValveTemplate.h"
#include "RimValveTemplateCollection.h"
#include "RimGeoMechCase.h"
#include "RimGeoMechModels.h"
#include "RimGridSummaryCase.h"
@@ -1095,6 +1098,38 @@ std::vector<RimFractureTemplate*> RimProject::allFractureTemplates() const
return templates;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimValveTemplateCollection*> RimProject::allValveTemplateCollections() const
{
std::vector<RimValveTemplateCollection*> templColls;
std::vector<RimOilField*> rimOilFields;
allOilFields(rimOilFields);
for (RimOilField* oilField : rimOilFields)
{
templColls.push_back(oilField->valveTemplateCollection());
}
return templColls;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimValveTemplate*> RimProject::allValveTemplates() const
{
std::vector<RimValveTemplate*> templates;
for (RimValveTemplateCollection* templColl : allValveTemplateCollections())
{
for (RimValveTemplate* templ : templColl->valveTemplates())
{
templates.push_back(templ);
}
}
return templates;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1208,7 +1243,7 @@ void RimProject::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QS
if (oilField->geoMechModels()) uiTreeOrdering.add(oilField->geoMechModels());
if (oilField->wellPathCollection()) uiTreeOrdering.add(oilField->wellPathCollection());
if (oilField->formationNamesCollection()) uiTreeOrdering.add(oilField->formationNamesCollection());
if (oilField->fractureDefinitionCollection()) uiTreeOrdering.add(oilField->fractureDefinitionCollection());
if (oilField->completionTemplateCollection()) uiTreeOrdering.add(oilField->completionTemplateCollection());
if (oilField->annotationCollection()) uiTreeOrdering.add(oilField->annotationCollection());
}

8
ApplicationCode/ProjectDataModel/RimProject.h
View File

@@ -61,6 +61,9 @@ class RimWellPath;
class RimWellPathImport;
class RimFractureTemplateCollection;
class RimFractureTemplate;
class RimValveTemplateCollection;
class RimValveTemplate;
class RimCompletionTemplateCollection;
namespace caf
{
@@ -152,7 +155,10 @@ public:
std::vector<RimGeoMechCase*> geoMechCases() const;
std::vector<RimFractureTemplateCollection*> allFractureTemplateCollections() const;
std::vector<RimFractureTemplate*> allFractureTemplates() const;
std::vector<RimFractureTemplate*> allFractureTemplates() const;
std::vector<RimValveTemplateCollection*> allValveTemplateCollections() const;
std::vector<RimValveTemplate*> allValveTemplates() const;
RiaEclipseUnitTools::UnitSystemType commonUnitSystemForAllCases() const;