//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- bool RimResultReservoir::openEclipseGridFile() { caf::ProgressInfo progInfo(20, "Reading Eclipse Grid File"); progInfo.setProgressDescription("Open Grid File"); progInfo.setNextProgressIncrement(19); // Early exit if reservoir data is created if (m_rigReservoir.notNull()) return true; cvf::ref<RifReaderInterface> readerInterface; if (caseName().contains("Result Mock Debug Model")) { readerInterface = this->createMockModel(this->caseName()); } else { QString fullCaseName = caseName + ".EGRID"; QDir dir(caseDirectory.v()); if (!dir.exists(fullCaseName)) { fullCaseName = caseName + ".GRID"; if (!dir.exists(fullCaseName)) { return false; } } QString fname = dir.absoluteFilePath(fullCaseName); RigReservoir* reservoir = new RigReservoir; readerInterface = new RifReaderEclipseOutput; if (!readerInterface->open(fname, reservoir)) { delete reservoir; return false; } m_rigReservoir = reservoir; } progInfo.setProgress(19); CVF_ASSERT(m_rigReservoir.notNull()); CVF_ASSERT(readerInterface.notNull()); m_rigReservoir->mainGrid()->results()->setReaderInterface(readerInterface.p()); progInfo.setProgressDescription("Computing Faults"); m_rigReservoir->computeFaults(); progInfo.setProgressDescription("Computing Cache"); m_rigReservoir->mainGrid()->computeCachedData(); return true; }
//-------------------------------------------------------------------------------------------------- /// Open file and read geometry into given reservoir object //-------------------------------------------------------------------------------------------------- bool RifReaderEclipseOutput::open(const QString& fileName, RigReservoir* reservoir) { CVF_ASSERT(reservoir); caf::ProgressInfo progInfo(100, ""); progInfo.setProgressDescription("Reading Grid"); // Make sure everything's closed close(); // Get set of files QStringList fileSet; if (!RifEclipseOutputFileTools::fileSet(fileName, &fileSet)) return false; progInfo.incrementProgress(); progInfo.setNextProgressIncrement(20); // Keep the set of files of interest m_fileSet = fileSet; // Read geometry ecl_grid_type * mainEclGrid = ecl_grid_alloc( fileName.toAscii().data() ); progInfo.incrementProgress(); progInfo.setNextProgressIncrement(10); progInfo.setProgressDescription("Transferring grid geometry"); if (!transferGeometry(mainEclGrid, reservoir)) return false; progInfo.incrementProgress(); progInfo.setProgressDescription("Releasing reader memory"); ecl_grid_free( mainEclGrid ); progInfo.incrementProgress(); progInfo.setProgressDescription("Reading Result index"); progInfo.setNextProgressIncrement(60); m_mainGrid = reservoir->mainGrid(); reservoir->mainGrid()->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(this); reservoir->mainGrid()->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(this); // Build results meta data if (!buildMetaData(reservoir)) return false; progInfo.incrementProgress(); progInfo.setNextProgressIncrement(8); progInfo.setProgressDescription("Reading Well information"); readWellCells(reservoir); return true; }
//-------------------------------------------------------------------------------------------------- /// Loads input property data from the gridFile and additional files /// Creates new InputProperties if necessary, and flags the unused ones as obsolete //-------------------------------------------------------------------------------------------------- void RimEclipseInputCase::loadAndSyncronizeInputProperties() { // Make sure we actually have reservoir data CVF_ASSERT(this->reservoirData()); CVF_ASSERT(this->reservoirData()->mainGrid()->gridPointDimensions() != cvf::Vec3st(0,0,0)); // Then read the properties from all the files referenced by the InputReservoir std::vector<QString> filenames = m_additionalFileNames; filenames.push_back(m_gridFileName); size_t inputPropCount = this->m_inputPropertyCollection()->inputProperties.size(); caf::ProgressInfo progInfo(static_cast<int>(filenames.size() * inputPropCount), "Reading Input properties" ); int progress = 0; for_all(filenames, i) { progress = static_cast<int>(i*inputPropCount); // Find all the keywords present on the file progInfo.setProgressDescription(filenames[i]); QFileInfo fileNameInfo(filenames[i]); bool isExistingFile = fileNameInfo.exists(); std::set<QString> fileKeywordSet; if (isExistingFile) { std::vector< RifKeywordAndFilePos > fileKeywords; RifEclipseInputFileTools::findKeywordsOnFile(filenames[i], &fileKeywords); for_all(fileKeywords, fkIt) fileKeywordSet.insert(fileKeywords[fkIt].keyword); } // Find the input property objects referring to the file std::vector<RimEclipseInputProperty*> ipsUsingThisFile = this->m_inputPropertyCollection()->findInputProperties(filenames[i]); // Read property data for each inputProperty for_all(ipsUsingThisFile, ipIdx) { if (!isExistingFile) { ipsUsingThisFile[ipIdx]->resolvedState = RimEclipseInputProperty::FILE_MISSING; } else { QString kw = ipsUsingThisFile[ipIdx]->eclipseKeyword(); ipsUsingThisFile[ipIdx]->resolvedState = RimEclipseInputProperty::KEYWORD_NOT_IN_FILE; if (fileKeywordSet.count(kw)) { if (RifEclipseInputFileTools::readProperty(filenames[i], this->reservoirData(), kw, ipsUsingThisFile[ipIdx]->resultName )) { ipsUsingThisFile[ipIdx]->resolvedState = RimEclipseInputProperty::RESOLVED; } } fileKeywordSet.erase(kw); } progInfo.setProgress(static_cast<int>(progress + ipIdx) ); } progInfo.setProgress(static_cast<int>(progress + inputPropCount)); // Check if there are more known property keywords left on file. If it is, read them and create inputProperty objects for (const QString fileKeyword : fileKeywordSet) { { QString resultName = this->reservoirData()->results(RifReaderInterface::MATRIX_RESULTS)->makeResultNameUnique(fileKeyword); if (RifEclipseInputFileTools::readProperty(filenames[i], this->reservoirData(), fileKeyword, resultName)) { RimEclipseInputProperty* inputProperty = new RimEclipseInputProperty; inputProperty->resultName = resultName; inputProperty->eclipseKeyword = fileKeyword; inputProperty->fileName = filenames[i]; inputProperty->resolvedState = RimEclipseInputProperty::RESOLVED; m_inputPropertyCollection->inputProperties.push_back(inputProperty); } } progInfo.setProgress(static_cast<int>(progress + inputPropCount)); } }
bool transferGridCellData(RigMainGrid* mainGrid, RigGridBase* localGrid, const ecl_grid_type* localEclGrid, size_t matrixActiveStartIndex, size_t fractureActiveStartIndex) { int cellCount = ecl_grid_get_global_size(localEclGrid); size_t cellStartIndex = mainGrid->cells().size(); size_t nodeStartIndex = mainGrid->nodes().size(); RigCell defaultCell; defaultCell.setHostGrid(localGrid); mainGrid->cells().resize(cellStartIndex + cellCount, defaultCell); mainGrid->nodes().resize(nodeStartIndex + cellCount*8, cvf::Vec3d(0,0,0)); int progTicks = 100; double cellsPrProgressTick = cellCount/(float)progTicks; caf::ProgressInfo progInfo(progTicks, ""); size_t computedCellCount = 0; // Loop over cells and fill them with data #pragma omp parallel for for (int gIdx = 0; gIdx < cellCount; ++gIdx) { RigCell& cell = mainGrid->cells()[cellStartIndex + gIdx]; bool invalid = ecl_grid_cell_invalid1(localEclGrid, gIdx); cell.setInvalid(invalid); cell.setCellIndex(gIdx); // Active cell index int matrixActiveIndex = ecl_grid_get_active_index1(localEclGrid, gIdx); if (matrixActiveIndex != -1) { cell.setActiveIndexInMatrixModel(matrixActiveStartIndex + matrixActiveIndex); } else { cell.setActiveIndexInMatrixModel(cvf::UNDEFINED_SIZE_T); } int fractureActiveIndex = ecl_grid_get_active_fracture_index1(localEclGrid, gIdx); if (fractureActiveIndex != -1) { cell.setActiveIndexInFractureModel(fractureActiveStartIndex + fractureActiveIndex); } else { cell.setActiveIndexInFractureModel(cvf::UNDEFINED_SIZE_T); } // Parent cell index int parentCellIndex = ecl_grid_get_parent_cell1(localEclGrid, gIdx); if (parentCellIndex == -1) { cell.setParentCellIndex(cvf::UNDEFINED_SIZE_T); } else { cell.setParentCellIndex(parentCellIndex); } // Coarse cell info ecl_coarse_cell_type * coarseCellData = ecl_grid_get_cell_coarse_group1( localEclGrid , gIdx); cell.setInCoarseCell(coarseCellData != NULL); // Corner coordinates int cIdx; for (cIdx = 0; cIdx < 8; ++cIdx) { double * point = mainGrid->nodes()[nodeStartIndex + gIdx * 8 + cellMappingECLRi[cIdx]].ptr(); ecl_grid_get_corner_xyz1(localEclGrid, gIdx, cIdx, &(point[0]), &(point[1]), &(point[2])); point[2] = -point[2]; cell.cornerIndices()[cIdx] = nodeStartIndex + gIdx*8 + cIdx; } // Sub grid in cell const ecl_grid_type* subGrid = ecl_grid_get_cell_lgr1(localEclGrid, gIdx); if (subGrid != NULL) { int subGridFileIndex = ecl_grid_get_grid_nr(subGrid); CVF_ASSERT(subGridFileIndex > 0); cell.setSubGrid(static_cast<RigLocalGrid*>(mainGrid->gridByIndex(subGridFileIndex))); } // Mark inactive long pyramid looking cells as invalid if (!invalid && (cell.isInCoarseCell() || (!cell.isActiveInMatrixModel() && !cell.isActiveInFractureModel()) ) ) { cell.setInvalid(cell.isLongPyramidCell()); } #pragma omp atomic computedCellCount++; progInfo.setProgress((int)(computedCellCount/cellsPrProgressTick)); } return true; }
//-------------------------------------------------------------------------------------------------- /// Build meta data - get states and results info //-------------------------------------------------------------------------------------------------- bool RifReaderEclipseOutput::buildMetaData(RigReservoir* reservoir) { CVF_ASSERT(reservoir); CVF_ASSERT(m_fileSet.size() > 0); caf::ProgressInfo progInfo(m_fileSet.size() + 3,""); progInfo.setNextProgressIncrement(m_fileSet.size()); // Create access object for dynamic results m_dynamicResultsAccess = dynamicResultsAccess(m_fileSet); if (m_dynamicResultsAccess.isNull()) { return false; } progInfo.incrementProgress(); RigReservoirCellResults* matrixModelResults = reservoir->mainGrid()->results(RifReaderInterface::MATRIX_RESULTS); RigReservoirCellResults* fractureModelResults = reservoir->mainGrid()->results(RifReaderInterface::FRACTURE_RESULTS); if (m_dynamicResultsAccess.notNull()) { // Get time steps m_timeSteps = m_dynamicResultsAccess->timeSteps(); QStringList resultNames; std::vector<size_t> resultNamesDataItemCounts; m_dynamicResultsAccess->resultNames(&resultNames, &resultNamesDataItemCounts); { QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::MATRIX_RESULTS, m_dynamicResultsAccess->timeStepCount()); for (int i = 0; i < matrixResultNames.size(); ++i) { size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, matrixResultNames[i]); matrixModelResults->setTimeStepDates(resIndex, m_timeSteps); } } { QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::FRACTURE_RESULTS, m_dynamicResultsAccess->timeStepCount()); for (int i = 0; i < fractureResultNames.size(); ++i) { size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, fractureResultNames[i]); fractureModelResults->setTimeStepDates(resIndex, m_timeSteps); } } } progInfo.incrementProgress(); QString initFileName = RifEclipseOutputFileTools::fileNameByType(m_fileSet, ECL_INIT_FILE); if (initFileName.size() > 0) { ecl_file_type* ecl_file = ecl_file_open(initFileName.toAscii().data()); if (!ecl_file) return false; progInfo.incrementProgress(); QStringList resultNames; std::vector<size_t> resultNamesDataItemCounts; RifEclipseOutputFileTools::findKeywordsAndDataItemCounts(ecl_file, &resultNames, &resultNamesDataItemCounts); { QStringList matrixResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::MATRIX_RESULTS, 1); QList<QDateTime> staticDate; if (m_timeSteps.size() > 0) { staticDate.push_back(m_timeSteps.front()); } for (int i = 0; i < matrixResultNames.size(); ++i) { size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, matrixResultNames[i]); matrixModelResults->setTimeStepDates(resIndex, staticDate); } } { QStringList fractureResultNames = validKeywordsForPorosityModel(resultNames, resultNamesDataItemCounts, RifReaderInterface::FRACTURE_RESULTS, 1); QList<QDateTime> staticDate; if (m_timeSteps.size() > 0) { staticDate.push_back(m_timeSteps.front()); } for (int i = 0; i < fractureResultNames.size(); ++i) { size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, fractureResultNames[i]); fractureModelResults->setTimeStepDates(resIndex, staticDate); } } m_ecl_file = ecl_file; } return true; }
//-------------------------------------------------------------------------------------------------- /// Read geometry from file given by name into given reservoir object //-------------------------------------------------------------------------------------------------- bool RifReaderEclipseOutput::transferGeometry(const ecl_grid_type* mainEclGrid, RigReservoir* reservoir) { CVF_ASSERT(reservoir); if (!mainEclGrid) { // Some error return false; } RigMainGrid* mainGrid = reservoir->mainGrid(); { cvf::Vec3st gridPointDim(0,0,0); gridPointDim.x() = ecl_grid_get_nx(mainEclGrid) + 1; gridPointDim.y() = ecl_grid_get_ny(mainEclGrid) + 1; gridPointDim.z() = ecl_grid_get_nz(mainEclGrid) + 1; mainGrid->setGridPointDimensions(gridPointDim); } // Get and set grid and lgr metadata size_t totalCellCount = static_cast<size_t>(ecl_grid_get_global_size(mainEclGrid)); int numLGRs = ecl_grid_get_num_lgr(mainEclGrid); int lgrIdx; for (lgrIdx = 0; lgrIdx < numLGRs; ++lgrIdx) { ecl_grid_type* localEclGrid = ecl_grid_iget_lgr(mainEclGrid, lgrIdx); std::string lgrName = ecl_grid_get_name(localEclGrid); cvf::Vec3st gridPointDim(0,0,0); gridPointDim.x() = ecl_grid_get_nx(localEclGrid) + 1; gridPointDim.y() = ecl_grid_get_ny(localEclGrid) + 1; gridPointDim.z() = ecl_grid_get_nz(localEclGrid) + 1; RigLocalGrid* localGrid = new RigLocalGrid(mainGrid); mainGrid->addLocalGrid(localGrid); localGrid->setIndexToStartOfCells(totalCellCount); localGrid->setGridName(lgrName); localGrid->setGridPointDimensions(gridPointDim); totalCellCount += ecl_grid_get_global_size(localEclGrid); } // Reserve room for the cells and nodes and fill them with data mainGrid->cells().reserve(totalCellCount); mainGrid->nodes().reserve(8*totalCellCount); caf::ProgressInfo progInfo(3 + numLGRs, ""); progInfo.setProgressDescription("Main Grid"); progInfo.setNextProgressIncrement(3); transferGridCellData(mainGrid, mainGrid, mainEclGrid, 0, 0); progInfo.setProgress(3); size_t globalMatrixActiveSize = ecl_grid_get_nactive(mainEclGrid); size_t globalFractureActiveSize = ecl_grid_get_nactive_fracture(mainEclGrid); mainGrid->setMatrixModelActiveCellCount(globalMatrixActiveSize); mainGrid->setFractureModelActiveCellCount(globalFractureActiveSize); for (lgrIdx = 0; lgrIdx < numLGRs; ++lgrIdx) { progInfo.setProgressDescription("LGR number " + QString::number(lgrIdx+1)); ecl_grid_type* localEclGrid = ecl_grid_iget_lgr(mainEclGrid, lgrIdx); RigLocalGrid* localGrid = static_cast<RigLocalGrid*>(mainGrid->gridByIndex(lgrIdx+1)); transferGridCellData(mainGrid, localGrid, localEclGrid, globalMatrixActiveSize, globalFractureActiveSize); int activeCellCount = ecl_grid_get_nactive(localEclGrid); localGrid->setMatrixModelActiveCellCount(activeCellCount); globalMatrixActiveSize += activeCellCount; activeCellCount = ecl_grid_get_nactive_fracture(localEclGrid); localGrid->setFractureModelActiveCellCount(activeCellCount); globalFractureActiveSize += activeCellCount; progInfo.setProgress(3 + lgrIdx); } mainGrid->setGlobalMatrixModelActiveCellCount(globalMatrixActiveSize); mainGrid->setGlobalFractureModelActiveCellCount(globalFractureActiveSize); return true; }
bool RemoteGetRecordingStatus( vector<TunerStatus> *tunerList, bool list_inactive) { bool isRecording = false; vector<uint> cardlist = CardUtil::GetCardList(); if (tunerList) tunerList->clear(); for (uint i = 0; i < cardlist.size(); i++) { QString status = ""; uint cardid = cardlist[i]; int state = kState_ChangingState; QString channelName = ""; QString title = ""; QString subtitle = ""; QDateTime dtStart = QDateTime(); QDateTime dtEnd = QDateTime(); QStringList strlist; QString cmd = QString("QUERY_REMOTEENCODER %1").arg(cardid); while (state == kState_ChangingState) { strlist = QStringList(cmd); strlist << "GET_STATE"; gCoreContext->SendReceiveStringList(strlist); if (strlist.empty()) break; state = strlist[0].toInt(); if (kState_ChangingState == state) usleep(5000); } if (kState_RecordingOnly == state || kState_WatchingRecording == state) { isRecording |= true; if (!tunerList) break; strlist = QStringList(QString("QUERY_RECORDER %1").arg(cardid)); strlist << "GET_RECORDING"; gCoreContext->SendReceiveStringList(strlist); ProgramInfo progInfo(strlist); title = progInfo.GetTitle(); subtitle = progInfo.GetSubtitle(); channelName = progInfo.GetChannelName(); dtStart = progInfo.GetScheduledStartTime(); dtEnd = progInfo.GetScheduledEndTime(); } else if (!list_inactive) continue; if (tunerList) { TunerStatus tuner; tuner.id = cardid; tuner.isRecording = ((kState_RecordingOnly == state) || (kState_WatchingRecording == state)); tuner.channame = channelName; tuner.title = (kState_ChangingState == state) ? QObject::tr("Error querying recorder state") : title; tuner.subtitle = subtitle; tuner.startTime = dtStart; tuner.endTime = dtEnd; tunerList->push_back(tuner); } } return isRecording; }