// Construct corner-point grid from EclipseGrid. void GridManager::initFromEclipseGrid(const Opm::EclipseGrid& inputGrid, const std::vector<double>& poreVolumes) { struct grdecl g; std::vector<int> actnum; std::vector<double> coord; std::vector<double> zcorn; std::vector<double> mapaxes; g.dims[0] = inputGrid.getNX(); g.dims[1] = inputGrid.getNY(); g.dims[2] = inputGrid.getNZ(); inputGrid.exportMAPAXES( mapaxes ); inputGrid.exportCOORD( coord ); inputGrid.exportZCORN( zcorn ); inputGrid.exportACTNUM( actnum ); g.coord = coord.data(); g.zcorn = zcorn.data(); g.actnum = actnum.data(); g.mapaxes = mapaxes.data(); if (!poreVolumes.empty() && (inputGrid.getMinpvMode() != MinpvMode::ModeEnum::Inactive)) { MinpvProcessor mp(g.dims[0], g.dims[1], g.dims[2]); const std::vector<double>& minpvv = inputGrid.getMinpvVector(); const size_t cartGridSize = g.dims[0] * g.dims[1] * g.dims[2]; std::vector<double> thickness(cartGridSize); for (size_t i = 0; i < cartGridSize; ++i) { thickness[i] = inputGrid.getCellThicknes(i); } // The legacy code only supports the opmfil option bool opmfil = true; //inputGrid.getMinpvMode() == MinpvMode::OpmFIL; const double z_tolerance = inputGrid.isPinchActive() ? inputGrid.getPinchThresholdThickness() : 0.0; mp.process(thickness, z_tolerance, poreVolumes, minpvv, actnum, opmfil, zcorn.data()); } const double z_tolerance = inputGrid.isPinchActive() ? inputGrid.getPinchThresholdThickness() : 0.0; ug_ = create_grid_cornerpoint(&g, z_tolerance); if (!ug_) { OPM_THROW(std::runtime_error, "Failed to construct grid."); } attach_zcorn_copy( ug_ , zcorn.data() ); }
void CpGridData::processEclipseFormat(const Opm::EclipseGrid& ecl_grid, bool periodic_extension, bool turn_normals, bool clip_z, const std::vector<double>& poreVolume) { std::vector<double> coordData; ecl_grid.exportCOORD(coordData); std::vector<int> actnumData; ecl_grid.exportACTNUM(actnumData); // Mutable because grdecl::zcorn is non-const. auto zcornData = getSanitizedZCORN(ecl_grid, actnumData); // Make input struct for processing code. grdecl g; g.dims[0] = ecl_grid.getNX(); g.dims[1] = ecl_grid.getNY(); g.dims[2] = ecl_grid.getNZ(); g.coord = &coordData[0]; g.zcorn = &zcornData[0]; g.actnum = actnumData.empty() ? nullptr : &actnumData[0]; // Possibly process MINPV if (!poreVolume.empty() && (ecl_grid.getMinpvMode() != Opm::MinpvMode::ModeEnum::Inactive)) { Opm::MinpvProcessor mp(g.dims[0], g.dims[1], g.dims[2]); // Currently the pinchProcessor is not used and only opmfil is supported //bool opmfil = ecl_grid.getMinpvMode() == Opm::MinpvMode::OpmFIL; bool opmfil = true; size_t cells_modified = mp.process(poreVolume, ecl_grid.getMinpvValue(), actnumData, opmfil, zcornData.data()); if (cells_modified > 0) { this->zcorn = zcornData; } } // this variable is only required because getCellZvals() needs // a coord_t instead of a plain integer pointer... coord_t logicalCartesianSize; for (int axisIdx = 0; axisIdx < 3; ++axisIdx) logicalCartesianSize[axisIdx] = g.dims[axisIdx]; // Handle zcorn clipping. The g variable points to the data in // the clipped_zcorn variable, i.e. clipped_zcorn must remain // in scope. std::vector<double> clipped_zcorn; if (clip_z) { double minz_top = 1e100; double maxz_bot = -1e100; for (int i = 0; i < g.dims[0]; ++i) { for (int j = 0; j < g.dims[1]; ++j) { coord_t logicalCartesianCoord; logicalCartesianCoord[0] = i; logicalCartesianCoord[1] = j; logicalCartesianCoord[2] = 0; std::array<double, 8> cellz_bot = getCellZvals(logicalCartesianCoord, logicalCartesianSize, &zcornData[0]); logicalCartesianCoord[2] = g.dims[2] - 1; std::array<double, 8> cellz_top = getCellZvals(logicalCartesianCoord, logicalCartesianSize, &zcornData[0]); for (int dd = 0; dd < 4; ++dd) { minz_top = std::min(cellz_top[dd+4], minz_top); maxz_bot = std::max(cellz_bot[dd], maxz_bot); } } } if (minz_top <= maxz_bot) { OPM_THROW(std::runtime_error, "Grid cannot be clipped to a shoe-box (in z): Would be empty afterwards."); } int num_zcorn = zcornData.size(); clipped_zcorn.resize(num_zcorn); for (int i = 0; i < num_zcorn; ++i) { clipped_zcorn[i] = std::max(maxz_bot, std::min(minz_top, g.zcorn[i])); } g.zcorn = &clipped_zcorn[0]; this->zcorn = clipped_zcorn; } // Get z_tolerance. const double z_tolerance = ecl_grid.isPinchActive() ? ecl_grid.getPinchThresholdThickness() : 0.0; if (periodic_extension) { // Extend grid periodically with one layer of cells in the (i, j) directions. std::vector<double> new_coord; std::vector<double> new_zcorn; std::vector<int> new_actnum; grdecl new_g; addOuterCellLayer(g, new_coord, new_zcorn, new_actnum, new_g); // Make the grid. processEclipseFormat(new_g, z_tolerance, true, turn_normals); } else { // Make the grid. processEclipseFormat(g, z_tolerance, false, turn_normals); } }