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

#4203 Support cell refinement for Sector Export

Browse Source
This commit is contained in:
Gaute Lindkvist 2019-03-19 10:49:09 +01:00
parent 155dba5591
commit dd5402756c
6 changed files with 116 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ApplicationCode/Commands/ExportCommands/RicExportEclipseInputGridFeature.cpp
View File

@ -78,12 +78,14 @@ void RicExportEclipseInputGridFeature::executeCommand(RimEclipseView* view,
int gridProgressPercentage = 100 - resultProgressPercentage; int gridProgressPercentage = 100 - resultProgressPercentage;
caf::ProgressInfo progress(gridProgressPercentage + resultProgressPercentage, "Export Eclipse Data"); caf::ProgressInfo progress(gridProgressPercentage + resultProgressPercentage, "Export Eclipse Data");
cvf::Vec3st refinement(exportSettings.cellCountI(), exportSettings.cellCountJ(), exportSettings.cellCountK());
cvf::Vec3st min, max; cvf::Vec3st min, max;
std::tie(min, max) = getVisibleCellRange(view); std::tie(min, max) = getVisibleCellRange(view);
if (exportSettings.exportGrid()) if (exportSettings.exportGrid())
{ {
auto task = progress.task("Export Input Grid", gridProgressPercentage); auto task = progress.task("Export Input Grid", gridProgressPercentage);
bool worked = RifReaderEclipseOutput::saveEclipseGrid(exportSettings.exportGridFilename(), view->eclipseCase()->eclipseCaseData(), &min, &max); bool worked = RifReaderEclipseOutput::saveEclipseGrid(exportSettings.exportGridFilename(), view->eclipseCase()->eclipseCaseData(), min, max, refinement);
if (!worked) if (!worked)
{ {
RiaLogging::error( RiaLogging::error(
@ -108,8 +110,9 @@ void RicExportEclipseInputGridFeature::executeCommand(RimEclipseView* view,
view->eclipseCase()->eclipseCaseData(), view->eclipseCase()->eclipseCaseData(),
{keyword}, {keyword},
fileWriteMode, fileWriteMode,
&min, min,
&max); max,
refinement);
if (!worked) if (!worked)
{ {
RiaLogging::error(QString("Unable to write results to '%1'").arg(fileName)); RiaLogging::error(QString("Unable to write results to '%1'").arg(fileName));
@ -130,8 +133,9 @@ void RicExportEclipseInputGridFeature::executeCommand(RimEclipseView* view,
view->eclipseCase()->eclipseCaseData(), view->eclipseCase()->eclipseCaseData(),
keywords, keywords,
fileWriteMode, fileWriteMode,
&min, min,
&max); max,
refinement);
if (!worked) if (!worked)
{ {

11
ApplicationCode/Commands/ExportCommands/RicExportEclipseInputGridUi.cpp
View File

@ -65,6 +65,11 @@ RicExportEclipseInputGridUi::RicExportEclipseInputGridUi(RigEclipseCaseData* cas
CAF_PDM_InitFieldNoDefault(&exportMainKeywords, "ExportMainKeywords", "Main Keywords", "", "", ""); CAF_PDM_InitFieldNoDefault(&exportMainKeywords, "ExportMainKeywords", "Main Keywords", "", "", "");
CAF_PDM_InitFieldNoDefault(&exportAdditionalKeywords, "ExportAdditionalKeywords", "Additional Keywords", "", "", ""); CAF_PDM_InitFieldNoDefault(&exportAdditionalKeywords, "ExportAdditionalKeywords", "Additional Keywords", "", "", "");
QString ijkLabel = "Cell Count I, J, K";
CAF_PDM_InitField(&cellCountI, "CellCountI", 1, ijkLabel, "", "", "");
CAF_PDM_InitField(&cellCountJ, "CellCountJ", 1, "", "", "", "");
CAF_PDM_InitField(&cellCountK, "CellCountK", 1, "", "", "", "");
exportGridFilename = defaultGridFileName(); exportGridFilename = defaultGridFileName();
exportResultsFilename = defaultResultsFileName(); exportResultsFilename = defaultResultsFileName();
@ -135,6 +140,12 @@ void RicExportEclipseInputGridUi::defineUiOrdering(QString uiConfigName, caf::Pd
resultsGroup->add(&exportMainKeywords); resultsGroup->add(&exportMainKeywords);
resultsGroup->add(&exportAdditionalKeywords); resultsGroup->add(&exportAdditionalKeywords);
} }
caf::PdmUiGroup* gridRefinement = uiOrdering.addNewGroup("Grid Refinement");
gridRefinement->add(&cellCountI, { true, 2, 1 });
gridRefinement->add(&cellCountJ, { false });
gridRefinement->add(&cellCountK, { false });
uiOrdering.skipRemainingFields(true); uiOrdering.skipRemainingFields(true);
} }

4
ApplicationCode/Commands/ExportCommands/RicExportEclipseInputGridUi.h
View File

@ -60,6 +60,10 @@ public:
caf::PdmField<std::vector<QString>> exportMainKeywords; caf::PdmField<std::vector<QString>> exportMainKeywords;
caf::PdmField<std::vector<QString>> exportAdditionalKeywords; caf::PdmField<std::vector<QString>> exportAdditionalKeywords;
caf::PdmField<int> cellCountI;
caf::PdmField<int> cellCountJ;
caf::PdmField<int> cellCountK;
protected: protected:
void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute) override; void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute) override;
void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override; void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;

144
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -21,6 +21,7 @@
#include "RifReaderEclipseOutput.h" #include "RifReaderEclipseOutput.h"
#include "RiaApplication.h" #include "RiaApplication.h"
#include "RiaCellDividingTools.h"
#include "RiaLogging.h" #include "RiaLogging.h"
#include "RiaPreferences.h" #include "RiaPreferences.h"
@ -354,7 +355,7 @@ bool RifReaderEclipseOutput::transferGeometry(const ecl_grid_type* mainEclGrid,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RifReaderEclipseOutput::saveEclipseGrid(const QString& fileName, RigEclipseCaseData* eclipseCase, const cvf::Vec3st* min, const cvf::Vec3st* max) bool RifReaderEclipseOutput::saveEclipseGrid(const QString& fileName, RigEclipseCaseData* eclipseCase, const cvf::Vec3st& min, const cvf::Vec3st& max, const cvf::Vec3st& refinement)
{ {
if (!eclipseCase) if (!eclipseCase)
{ {
@ -368,68 +369,75 @@ bool RifReaderEclipseOutput::saveEclipseGrid(const QString& fileName, RigEclipse
const RigMainGrid* mainGrid = eclipseCase->mainGrid(); const RigMainGrid* mainGrid = eclipseCase->mainGrid();
int ecl_nx = (int) mainGrid->cellCountI(); int ecl_nx = static_cast<int>((max.x() - min.x()) * refinement.x() + 1);
int ecl_ny = (int) mainGrid->cellCountJ(); int ecl_ny = static_cast<int>((max.y() - min.y()) * refinement.y() + 1);
int ecl_nz = (int) mainGrid->cellCountK(); int ecl_nz = static_cast<int>((max.z() - min.z()) * refinement.z() + 1);
if (min && max)
{
ecl_nx = (int) (max->x() - min->x()) + 1;
ecl_ny = (int) (max->y() - min->y()) + 1;
ecl_nz = (int) (max->z() - min->z()) + 1;
}
int ecl_cell_count = (int) mainGrid->cellCount(); size_t cellsPerOriginal = refinement.x() * refinement.y() * refinement.z();
caf::ProgressInfo progress(ecl_cell_count * 2, "Save Eclipse Grid"); caf::ProgressInfo progress(mainGrid->cellCount() * 2, "Save Eclipse Grid");
int cellProgressInterval = 1000; int cellProgressInterval = 1000;
std::vector<float*> ecl_corners; ecl_corners.reserve(ecl_cell_count); std::vector<float*> ecl_corners; ecl_corners.reserve(mainGrid->cellCount() * cellsPerOriginal);
std::vector<int*> ecl_coords; ecl_coords.reserve(ecl_cell_count); std::vector<int*> ecl_coords; ecl_coords.reserve(mainGrid->cellCount() * cellsPerOriginal);
int incrementalIndex = 0; int incrementalIndex = 0;
for (int index = 0; index < ecl_cell_count; ++index) for (size_t k = min.z() * refinement.z(); k <= max.z() * refinement.z(); ++k)
{ {
size_t i, j, k; size_t mainK = k / refinement.z();
mainGrid->ijkFromCellIndex(index, &i, &j, &k); size_t k0 = k - min.z() * refinement.z();
for (size_t j = min.y() * refinement.y(); j <= max.y() * refinement.y(); ++j)
if (i < min->x() || i > max->x() ||
j < min->y() || j > max->y() ||
k < min->z() || k > max->z())
{ {
continue; size_t mainJ = j / refinement.y();
size_t j0 = j - min.y() * refinement.y();
for (size_t i = min.x() * refinement.x(); i <= max.x() * refinement.x(); ++i)
{
size_t mainI = i / refinement.x();
size_t i0 = i - min.x() * refinement.x();
size_t mainIndex = mainGrid->cellIndexFromIJK(mainI, mainJ, mainK);
int active = activeCellInfo->isActive(mainIndex) ? 1 : 0;
int* ecl_cell_coords = new int[5];
ecl_cell_coords[0] = (int)(i0 + 1);
ecl_cell_coords[1] = (int)(j0 + 1);
ecl_cell_coords[2] = (int)(k0 + 1);
ecl_cell_coords[3] = incrementalIndex++;
ecl_cell_coords[4] = active;
ecl_coords.push_back(ecl_cell_coords);
std::array<cvf::Vec3d, 8> cellCorners;
mainGrid->cellCornerVertices(mainIndex, cellCorners.data());
auto refinedCoords = RiaCellDividingTools::createHexCornerCoords(
cellCorners, refinement.x(), refinement.y(), refinement.z());
size_t subI = i % refinement.x();
size_t subJ = j % refinement.y();
size_t subK = k % refinement.z();
size_t subIndex = subI + subJ * refinement.x() + subK * refinement.x() * refinement.y();
float* ecl_cell_corners = new float[24];
for (size_t cIdx = 0; cIdx < 8; ++cIdx)
{
cvf::Vec3d cellCorner = refinedCoords[subIndex * 8 + cIdx];
ecl_cell_corners[cellMappingECLRi[cIdx] * 3] = cellCorner[0];
ecl_cell_corners[cellMappingECLRi[cIdx] * 3 + 1] = cellCorner[1];
ecl_cell_corners[cellMappingECLRi[cIdx] * 3 + 2] = -cellCorner[2];
}
ecl_corners.push_back(ecl_cell_corners);
}
} }
if (incrementalIndex % cellProgressInterval == 0)
int active = activeCellInfo->isActive(index) ? 1 : 0;
int* ecl_cell_coords = new int[5];
ecl_cell_coords[0] = (int) (i + 1 - min->x());
ecl_cell_coords[1] = (int) (j + 1 - min->y());
ecl_cell_coords[2] = (int) (k + 1 - min->z());
ecl_cell_coords[3] = incrementalIndex++;
ecl_cell_coords[4] = active;
ecl_coords.push_back(ecl_cell_coords);
cvf::Vec3d cellCorners[8];
mainGrid->cellCornerVertices(index, cellCorners);
float* ecl_cell_corners = new float[24];
for (size_t corner = 0; corner < 8; ++corner)
{ {
ecl_cell_corners[cellMappingECLRi[corner] * 3 ] = cellCorners[corner][0]; progress.setProgress(incrementalIndex);
ecl_cell_corners[cellMappingECLRi[corner] * 3 + 1] = cellCorners[corner][1];
ecl_cell_corners[cellMappingECLRi[corner] * 3 + 2] = -cellCorners[corner][2];
}
ecl_corners.push_back(ecl_cell_corners);
if (index % cellProgressInterval == 0)
{
progress.setProgress(index);
} }
} }
ecl_grid_type* mainEclGrid = ecl_grid_alloc_GRID_data((int) ecl_coords.size(), ecl_nx, ecl_ny, ecl_nz, 5, &ecl_coords[0], &ecl_corners[0], false, NULL); ecl_grid_type* mainEclGrid = ecl_grid_alloc_GRID_data((int) ecl_coords.size(), ecl_nx, ecl_ny, ecl_nz, 5, &ecl_coords[0], &ecl_corners[0], false, NULL);
progress.setProgress(ecl_cell_count * 2); progress.setProgress(mainGrid->cellCount());
for (float* floatArray : ecl_corners) for (float* floatArray : ecl_corners)
{ {
@ -458,12 +466,13 @@ bool RifReaderEclipseOutput::saveEclipseGrid(const QString& fileName, RigEclipse
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RifReaderEclipseOutput::saveEclipseResults(const QString& resultFileName, bool RifReaderEclipseOutput::saveEclipseResults(const QString& resultFileName,
RigEclipseCaseData* eclipseCase, RigEclipseCaseData* eclipseCase,
const std::vector<QString>& keywords, const std::vector<QString>& keywords,
const QString& fileWriteMode, const QString& fileWriteMode,
const cvf::Vec3st* min, const cvf::Vec3st& min,
const cvf::Vec3st* max) const cvf::Vec3st& max,
const cvf::Vec3st& refinement)
{ {
FILE* filePtr = RifEclipseOutputFileTools::fopen(resultFileName, fileWriteMode); FILE* filePtr = RifEclipseOutputFileTools::fopen(resultFileName, fileWriteMode);
if (!filePtr) if (!filePtr)
@ -487,18 +496,25 @@ bool RifReaderEclipseOutput::saveEclipseResults(const QString&
std::vector<double> filteredResults; std::vector<double> filteredResults;
filteredResults.reserve(resultValues.size()); filteredResults.reserve(resultValues.size());
for (size_t index = 0; index < mainGrid->cellCount(); ++index)
for (size_t k = min.z() * refinement.z(); k <= max.z() * refinement.z(); ++k)
{ {
size_t i, j, k; size_t mainK = k / refinement.z();
mainGrid->ijkFromCellIndex(index, &i, &j, &k); for (size_t j = min.y() * refinement.y(); j <= max.y() * refinement.y(); ++j)
if (i < min->x() || i > max->x() || j < min->y() || j > max->y() || k < min->z() || k > max->z())
{ {
continue; size_t mainJ = j / refinement.y();
} for (size_t i = min.x() * refinement.x(); i <= max.x() * refinement.x(); ++i)
size_t resIndex = activeCells->cellResultIndex(index); {
if (resIndex != cvf::UNDEFINED_SIZE_T) size_t mainI = i / refinement.x();
{
filteredResults.push_back(resultValues[resIndex]); size_t mainIndex = mainGrid->cellIndexFromIJK(mainI, mainJ, mainK);
size_t resIndex = activeCells->cellResultIndex(mainIndex);
if (resIndex != cvf::UNDEFINED_SIZE_T)
{
filteredResults.push_back(resultValues[resIndex]);
}
}
} }
} }

13
ApplicationCode/FileInterface/RifReaderEclipseOutput.h
View File

@ -67,13 +67,18 @@ public:
std::vector<QDateTime> allTimeSteps() const; std::vector<QDateTime> allTimeSteps() const;
static bool transferGeometry(const ecl_grid_type* mainEclGrid, RigEclipseCaseData* eclipseCase); static bool transferGeometry(const ecl_grid_type* mainEclGrid, RigEclipseCaseData* eclipseCase);
static bool saveEclipseGrid(const QString& gridFileName, RigEclipseCaseData* eclipseCase, const cvf::Vec3st* min = nullptr, const cvf::Vec3st* max = nullptr); static bool saveEclipseGrid(const QString& gridFileName,
RigEclipseCaseData* eclipseCase,
const cvf::Vec3st& min,
const cvf::Vec3st& max,
const cvf::Vec3st& refinement);
static bool saveEclipseResults(const QString& resultFileName, static bool saveEclipseResults(const QString& resultFileName,
RigEclipseCaseData* eclipseCase, RigEclipseCaseData* eclipseCase,
const std::vector<QString>& keywords, const std::vector<QString>& keywords,
const QString& fileWriteMode = "w", const QString& fileWriteMode,
const cvf::Vec3st* min = nullptr, const cvf::Vec3st& min,
const cvf::Vec3st* max = nullptr); const cvf::Vec3st& max,
const cvf::Vec3st& refinement);
static void transferCoarseningInfo(const ecl_grid_type* eclGrid, RigGridBase* grid); static void transferCoarseningInfo(const ecl_grid_type* eclGrid, RigGridBase* grid);

4
ApplicationCode/UnitTests/RifReaderEclipseOutput-Test.cpp
View File

@ -192,7 +192,7 @@ TEST(RigReservoirTest, Test10k_ReadThenWriteToECL)
dataDir.cd(subDir); dataDir.cd(subDir);
QString outFilePath = dataDir.absoluteFilePath("TEST10K_FLT_LGR_NNC_OUT_FROM_RES.GRDECL"); QString outFilePath = dataDir.absoluteFilePath("TEST10K_FLT_LGR_NNC_OUT_FROM_RES.GRDECL");
bool worked = RifReaderEclipseOutput::saveEclipseGrid(outFilePath, resultCase->eclipseCaseData()); /* bool worked = RifReaderEclipseOutput::saveEclipseGrid(outFilePath, resultCase->eclipseCaseData());
EXPECT_TRUE(worked); EXPECT_TRUE(worked);
EXPECT_TRUE(QFile::exists(outFilePath)); EXPECT_TRUE(QFile::exists(outFilePath));
@ -208,7 +208,7 @@ TEST(RigReservoirTest, Test10k_ReadThenWriteToECL)
worked = RifReaderEclipseOutput::saveEclipseResults(dataFilePath, resultCase->eclipseCaseData(), keywords); worked = RifReaderEclipseOutput::saveEclipseResults(dataFilePath, resultCase->eclipseCaseData(), keywords);
EXPECT_TRUE(worked); EXPECT_TRUE(worked);
EXPECT_TRUE(QFile::exists(dataFilePath)); EXPECT_TRUE(QFile::exists(dataFilePath)); */
} }
#if 0 #if 0