//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- bool RicImportSummaryCasesFeature::createSummaryCasesFromFiles(const QStringList& fileNames, std::vector<RimSummaryCase*>* newCases, bool ensembleOrGroup) { RiaApplication* app = RiaApplication::instance(); RimProject* proj = app->project(); RimSummaryCaseMainCollection* sumCaseColl = proj->activeOilField() ? proj->activeOilField()->summaryCaseMainCollection() : nullptr; if (newCases) newCases->clear(); if (!sumCaseColl) return false; RifSummaryCaseRestartSelector fileSelector; fileSelector.setEnsembleOrGroupMode(ensembleOrGroup); fileSelector.determineFilesToImportFromSummaryFiles(fileNames); std::vector<RifSummaryCaseFileResultInfo> importFileInfos = fileSelector.summaryFileInfos(); if (!importFileInfos.empty()) { std::vector<RimSummaryCase*> sumCases = sumCaseColl->createSummaryCasesFromFileInfos(importFileInfos, true); if (newCases) newCases->insert(newCases->end(), sumCases.begin(), sumCases.end()); } if (fileSelector.foundErrors()) { QString errorMessage = fileSelector.createCombinedErrorMessage(); RiaLogging::error(errorMessage); QMessageBox::warning(nullptr, QString("Problem Importing Summary Case File(s)"), errorMessage); } return true; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicReloadWellPathFormationNamesFeature::onActionTriggered(bool isChecked) { std::vector<RimWellPath*> wellPaths; caf::SelectionManager::instance()->objectsByType(&wellPaths); std::vector<RimWellPathCollection*> wellPathCollections; caf::SelectionManager::instance()->objectsByType(&wellPathCollections); if (wellPaths.size() > 0) { RimWellPathCollection* wellPathCollection; wellPaths[0]->firstAncestorOrThisOfTypeAsserted(wellPathCollection); wellPathCollection->reloadAllWellPathFormations(); } else if (wellPathCollections.size() > 0) { wellPathCollections[0]->reloadAllWellPathFormations(); } RimProject* project = RiaApplication::instance()->project(); if (project) { if (project->mainPlotCollection()) { project->mainPlotCollection->updatePlotsWithFormations(); } } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicSnapshotViewToFileFeature::onActionTriggered(bool isChecked) { RiaApplication* app = RiaApplication::instance(); RimProject* proj = app->project(); QString startPath; if (!proj->fileName().isEmpty()) { QFileInfo fi(proj->fileName()); startPath = fi.absolutePath(); } else { startPath = app->lastUsedDialogDirectory("IMAGE_SNAPSHOT"); } startPath += "/image.png"; QString fileName = QFileDialog::getSaveFileName(NULL, tr("Save File"), startPath, tr("Image files (*.bmp *.png * *.jpg)")); if (fileName.isEmpty()) { return; } // Remember the directory to next time app->setLastUsedDialogDirectory("IMAGE_SNAPSHOT", QFileInfo(fileName).absolutePath()); RimViewWindow* viewWindow = app->activeViewWindow(); RicSnapshotViewToFileFeature::saveSnapshotAs(fileName, viewWindow); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- QList<caf::PdmOptionItemInfo> RicCreateMultipleFracturesOptionItemUi::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly) { QList<caf::PdmOptionItemInfo> options; RimProject* proj = RiaApplication::instance()->project(); CVF_ASSERT(proj); if (fieldNeedingOptions == &m_fractureTemplate) { RimOilField* oilField = proj->activeOilField(); if (oilField && oilField->fractureDefinitionCollection()) { RimFractureTemplateCollection* fracDefColl = oilField->fractureDefinitionCollection(); for (RimFractureTemplate* fracDef : fracDefColl->fractureTemplates()) { QString displayText = fracDef->nameAndUnit(); options.push_back(caf::PdmOptionItemInfo(displayText, fracDef)); } } } return options; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicSetMasterViewFeature::onActionTriggered(bool isChecked) { RimView* activeView = RiaApplication::instance()->activeReservoirView(); if (!activeView) return; RimProject* proj = RiaApplication::instance()->project(); RimViewLinker* viewLinker = proj->viewLinkerCollection()->viewLinker(); viewLinker->applyRangeFilterCollectionByUserChoice(); RimView* previousMasterView = viewLinker->masterView(); viewLinker->setMasterView(activeView); viewLinker->updateDependentViews(); viewLinker->addDependentView(previousMasterView); proj->viewLinkerCollection.uiCapability()->updateConnectedEditors(); proj->updateConnectedEditors(); // Set managed view collection to selected and expanded in project tree caf::PdmUiTreeView* projTreeView = RiuMainWindow::instance()->projectTreeView(); projTreeView->selectAsCurrentItem(viewLinker); projTreeView->setExpanded(viewLinker, true); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimSummaryPlotSourceStepping::applyNextCase() { RimProject* proj = RiaApplication::instance()->project(); auto summaryCases = proj->allSummaryCases(); if (summaryCases.size() < 1) return; auto currentCase = std::find(summaryCases.begin(), summaryCases.end(), m_summaryCase()); if (currentCase != summaryCases.end()) { currentCase++; if (currentCase != summaryCases.end()) { m_summaryCase = *currentCase; } } else { m_summaryCase = summaryCases[0]; } fieldChangedByUi(&m_summaryCase, QVariant(), QVariant()); m_summaryCase.uiCapability()->updateConnectedEditors(); RimSummaryCurveCollection* curveCollection = nullptr; this->firstAncestorOrThisOfTypeAsserted(curveCollection); curveCollection->updateConnectedEditors(); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicNewValveTemplateFeature::selectValveTemplateAndUpdate(RimValveTemplate* valveTemplate) { valveTemplate->loadDataAndUpdate(); RimValveTemplateCollection* templateCollection = nullptr; valveTemplate->firstAncestorOrThisOfType(templateCollection); if (templateCollection) { 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 RicNewSummaryCurveFeature::onActionTriggered(bool isChecked) { RimProject* project = RiaApplication::instance()->project(); CVF_ASSERT(project); RimSummaryPlot* plot = selectedSummaryPlot(); if (plot) { RimSummaryCurve* newCurve = new RimSummaryCurve(); cvf::Color3f curveColor = RicWellLogPlotCurveFeatureImpl::curveColorFromTable(plot->curveCount()); newCurve->setColor(curveColor); plot->addCurveAndUpdate(newCurve); RimSummaryCase* defaultCase = nullptr; if (project->activeOilField()->summaryCaseMainCollection()->summaryCaseCount() > 0) { defaultCase = project->activeOilField()->summaryCaseMainCollection()->summaryCase(0); newCurve->setSummaryCaseY(defaultCase); newCurve->setSummaryAddressY(RifEclipseSummaryAddress::fieldVarAddress("FOPT")); newCurve->loadDataAndUpdate(true); } plot->updateConnectedEditors(); RiaApplication::instance()->getOrCreateAndShowMainPlotWindow()->selectAsCurrentItem(newCurve); RiuPlotMainWindow* mainPlotWindow = RiaApplication::instance()->mainPlotWindow(); mainPlotWindow->updateSummaryPlotToolBar(); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RimEclipseCase* RimGridSummaryCase::associatedEclipseCase() { if (!m_eclipseCase()) { // Find a possible associated eclipse case RimProject* project; firstAncestorOrThisOfTypeAsserted(project); std::vector<RimCase*> allCases; project->allCases(allCases); for ( RimCase* someCase: allCases ) { auto eclCase = dynamic_cast<RimEclipseCase*>(someCase); if ( eclCase ) { QString sumHeaderFileName = summaryHeaderFilenameFromEclipseCase(eclCase); if ( sumHeaderFileName == m_summaryHeaderFilename ) { m_eclipseCase = eclCase; this->updateAutoShortName(); this->updateTreeItemName(); break; } } } } return m_eclipseCase(); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicNewSummaryPlotFeature::onActionTriggered(bool isChecked) { RimProject* project = RiaApplication::instance()->project(); CVF_ASSERT(project); RimMainPlotCollection* mainPlotColl = project->mainPlotCollection(); CVF_ASSERT(mainPlotColl); RimSummaryPlotCollection* summaryPlotColl = mainPlotColl->summaryPlotCollection(); CVF_ASSERT(summaryPlotColl); RimSummaryCase* summaryCase = nullptr; std::vector<RimSummaryCase*> selection; caf::SelectionManager::instance()->objectsByType(&selection); if (selection.size() == 1) { summaryCase = selection[0]; } else { std::vector<RimSummaryCase*> cases; project->allSummaryCases(cases); if (cases.size() > 0) { summaryCase = cases[0]; } } createNewSummaryPlot(summaryPlotColl, summaryCase); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- std::set<std::string> RicSummaryCurveCreator::getAllSummaryWellNames() { std::set<std::string> summaryWellNames; RimProject* proj = RiaApplication::instance()->project(); std::vector<RimSummaryCase*> cases = proj->allSummaryCases(); for (RimSummaryCase* rimCase : cases) { RifSummaryReaderInterface* reader = nullptr; if (rimCase) { reader = rimCase->summaryReader(); } if (reader) { const std::vector<RifEclipseSummaryAddress> allAddresses = reader->allResultAddresses(); for (size_t i = 0; i < allAddresses.size(); i++) { if (allAddresses[i].category() == RifEclipseSummaryAddress::SUMMARY_WELL) { summaryWellNames.insert(allAddresses[i].wellName()); } } } } return summaryWellNames; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- bool RicNewPltPlotFeature::isCommandEnabled() { if (RicWellLogPlotCurveFeatureImpl::parentWellAllocationPlot()) return false; RimSimWellInView* simWell = caf::firstAncestorOfTypeFromSelectedObject<RimSimWellInView*>(); RimWellPath* selectedWellPath = caf::firstAncestorOfTypeFromSelectedObject<RimWellPath*>(); bool enable = true; if (selectedWellPath) { if (selectedWellPath->wellPathGeometry() == nullptr && !RimWellPlotTools::hasFlowData(selectedWellPath)) { return false; } } if (simWell != nullptr) { RimProject* proj = RiaApplication::instance()->project(); QString simWellName = simWell->name(); RimWellPath* wellPath = proj->wellPathFromSimWellName(simWellName); enable = wellPath != nullptr; } return enable; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimWellPath::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) { partMgr()->scheduleGeometryRegen(); RimProject* proj; this->firstAnchestorOrThisOfType(proj); if (proj) proj->createDisplayModelAndRedrawAllViews(); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimCompletionCellIntersectionCalc::calculateCompletionTypeResult(RimEclipseCase* eclipseCase, std::vector<double>& completionTypeCellResult, size_t timeStep) { CVF_ASSERT(eclipseCase && eclipseCase->eclipseCaseData()); RimProject* project = nullptr; eclipseCase->firstAncestorOrThisOfTypeAsserted(project); if (project->activeOilField()->wellPathCollection->isActive) { const RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData(); for (const RimWellPath* wellPath : project->activeOilField()->wellPathCollection->wellPaths) { if (wellPath->showWellPath() && wellPath->wellPathGeometry()) { auto intersectedCells = RigWellPathIntersectionTools::findIntersectedGlobalCellIndices( eclipseCaseData, wellPath->wellPathGeometry()->m_wellPathPoints); for (auto& intersection : intersectedCells) { completionTypeCellResult[intersection] = RiaDefines::WELL_PATH; } auto completions = eclipseCase->computeAndGetVirtualPerforationTransmissibilities(); if (completions) { for (const auto& completionsForWell : completions->multipleCompletionsPerEclipseCell(wellPath, timeStep)) { RiaDefines::WellPathComponentType appCompletionType = RiaDefines::WELL_PATH; auto appCompletionTypes = fromCompletionData(completionsForWell.second); if (std::find(appCompletionTypes.begin(), appCompletionTypes.end(), RiaDefines::FRACTURE) != appCompletionTypes.end()) { appCompletionType = RiaDefines::FRACTURE; } else if (std::find(appCompletionTypes.begin(), appCompletionTypes.end(), RiaDefines::FISHBONES) != appCompletionTypes.end()) { appCompletionType = RiaDefines::FISHBONES; } else if (std::find(appCompletionTypes.begin(), appCompletionTypes.end(), RiaDefines::PERFORATION_INTERVAL) != appCompletionTypes.end()) { appCompletionType = RiaDefines::PERFORATION_INTERVAL; } completionTypeCellResult[completionsForWell.first] = appCompletionType; } } } } } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- QList<caf::PdmOptionItemInfo> RimSummaryCurve::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly) { QList<caf::PdmOptionItemInfo> optionList = this->RimPlotCurve::calculateValueOptions(fieldNeedingOptions,useOptionsOnly); if (!optionList.isEmpty()) return optionList; if (fieldNeedingOptions == &m_summaryCase) { RimProject* proj = RiaApplication::instance()->project(); std::vector<RimSummaryCase*> cases; proj->allSummaryCases(cases); for (size_t i = 0; i < cases.size(); i++) { RimSummaryCase* rimCase = cases[i]; optionList.push_back(caf::PdmOptionItemInfo(rimCase->caseName(), QVariant::fromValue(caf::PdmPointer<caf::PdmObjectHandle>(rimCase)))); } if (optionList.size() > 0) { optionList.push_front(caf::PdmOptionItemInfo("None", QVariant::fromValue(caf::PdmPointer<caf::PdmObjectHandle>(NULL)))); } } else if(fieldNeedingOptions == &m_uiFilterResultSelection) { if(m_summaryCase) { RifReaderEclipseSummary* reader = summaryReader(); int addressCount = 0; if(reader) { const std::vector<RifEclipseSummaryAddress> allAddresses = reader->allResultAddresses(); addressCount = static_cast<int>(allAddresses.size()); std::map<RifEclipseSummaryAddress, int> addrToIdxMap; for(int i = 0; i <addressCount; i++) { if (!m_summaryFilter->isIncludedByFilter(allAddresses[i] )) continue; addrToIdxMap[allAddresses[i]] = i; } for (const auto& addrIntPair: addrToIdxMap) { std::string name = addrIntPair.first.uiText(); QString s = QString::fromStdString(name); optionList.push_back(caf::PdmOptionItemInfo(s, addrIntPair.second)); } } optionList.push_front(caf::PdmOptionItemInfo(RimDefines::undefinedResultName(), addressCount)); if(useOptionsOnly) *useOptionsOnly = true; } } return optionList; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicSnapshotAllPlotsToFileFeature::saveAllPlots() { RiaApplication* app = RiaApplication::instance(); RiuMainPlotWindow* mainPlotWindow = app->mainPlotWindow(); if (!mainPlotWindow) return; RimProject* proj = app->project(); if (!proj) return; // Save images in snapshot catalog relative to project directory QString snapshotFolderName = app->createAbsolutePathFromProjectRelativePath("snapshots"); QDir snapshotPath(snapshotFolderName); if (!snapshotPath.exists()) { if (!snapshotPath.mkpath(".")) return; } const QString absSnapshotPath = snapshotPath.absolutePath(); // Well log plots { std::vector<RimWellLogPlot*> wellLogPlots; proj->descendantsIncludingThisOfType(wellLogPlots); for (RimWellLogPlot* wellLogPlot : wellLogPlots) { if (wellLogPlot && wellLogPlot->viewWidget()) { QString fileName = wellLogPlot->description(); fileName.replace(" ", "_"); QString absoluteFileName = caf::Utils::constructFullFileName(absSnapshotPath, fileName, ".png"); RicSnapshotViewToFileFeature::saveSnapshotAs(absoluteFileName, wellLogPlot); } } } // Summary plots { std::vector<RimSummaryPlot*> summaryPlots; proj->descendantsIncludingThisOfType(summaryPlots); for (RimSummaryPlot* summaryPlot : summaryPlots) { if (summaryPlot && summaryPlot->viewWidget()) { QString fileName = summaryPlot->description(); fileName.replace(" ", "_"); QString absoluteFileName = caf::Utils::constructFullFileName(absSnapshotPath, fileName, ".png"); RicSnapshotViewToFileFeature::saveSnapshotAs(absoluteFileName, summaryPlot); } } } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimValveTemplateCollection::setDefaultUnitSystemBasedOnLoadedCases() { RimProject* proj = RiaApplication::instance()->project(); auto commonUnitSystem = proj->commonUnitSystemForAllCases(); if (commonUnitSystem != RiaEclipseUnitTools::UNITS_UNKNOWN) { m_defaultUnitsForValveTemplates = commonUnitSystem; } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicImportSummaryCasesFeature::addSummaryCases(const std::vector<RimSummaryCase*> cases) { RiaApplication* app = RiaApplication::instance(); RimProject* proj = app->project(); RimSummaryCaseMainCollection* sumCaseColl = proj->activeOilField() ? proj->activeOilField()->summaryCaseMainCollection() : nullptr; sumCaseColl->addCases(cases); sumCaseColl->updateAllRequiredEditors(); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimWellPathCollection::addWellPaths( QStringList filePaths ) { std::vector<RimWellPath*> wellPathArray; for (QString filePath : filePaths) { // Check if this file is already open bool alreadyOpen = false; for (size_t wpIdx = 0; wpIdx < wellPaths.size(); wpIdx++) { QFile f1; f1.setFileName(filePath); QString s1 = f1.fileName(); QFile f2; f2.setFileName(wellPaths[wpIdx]->filepath()); QString s2 = f2.fileName(); if (s1 == s2) { //printf("Attempting to open well path JSON file that is already open:\n %s\n", (const char*) filePath.toLocal8Bit()); alreadyOpen = true; break; } } if (!alreadyOpen) { QFileInfo fi(filePath); if (fi.suffix().compare("json") == 0) { RimWellPath* wellPath = new RimWellPath(); wellPath->filepath = filePath; wellPathArray.push_back(wellPath); } else { // Create Well path objects for all the paths in the assumed ascii file size_t wellPathCount = m_wellPathImporter->wellDataCount(filePath); for (size_t i = 0; i < wellPathCount; ++i) { RimWellPath* wellPath = new RimWellPath(); wellPath->filepath = filePath; wellPath->wellPathIndexInFile = static_cast<int>(i); wellPathArray.push_back(wellPath); } } } } readAndAddWellPaths(wellPathArray); RimProject* proj; firstAncestorOrThisOfTypeAsserted(proj); proj->reloadCompletionTypeResultsInAllViews(); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimSimWellInViewCollection::updateWellAllocationPlots() { RimProject* proj = RiaApplication::instance()->project(); std::vector<RimWellAllocationPlot*> wellAllocationPlots; proj->descendantsIncludingThisOfType(wellAllocationPlots); for (auto wap : wellAllocationPlots) { wap->loadDataAndUpdate(); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- std::vector<RimSaturationPressurePlot*> RicCreateSaturationPressurePlotsFeature::createPlots(RimEclipseResultCase* eclipseResultCase) { std::vector<RimSaturationPressurePlot*> plots; if (!eclipseResultCase) { RiaLogging::error( "RicCreateSaturationPressurePlotsFeature:: No case specified for creation of saturation pressure plots"); return plots; } RimProject* project = RiaApplication::instance()->project(); RimSaturationPressurePlotCollection* collection = project->mainPlotCollection()->saturationPressurePlotCollection(); if (eclipseResultCase && eclipseResultCase->ensureReservoirCaseIsOpen()) { eclipseResultCase->ensureDeckIsParsedForEquilData(); RigEclipseCaseData* eclipseCaseData = eclipseResultCase->eclipseCaseData(); bool requiredInputDataPresent = false; if (!eclipseCaseData->equilData().empty()) { if (eclipseCaseData && eclipseCaseData->results(RiaDefines::MATRIX_MODEL)) { RigCaseCellResultsData* resultData = eclipseCaseData->results(RiaDefines::MATRIX_MODEL); if (resultData->hasResultEntry(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "PRESSURE")) && resultData->hasResultEntry(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "PDEW")) && resultData->hasResultEntry(RigEclipseResultAddress(RiaDefines::DYNAMIC_NATIVE, "PBUB"))) { requiredInputDataPresent = true; } } } if (requiredInputDataPresent) { plots = collection->createSaturationPressurePlots(eclipseResultCase); for (auto plot : plots) { plot->loadDataAndUpdate(); plot->zoomAll(); plot->updateConnectedEditors(); } } } return plots; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimPerforationInterval::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) { if (changedField == &m_startOfHistory) { m_date.uiCapability()->setUiReadOnly(m_startOfHistory()); } RimProject* proj; this->firstAncestorOrThisOfTypeAsserted(proj); proj->reloadCompletionTypeResultsInAllViews(); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicNewStimPlanFractureTemplateFeature::onActionTriggered(bool isChecked) { RiaApplication* app = RiaApplication::instance(); QString defaultDir = app->lastUsedDialogDirectory("BINARY_GRID"); QString fileName = QFileDialog::getOpenFileName(nullptr, "Open StimPlan XML File", defaultDir, "StimPlan XML File (*.xml);;All files(*.*)"); if (fileName.isEmpty()) return; RimProject* project = RiaApplication::instance()->project(); CVF_ASSERT(project); RimOilField* oilfield = project->activeOilField(); if (oilfield == nullptr) return; RimFractureTemplateCollection* fracDefColl = oilfield->fractureDefinitionCollection(); if (fracDefColl) { RimStimPlanFractureTemplate* fractureDef = new RimStimPlanFractureTemplate(); fracDefColl->addFractureTemplate(fractureDef); QFileInfo stimplanfileFileInfo(fileName); QString name = stimplanfileFileInfo.baseName(); if (name.isEmpty()) { name = "StimPlan Fracture Template"; } fractureDef->setName(name); fractureDef->setFileName(fileName); fractureDef->loadDataAndUpdate(); fractureDef->setDefaultsBasedOnXMLfile(); fractureDef->setDefaultWellDiameterFromUnit(); fractureDef->updateFractureGrid(); fracDefColl->updateConnectedEditors(); std::vector<Rim3dView*> views; project->allVisibleViews(views); for (Rim3dView* view : views) { if (dynamic_cast<RimEclipseView*>(view)) { view->updateConnectedEditors(); } } Riu3DMainWindowTools::selectAsCurrentItem(fractureDef); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- std::set<std::string> RicSummaryCurveCreator::getAllSummaryCaseNames() { std::set<std::string> summaryCaseHashes; RimProject* proj = RiaApplication::instance()->project(); std::vector<RimSummaryCase*> cases = proj->allSummaryCases(); for (RimSummaryCase* rimCase : cases) { summaryCaseHashes.insert(rimCase->summaryHeaderFilename().toUtf8().constData()); } return summaryCaseHashes; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimUiTreeModelPdm::slotRefreshScriptTree(QString path) { RimProject* proj = RIApplication::instance()->project(); if (!proj || !proj->scriptCollection()) return; RimScriptCollection* changedSColl = proj->scriptCollection()->findScriptCollection(path); if (changedSColl) { changedSColl->readContentFromDisc(); this->rebuildUiSubTree(changedSColl); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void Rim3dWellLogCurve::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) { RimProject* proj; this->firstAncestorOrThisOfTypeAsserted(proj); if (changedField == &m_showCurve) { proj->reloadCompletionTypeResultsInAllViews(); } else { proj->scheduleCreateDisplayModelAndRedrawAllViews(); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicNewSummaryEnsembleCurveSetFeature::onActionTriggered(bool isChecked) { RimProject* project = RiaApplication::instance()->project(); CVF_ASSERT(project); RimSummaryPlot* plot = selectedSummaryPlot(); if (plot) { auto ensemble = project->summaryGroups().back(); RicNewSummaryEnsembleCurveSetFeature::createPlotForCurveSetAndUpdate(ensemble); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuSelectionChangedHandler::scheduleUpdateForAllVisibleViews() const { RimProject* proj = RiaApplication::instance()->project(); if (proj) { std::vector<Rim3dView*> visibleViews; proj->allVisibleViews(visibleViews); for (size_t i = 0; i < visibleViews.size(); i++) { visibleViews[i]->createHighlightAndGridBoxDisplayModelWithRedraw(); } } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimWellPathFracture::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) { RimFracture::defineUiOrdering(uiConfigName, uiOrdering); if (m_fractureTemplate()) { uiOrdering.add(nameField(), caf::PdmUiOrdering::LayoutOptions(true, 3, 1)); uiOrdering.add(&m_fractureTemplate, {true, 2, 1}); uiOrdering.add(&m_editFractureTemplate, {false, 1, 0}); } else { uiOrdering.add(nameField()); { RimProject* project = nullptr; this->firstAncestorOrThisOfTypeAsserted(project); if (project->allFractureTemplates().empty()) { uiOrdering.add(&m_createEllipseFractureTemplate); uiOrdering.add(&m_createStimPlanFractureTemplate, false); } else { uiOrdering.add(&m_fractureTemplate); } } } caf::PdmUiGroup* locationGroup = uiOrdering.addNewGroup("Location / Orientation"); locationGroup->add(&m_measuredDepth); locationGroup->add(&m_azimuth); locationGroup->add(&m_uiWellPathAzimuth); locationGroup->add(&m_uiWellFractureAzimuthDiff); locationGroup->add(&m_wellFractureAzimuthAngleWarning); locationGroup->add(&m_dip); locationGroup->add(&m_tilt); caf::PdmUiGroup* propertyGroup = uiOrdering.addNewGroup("Properties"); propertyGroup->add(&m_fractureUnit); propertyGroup->add(&m_stimPlanTimeIndexToPlot); propertyGroup->add(&m_perforationLength); propertyGroup->add(&m_perforationEfficiency); propertyGroup->add(&m_wellDiameter); caf::PdmUiGroup* fractureCenterGroup = uiOrdering.addNewGroup("Fracture Center Info"); fractureCenterGroup->add(&m_uiAnchorPosition); uiOrdering.skipRemainingFields(true); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RicSummaryCurveCreator::createNewPlot() { RimProject* proj = RiaApplication::instance()->project(); RimSummaryPlotCollection* summaryPlotColl = proj->mainPlotCollection()->summaryPlotCollection(); if (summaryPlotColl) { RimSummaryPlot* newSummaryPlot = nullptr; if (m_useAutoPlotTitleProxy()) { newSummaryPlot = summaryPlotColl->createSummaryPlotWithAutoTitle(); } else { QString candidatePlotName; if (m_previewPlot) { candidatePlotName = m_previewPlot->generatedPlotTitleFromAllCurves(); } { bool ok = false; candidatePlotName = QInputDialog::getText(nullptr, "New Summary Plot Name", "New Summary Plot Name", QLineEdit::Normal, candidatePlotName, &ok, RiuTools::defaultDialogFlags()); if (!ok) { return; } newSummaryPlot = summaryPlotColl->createNamedSummaryPlot(candidatePlotName); } } if (newSummaryPlot) { newSummaryPlot->loadDataAndUpdate(); summaryPlotColl->updateConnectedEditors(); m_targetPlot = newSummaryPlot; updateTargetPlot(); } } }