int main(int argc , char ** argv) {
const char * grid_file = argv[1];
const char * fault_blk_file = argv[2];
ecl_grid_type * ecl_grid = ecl_grid_alloc( grid_file );
ecl_kw_type * fault_blk_kw;
{
FILE * stream = util_fopen( fault_blk_file , "r");
fault_blk_kw = ecl_kw_fscanf_alloc_grdecl( stream , "FAULTBLK" , ecl_grid_get_global_size( ecl_grid ) , ECL_INT);
fclose( stream );
}
test_create( ecl_grid , fault_blk_kw );
ecl_grid_free( ecl_grid );
ecl_kw_free( fault_blk_kw );
exit(0);
}
void test_neighbours( const ecl_grid_type * grid) {
const int k = 0;
fault_block_layer_type * layer = fault_block_layer_alloc( grid , k );
geo_polygon_collection_type * polylines = geo_polygon_collection_alloc();
ecl_kw_type * ecl_kw = ecl_kw_alloc("FAULTBLK" , ecl_grid_get_global_size( grid ) , ECL_INT_TYPE );
ecl_kw_iset_int( ecl_kw , 0 , 1);
ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 3,3,k) , 2);
ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 4,3,k) , 3);
ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 5,3,k) , 4);
ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 4,2,k) , 5);
fault_block_layer_load_kw( layer , ecl_kw);
{
int_vector_type * neighbours = int_vector_alloc( 0,0);
{
fault_block_type * block = fault_block_layer_get_block( layer , 1 );
test_assert_int_equal( 0 , int_vector_size( neighbours ));
fault_block_list_neighbours( block , false , polylines , neighbours );
test_assert_int_equal( 0 , int_vector_size( neighbours ));
}
{
fault_block_type * block = fault_block_layer_get_block( layer , 2 );
fault_block_list_neighbours( block , false , polylines , neighbours );
test_assert_int_equal( 1 , int_vector_size( neighbours ));
test_assert_true( int_vector_contains( neighbours , 3 ));
}
int_vector_free( neighbours );
}
geo_polygon_collection_free( polylines );
fault_block_layer_free( layer );
ecl_kw_free( ecl_kw );
}
int main(int argc , char ** argv) {
const char * case_path = argv[1];
char * egrid_file = ecl_util_alloc_filename( NULL , case_path , ECL_EGRID_FILE , false , 0 );
char * rst_file = ecl_util_alloc_filename( NULL , case_path , ECL_RESTART_FILE , false , 0 );
char * init_file = ecl_util_alloc_filename( NULL , case_path , ECL_INIT_FILE , false , 0 );
ecl_grid_type * GRID = ecl_grid_alloc(egrid_file );
ecl_file_type * RST_file = ecl_file_open( rst_file , 0);
ecl_file_type * INIT_file = ecl_file_open( init_file , 0);
{
test_assert_true( ecl_grid_have_coarse_cells( GRID ) );
test_assert_int_equal( ecl_grid_get_num_coarse_groups( GRID ) , 3384);
}
{
const ecl_kw_type * swat0 = ecl_file_iget_named_kw( RST_file , "SWAT" , 0 );
const ecl_kw_type * porv = ecl_file_iget_named_kw( INIT_file , "PORV" , 0 );
test_assert_int_equal( ecl_kw_get_size( swat0 ) , ecl_grid_get_active_size( GRID ) );
test_assert_int_equal( ecl_kw_get_size( porv ) , ecl_grid_get_global_size( GRID ) );
}
{
int ic;
for (ic = 0; ic < ecl_grid_get_num_coarse_groups(GRID); ic++) {
ecl_coarse_cell_type * coarse_cell = ecl_grid_iget_coarse_group( GRID , ic );
test_coarse_cell( GRID , coarse_cell );
}
}
ecl_file_close( INIT_file );
ecl_file_close( RST_file );
ecl_grid_free( GRID );
exit(0);
}
int field_config_get_data_size_from_grid(const field_config_type * config) {
return config->keep_inactive_cells ? ecl_grid_get_global_size(config->grid) : ecl_grid_get_active_size(config->grid);
}
bool fault_block_layer_export( const fault_block_layer_type * layer , ecl_kw_type * faultblock_kw) {
if (ecl_type_is_int(ecl_kw_get_data_type( faultblock_kw )) && (ecl_kw_get_size( faultblock_kw ) == ecl_grid_get_global_size( layer->grid ))) {
int i,j;
for (j=0; j < ecl_grid_get_ny( layer->grid ); j++) {
for (i=0; i < ecl_grid_get_nx( layer->grid ); i++) {
int g = ecl_grid_get_global_index3( layer->grid , i, j , layer->k );
int cell_value = layer_iget_cell_value( layer->layer , i , j );
ecl_kw_iset_int( faultblock_kw , g , cell_value);
}
}
return true;
} else
return false;
}
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;
}
//--------------------------------------------------------------------------------------------------
/// 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;
}
void rms_export_roff_from_keyword(const char *filename, ecl_grid_type *ecl_grid,
ecl_kw_type **ecl_kw, int size) {
rms_file_type *rms_file;
rms_tagkey_type *data_key;
int nx, ny, nz, active_size;
int i, j, k;
int global_size;
int n;
ecl_grid_get_dims(ecl_grid, &nx, &ny, &nz, &active_size);
global_size = ecl_grid_get_global_size(ecl_grid);
rms_file = rms_file_alloc(filename, false);
rms_file_fopen_w(rms_file);
rms_file_init_fwrite(rms_file , "parameter");
rms_tag_fwrite_dimensions(nx , ny , nz , rms_file_get_FILE(rms_file));
for (n = 0; n < size; n++) {
float *src_data;
float *target_data;
src_data = (float *) ecl_kw_get_void_ptr(ecl_kw[n]);
target_data = util_calloc(global_size , sizeof * target_data );
for (k=0; k < nz; k++) {
for (j=0; j < ny; j++) {
for (i=0; i < nx; i++) {
int index1D;
int index3D;
double fill = RMS_INACTIVE_FLOAT;
/* TODO:
* This currently only supports FLOAT / REAL type.
*/
index1D = ecl_grid_get_active_index3(ecl_grid, i, j, k);
index3D = rms_util_global_index_from_eclipse_ijk(nx, ny, nz, i, j, k);
if (index1D >= 0)
target_data[index3D] = src_data[index1D];
else
memcpy(&target_data[index3D] , &fill, sizeof(float));
}
}
}
data_key = rms_tagkey_alloc_complete("data", global_size,
rms_util_convert_ecl_type(ecl_kw_get_data_type(ecl_kw[n])) , target_data, true);
rms_tag_fwrite_parameter(ecl_kw_get_header8(ecl_kw[n]), data_key,
rms_file_get_FILE(rms_file));
rms_tagkey_free(data_key);
util_safe_free(target_data);
}
rms_file_complete_fwrite(rms_file);
rms_file_fclose(rms_file);
rms_file_free(rms_file);
}
static double gravity_response(const ecl_grid_type * ecl_grid ,
const ecl_file_type * init_file ,
const ecl_file_type * restart_file1 ,
const ecl_file_type * restart_file2 ,
const grav_station_type * grav_station ,
int model_phases,
int file_phases) {
ecl_kw_type * rporv1_kw = NULL;
ecl_kw_type * rporv2_kw = NULL;
ecl_kw_type * oil_den1_kw = NULL;
ecl_kw_type * oil_den2_kw = NULL;
ecl_kw_type * gas_den1_kw = NULL;
ecl_kw_type * gas_den2_kw = NULL;
ecl_kw_type * wat_den1_kw = NULL;
ecl_kw_type * wat_den2_kw = NULL;
ecl_kw_type * sgas1_kw = NULL;
ecl_kw_type * sgas2_kw = NULL;
ecl_kw_type * swat1_kw = NULL;
ecl_kw_type * swat2_kw = NULL;
ecl_kw_type * aquifern_kw = NULL ;
double local_deltag = 0;
/* Extracting the pore volumes */
rporv1_kw = ecl_file_iget_named_kw( restart_file1 , "RPORV" , 0);
rporv2_kw = ecl_file_iget_named_kw( restart_file2 , "RPORV" , 0);
/** Extracting the densities */
{
// OIL_DEN
if( has_phase(model_phases , OIL) ) {
if (simulator == ECLIPSE100) {
oil_den1_kw = ecl_file_iget_named_kw(restart_file1, "OIL_DEN", 0);
oil_den2_kw = ecl_file_iget_named_kw(restart_file2, "OIL_DEN", 0);
} else { // ECLIPSE300
oil_den1_kw = ecl_file_iget_named_kw(restart_file1, "DENO", 0);
oil_den2_kw = ecl_file_iget_named_kw(restart_file2, "DENO", 0);
} ;
}
// GAS_DEN
if( has_phase( model_phases , GAS) ) {
if (simulator == ECLIPSE100) {
gas_den1_kw = ecl_file_iget_named_kw(restart_file1, "GAS_DEN", 0);
gas_den2_kw = ecl_file_iget_named_kw(restart_file2, "GAS_DEN", 0);
} else { // ECLIPSE300
gas_den1_kw = ecl_file_iget_named_kw(restart_file1, "DENG", 0);
gas_den2_kw = ecl_file_iget_named_kw(restart_file2, "DENG", 0);
} ;
}
// WAT_DEN
if( has_phase( model_phases , WATER) ) {
if (simulator == ECLIPSE100) {
wat_den1_kw = ecl_file_iget_named_kw(restart_file1, "WAT_DEN", 0);
wat_den2_kw = ecl_file_iget_named_kw(restart_file2, "WAT_DEN", 0);
} else { // ECLIPSE300
wat_den1_kw = ecl_file_iget_named_kw(restart_file1, "DENW", 0);
wat_den2_kw = ecl_file_iget_named_kw(restart_file2, "DENW", 0);
} ;
}
}
/* Extracting the saturations */
{
// SGAS
if( has_phase( file_phases , GAS )) {
sgas1_kw = ecl_file_iget_named_kw(restart_file1, "SGAS", 0);
sgas2_kw = ecl_file_iget_named_kw(restart_file2, "SGAS", 0);
}
// SWAT
if( has_phase( file_phases , WATER )) {
swat1_kw = ecl_file_iget_named_kw(restart_file1, "SWAT", 0);
swat2_kw = ecl_file_iget_named_kw(restart_file2, "SWAT", 0);
}
}
/* The numerical aquifer information */
if( ecl_file_has_kw( init_file , "AQUIFERN"))
aquifern_kw = ecl_file_iget_named_kw(init_file, "AQUIFERN", 0);
{
int nactive = ecl_grid_get_active_size( ecl_grid );
float * zero = util_calloc( nactive , sizeof * zero ); /* Fake vector of zeros used for densities / sturations when you do not have data. */
int * int_zero = util_calloc( nactive , sizeof * int_zero ); /* Fake vector of zeros used for AQUIFER when the init file does not supply data. */
/*
Observe that the fake vectors are only a coding simplification,
they should not be really used.
*/
{
int i;
for (i=0; i < nactive; i++) {
zero[i] = 0;
int_zero[i] = 0;
}
}
{
const float * sgas1_v = safe_get_float_ptr( sgas1_kw , NULL );
const float * swat1_v = safe_get_float_ptr( swat1_kw , NULL );
const float * oil_den1 = safe_get_float_ptr( oil_den1_kw , zero );
const float * gas_den1 = safe_get_float_ptr( gas_den1_kw , zero );
const float * wat_den1 = safe_get_float_ptr( wat_den1_kw , zero );
const float * sgas2_v = safe_get_float_ptr( sgas2_kw , NULL );
const float * swat2_v = safe_get_float_ptr( swat2_kw , NULL );
const float * oil_den2 = safe_get_float_ptr( oil_den2_kw , zero );
const float * gas_den2 = safe_get_float_ptr( gas_den2_kw , zero );
const float * wat_den2 = safe_get_float_ptr( wat_den2_kw , zero );
const float * rporv1 = ecl_kw_get_float_ptr(rporv1_kw);
const float * rporv2 = ecl_kw_get_float_ptr(rporv2_kw);
double utm_x = grav_station->utm_x;
double utm_y = grav_station->utm_y;
double tvd = grav_station->depth;
int * aquifern;
int global_index;
if (aquifern_kw != NULL)
aquifern = ecl_kw_get_int_ptr( aquifern_kw );
else
aquifern = int_zero;
for (global_index=0;global_index < ecl_grid_get_global_size( ecl_grid ); global_index++){
const int act_index = ecl_grid_get_active_index1( ecl_grid , global_index );
if (act_index >= 0) {
// Not numerical aquifer
if(aquifern[act_index] >= 0){
float swat1 = swat1_v[act_index];
float swat2 = swat2_v[act_index];
float sgas1 = 0;
float sgas2 = 0;
float soil1 = 0;
float soil2 = 0;
truncate_saturation( &swat1 );
truncate_saturation( &swat2 );
if (has_phase( model_phases , GAS)) {
if (has_phase( file_phases , GAS )) {
sgas1 = sgas1_v[act_index];
sgas2 = sgas2_v[act_index];
truncate_saturation( &sgas1 );
truncate_saturation( &sgas2 );
} else {
sgas1 = 1 - swat1;
sgas2 = 1 - swat2;
}
}
if (has_phase( model_phases , OIL )) {
soil1 = 1 - sgas1 - swat1;
soil2 = 1 - sgas2 - swat2;
truncate_saturation( &soil1 );
truncate_saturation( &soil2 );
}
/*
We have found all the info we need for one cell.
*/
{
double mas1 , mas2;
double xpos , ypos , zpos;
mas1 = rporv1[act_index]*(soil1 * oil_den1[act_index] + sgas1 * gas_den1[act_index] + swat1 * wat_den1[act_index] );
mas2 = rporv2[act_index]*(soil2 * oil_den2[act_index] + sgas2 * gas_den2[act_index] + swat2 * wat_den2[act_index] );
ecl_grid_get_xyz1(ecl_grid , global_index , &xpos , &ypos , &zpos);
{
double dist_x = xpos - utm_x;
double dist_y = ypos - utm_y;
double dist_d = zpos - tvd;
double dist_sq = dist_x*dist_x + dist_y*dist_y + dist_d*dist_d;
if(dist_sq == 0){
exit(1);
}
local_deltag += 6.67428E-3*(mas2 - mas1)*dist_d/pow(dist_sq, 1.5); // Gravity in units of \mu Gal = 10^{-8} m/s^2
}
}
}
}
}
}
free( zero );
free( int_zero );
}
return local_deltag;
}
