void test_tranLL( const ecl_grid_type * grid , const ecl_file_type * init_file , int lgr_nr1 , int lgr_nr2,
int size,
double first ,
double last) {
ecl_kw_type * ecl_kw = ecl_nnc_export_get_tranll_kw(grid , init_file , lgr_nr1 , lgr_nr2 );
printf("lgr: %d -> %d \n",lgr_nr1 , lgr_nr2);
test_assert_not_NULL(ecl_kw);
test_assert_true(ecl_kw_is_instance( ecl_kw ));
test_assert_int_equal( size , ecl_kw_get_size( ecl_kw ));
test_assert_double_equal( first , ecl_kw_iget_as_double( ecl_kw , 0 ));
test_assert_double_equal( last , ecl_kw_iget_as_double( ecl_kw , size - 1 ));
}
static void ecl_grav_survey_assert_RPORV( const ecl_grav_survey_type * survey , const ecl_file_type * init_file ) {
const ecl_grid_cache_type * grid_cache = survey->grid_cache;
int active_size = ecl_grid_cache_get_size( grid_cache );
const ecl_kw_type * init_porv_kw = ecl_file_iget_named_kw( init_file , PORV_KW , 0);
int check_points = 100;
int check_nr = 0;
while (check_nr < check_points) {
int active_index = rand() % active_size;
int global_index = ecl_grid_cache_iget_global_index( grid_cache , active_index );
double init_porv = ecl_kw_iget_as_double( init_porv_kw , global_index ); /* NB - this uses global indexing. */
if (init_porv > 0) {
double rporv = survey->porv[ active_index ];
double log_pormod = log10( rporv / init_porv );
if (fabs( log_pormod ) > 1) {
/* Detected as error if the effective pore volume multiplier
is greater than 10 or less than 0.10. */
fprintf(stderr,"-----------------------------------------------------------------\n");
fprintf(stderr,"INIT PORV : %g \n",init_porv);
fprintf(stderr,"RPORV : %g \n",rporv);
fprintf(stderr,"Hmmm - the RPORV values extracted from the restart file seem to be \n");
fprintf(stderr,"veeery different from the initial porv value. This might indicate \n");
fprintf(stderr,"an ECLIPSE bug in the RPORV handling. Try using another ECLIPSE version,\n");
fprintf(stderr,"or alternatively the PORMOD approach instead\n");
fprintf(stderr,"-----------------------------------------------------------------\n");
exit(1);
}
check_nr++;
}
}
}
void test_kw_io_charlength() {
test_work_area_type * work_area = test_work_area_alloc("ecl_kw_io_charlength");
{
const char * KW0 = "QWERTYUI";
const char * KW1 = "ABCDEFGHIJTTTTTTTTTTTTTTTTTTTTTTABCDEFGHIJKLMNOP";
ecl_kw_type * ecl_kw_out0 = ecl_kw_alloc(KW0 , 5, ECL_FLOAT);
ecl_kw_type * ecl_kw_out1 = ecl_kw_alloc(KW1 , 5, ECL_FLOAT);
for (int i=0; i < ecl_kw_get_size( ecl_kw_out1); i++) {
ecl_kw_iset_float( ecl_kw_out0 , i , i*1.5 );
ecl_kw_iset_float( ecl_kw_out1 , i , i*1.5 );
}
{
fortio_type * f = fortio_open_writer( "TEST1" , false, ECL_ENDIAN_FLIP );
test_assert_true( ecl_kw_fwrite( ecl_kw_out0, f ));
test_assert_false(ecl_kw_fwrite( ecl_kw_out1, f ));
fortio_fclose( f );
}
{
test_assert_false( util_file_exists( "TEST1"));
}
{
FILE * file = util_fopen("TEST2", "w");
ecl_kw_fprintf_grdecl(ecl_kw_out1 , file);
fclose(file);
}
{
FILE * file = util_fopen("TEST2", "r");
ecl_kw_type * ecl_kw_in = ecl_kw_fscanf_alloc_grdecl( file , KW1 , -1 , ECL_FLOAT);
test_assert_string_equal(KW1, ecl_kw_get_header(ecl_kw_in) );
test_assert_int_equal(5, ecl_kw_get_size( ecl_kw_in) );
test_assert_double_equal(ecl_kw_iget_as_double(ecl_kw_in, 0), 0.0);
test_assert_double_equal(ecl_kw_iget_as_double(ecl_kw_in, 4), 6.0);
fclose(file);
}
ecl_kw_free( ecl_kw_out0 );
ecl_kw_free( ecl_kw_out1 );
}
test_work_area_free( work_area );
}
static int ecl_nnc_export__( const ecl_grid_type * grid , int lgr_index1 , const ecl_file_type * init_file , ecl_nnc_type * nnc_data, int * nnc_offset) {
int nnc_index = *nnc_offset;
int lgr_nr1 = ecl_grid_get_lgr_nr( grid );
int global_index1;
int valid_trans = 0 ;
const ecl_grid_type * global_grid = ecl_grid_get_global_grid( grid );
if (!global_grid)
global_grid = grid;
for (global_index1 = 0; global_index1 < ecl_grid_get_global_size( grid ); global_index1++) {
const nnc_info_type * nnc_info = ecl_grid_get_cell_nnc_info1( grid , global_index1 );
if (nnc_info) {
int lgr_index2;
for (lgr_index2=0; lgr_index2 < nnc_info_get_size( nnc_info ); lgr_index2++) {
const nnc_vector_type * nnc_vector = nnc_info_iget_vector( nnc_info , lgr_index2 );
const int_vector_type * grid2_index_list = nnc_vector_get_grid_index_list( nnc_vector );
const int_vector_type * nnc_index_list = nnc_vector_get_nnc_index_list( nnc_vector );
int lgr_nr2 = nnc_vector_get_lgr_nr( nnc_vector );
const ecl_kw_type * tran_kw = ecl_nnc_export_get_tranx_kw(global_grid , init_file , lgr_nr1 , lgr_nr2 );
int index2;
ecl_nnc_type nnc;
nnc.grid_nr1 = lgr_nr1;
nnc.grid_nr2 = lgr_nr2;
nnc.global_index1 = global_index1;
for (index2 = 0; index2 < nnc_vector_get_size( nnc_vector ); index2++) {
nnc.global_index2 = int_vector_iget( grid2_index_list , index2 );
nnc.input_index = int_vector_iget( nnc_index_list, index2 );
if(tran_kw) {
nnc.trans = ecl_kw_iget_as_double(tran_kw, nnc.input_index);
valid_trans++;
}else{
nnc.trans = ERT_ECL_DEFAULT_NNC_TRANS;
}
nnc_data[nnc_index] = nnc;
nnc_index++;
}
}
}
}
*nnc_offset = nnc_index;
return valid_trans;
}
static ecl_grav_survey_type * ecl_grav_survey_alloc_RPORV(ecl_grav_type * ecl_grav ,
const ecl_file_type * restart_file ,
const char * name ) {
ecl_grav_survey_type * survey = ecl_grav_survey_alloc_empty( ecl_grav , name , GRAV_CALC_RPORV);
if (ecl_file_has_kw( restart_file , RPORV_KW)) {
ecl_kw_type * rporv_kw = ecl_file_iget_named_kw( restart_file , RPORV_KW , 0);
int iactive;
for (iactive = 0; iactive < ecl_kw_get_size( rporv_kw ); iactive++)
survey->porv[ iactive ] = ecl_kw_iget_as_double( rporv_kw , iactive );
} else
util_abort("%s: restart file did not contain %s keyword??\n",__func__ , RPORV_KW);
{
const ecl_file_type * init_file = ecl_grav->init_file;
ecl_grav_survey_assert_RPORV( survey , init_file );
ecl_grav_survey_add_phases( ecl_grav , survey , restart_file , GRAV_CALC_RPORV);
}
return survey;
}
void check_exported_data(const char * exported_file,
const char * init_file,
field_file_format_type file_type,
const field_config_type * field_config,
const field_type * field,
int nx,
int ny,
int nz) {
FILE * original_stream = NULL;
ecl_kw_type * kw_original = NULL;
FILE * exported_stream = NULL;
ecl_kw_type * kw_exported = NULL;
field_type * exported_field = NULL;
field_config_type * exported_field_config = NULL;
{
if (init_file) {
original_stream = util_fopen( init_file , "r");
kw_original = ecl_kw_fscanf_alloc_grdecl_dynamic( original_stream , field_config_get_key(field_config) , ECL_DOUBLE_TYPE );
}
if (ECL_GRDECL_FILE == file_type) {
exported_stream = util_fopen( exported_file , "r");
kw_exported = ecl_kw_fscanf_alloc_grdecl_dynamic( exported_stream , field_config_get_key(field_config) , ECL_DOUBLE_TYPE );
} else if (RMS_ROFF_FILE == file_type) {
ecl_grid_type * grid = field_config_get_grid(field_config);
exported_field_config = field_config_alloc_empty(field_config_get_key(field_config), grid, NULL, true);
exported_field = field_alloc(exported_field_config);
bool keep_inactive = true;
field_fload_rms(exported_field, exported_file, keep_inactive);
}
}
{
int k, j, i = 0;
for (k=0; k < nz; k++) {
for (j=0; j < ny; j++) {
for (i=0; i < nx; i++) {
bool active = field_config_active_cell(field_config, i, j, k);
double field_value = active ? field_ijk_get_double(field, i, j, k) : 0.0;
int global_index = field_config_global_index(field_config , i , j , k);
double exported_value = 0.0;
if (ECL_GRDECL_FILE == file_type)
exported_value = ecl_kw_iget_as_double(kw_exported, global_index);
else if (RMS_ROFF_FILE == file_type) {
exported_value = field_ijk_get_double(exported_field, i, j, k);
}
double initial_value = init_file ? ecl_kw_iget_as_double(kw_original, global_index) : 0.0;
if (active)
test_assert_double_equal(field_value, exported_value);
else if (init_file)
test_assert_double_equal(initial_value, exported_value);
else if (file_type == RMS_ROFF_FILE)
test_assert_double_equal(RMS_INACTIVE_DOUBLE, exported_value);
else
test_assert_double_equal(0.0, exported_value);
}
}
}
}
if (init_file) {
util_fclose(original_stream);
ecl_kw_free(kw_original);
}
if (ECL_GRDECL_FILE == file_type) {
util_fclose(exported_stream);
ecl_kw_free(kw_exported);
} else
field_free(exported_field);
}
static ecl_grav_phase_type * ecl_grav_phase_alloc( ecl_grav_type * ecl_grav ,
ecl_grav_survey_type * survey ,
ecl_phase_enum phase ,
const ecl_file_type * restart_file,
grav_calc_type calc_type) {
const ecl_file_type * init_file = ecl_grav->init_file;
const ecl_grid_cache_type * grid_cache = ecl_grav->grid_cache;
const char * sat_kw_name = ecl_util_get_phase_name( phase );
{
ecl_grav_phase_type * grav_phase = util_malloc( sizeof * grav_phase );
const int size = ecl_grid_cache_get_size( grid_cache );
UTIL_TYPE_ID_INIT( grav_phase , ECL_GRAV_PHASE_TYPE_ID );
grav_phase->grid_cache = grid_cache;
grav_phase->aquifer_cell = ecl_grav->aquifer_cell;
grav_phase->fluid_mass = util_calloc( size , sizeof * grav_phase->fluid_mass );
grav_phase->phase = phase;
grav_phase->work = NULL;
if (calc_type == GRAV_CALC_FIP) {
ecl_kw_type * pvtnum_kw = ecl_file_iget_named_kw( init_file , PVTNUM_KW , 0 );
double_vector_type * std_density = hash_get( ecl_grav->std_density , ecl_util_get_phase_name( phase ));
ecl_kw_type * fip_kw;
if ( phase == ECL_OIL_PHASE)
fip_kw = ecl_file_iget_named_kw( restart_file , FIPOIL_KW , 0 );
else if (phase == ECL_GAS_PHASE)
fip_kw = ecl_file_iget_named_kw( restart_file , FIPGAS_KW , 0 );
else
fip_kw = ecl_file_iget_named_kw( restart_file , FIPWAT_KW , 0 );
{
int iactive;
for (iactive=0; iactive < size; iactive++) {
double fip = ecl_kw_iget_as_double( fip_kw , iactive );
int pvtnum = ecl_kw_iget_int( pvtnum_kw , iactive );
grav_phase->fluid_mass[ iactive ] = fip * double_vector_safe_iget( std_density , pvtnum );
}
}
} else {
ecl_version_enum ecl_version = ecl_file_get_ecl_version( init_file );
const char * den_kw_name = get_den_kw( phase , ecl_version );
const ecl_kw_type * den_kw = ecl_file_iget_named_kw( restart_file , den_kw_name , 0 );
if (calc_type == GRAV_CALC_RFIP) {
ecl_kw_type * rfip_kw;
if ( phase == ECL_OIL_PHASE)
rfip_kw = ecl_file_iget_named_kw( restart_file , RFIPOIL_KW , 0 );
else if (phase == ECL_GAS_PHASE)
rfip_kw = ecl_file_iget_named_kw( restart_file , RFIPGAS_KW , 0 );
else
rfip_kw = ecl_file_iget_named_kw( restart_file , RFIPWAT_KW , 0 );
{
int iactive;
for (iactive=0; iactive < size; iactive++) {
double rho = ecl_kw_iget_as_double( den_kw , iactive );
double rfip = ecl_kw_iget_as_double( rfip_kw , iactive );
grav_phase->fluid_mass[ iactive ] = rho * rfip;
}
}
} else {
/* (calc_type == GRAV_CALC_RPORV) || (calc_type == GRAV_CALC_PORMOD) */
ecl_kw_type * sat_kw;
bool private_sat_kw = false;
if (ecl_file_has_kw( restart_file , sat_kw_name ))
sat_kw = ecl_file_iget_named_kw( restart_file , sat_kw_name , 0 );
else {
/* We are targeting the residual phase, e.g. the OIL phase in a three phase system. */
const ecl_kw_type * swat_kw = ecl_file_iget_named_kw( restart_file , "SWAT" , 0 );
sat_kw = ecl_kw_alloc_copy( swat_kw );
ecl_kw_scalar_set_float( sat_kw , 1.0 );
ecl_kw_inplace_sub( sat_kw , swat_kw ); /* sat = 1 - SWAT */
if (ecl_file_has_kw( restart_file , "SGAS" )) {
const ecl_kw_type * sgas_kw = ecl_file_iget_named_kw( restart_file , "SGAS" , 0 );
ecl_kw_inplace_sub( sat_kw , sgas_kw ); /* sat -= SGAS */
}
private_sat_kw = true;
}
{
int iactive;
for (iactive=0; iactive < size; iactive++) {
double rho = ecl_kw_iget_as_double( den_kw , iactive );
double sat = ecl_kw_iget_as_double( sat_kw , iactive );
grav_phase->fluid_mass[ iactive ] = rho * sat * survey->porv[ iactive ];
}
}
if (private_sat_kw)
ecl_kw_free( sat_kw );
}
}
return grav_phase;
}
}
void test_get_tran(const char * name) {
char * grid_file_name = ecl_util_alloc_filename(NULL , name , ECL_EGRID_FILE , false , -1);
char * init_file_name = ecl_util_alloc_filename(NULL , name , ECL_INIT_FILE , false , -1);
ecl_grid_type * grid = ecl_grid_alloc( grid_file_name );
ecl_file_type * grid_file = ecl_file_open( grid_file_name , 0 );
ecl_file_type * init_file = ecl_file_open( init_file_name , 0 );
/* Get global */
{
ecl_kw_type * tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANNNC_KW , 0 );
test_assert_true( ecl_kw_is_instance( tran_kw ));
test_assert_double_equal( 0.85582769 , ecl_kw_iget_as_double( tran_kw , 0 ));
test_assert_double_equal( 0.24635284 , ecl_kw_iget_as_double( tran_kw , 7184 ));
}
test_assert_NULL( ecl_nnc_export_get_tran_kw( init_file , TRANGL_KW , 0 ));
test_assert_NULL( ecl_nnc_export_get_tran_kw( init_file , TRANLL_KW , 0 ));
test_assert_NULL( ecl_nnc_export_get_tran_kw( init_file , "INVALID" , 1));
/* Get lgr_nr: 48 */
{
ecl_kw_type * tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANNNC_KW , 48 );
test_assert_true( ecl_kw_is_instance( tran_kw ));
test_assert_int_equal( 0 , ecl_kw_get_size( tran_kw ));
tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANGL_KW , 48 );
test_assert_int_equal( 282 , ecl_kw_get_size( tran_kw ));
test_assert_double_equal( 22.922695 , ecl_kw_iget_as_double( tran_kw , 0 ));
test_assert_double_equal( 16.720325 , ecl_kw_iget_as_double( tran_kw , 281 ));
}
/* Get lgr_nr: 99 */
{
ecl_kw_type * tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANNNC_KW , 99 );
test_assert_true( ecl_kw_is_instance( tran_kw ));
test_assert_int_equal( 0 , ecl_kw_get_size( tran_kw ));
tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANGL_KW , 99 );
test_assert_int_equal( 693 , ecl_kw_get_size( tran_kw ));
test_assert_double_equal( 0.25534782 , ecl_kw_iget_as_double( tran_kw , 0 ));
test_assert_double_equal( 0.12677453 , ecl_kw_iget_as_double( tran_kw , 692 ));
}
/* Get lgr_nr: 10 */
{
ecl_kw_type * tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANNNC_KW , 10 );
test_assert_true( ecl_kw_is_instance( tran_kw ));
test_assert_int_equal( 0 , ecl_kw_get_size( tran_kw ));
tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANGL_KW , 10 );
test_assert_int_equal( 260 , ecl_kw_get_size( tran_kw ));
test_assert_double_equal( 0.87355447 , ecl_kw_iget_as_double( tran_kw , 0 ));
test_assert_double_equal( 26.921568 , ecl_kw_iget_as_double( tran_kw , 259 ));
}
/* Get lgr_nr: 110 */
{
ecl_kw_type * tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANNNC_KW , 110 );
test_assert_true( ecl_kw_is_instance( tran_kw ));
test_assert_int_equal( 0 , ecl_kw_get_size( tran_kw ));
tran_kw = ecl_nnc_export_get_tran_kw( init_file , TRANGL_KW , 110 );
test_assert_int_equal( 208 , ecl_kw_get_size( tran_kw ));
test_assert_double_equal( 17.287283 , ecl_kw_iget_as_double( tran_kw , 0 ));
test_assert_double_equal( 569.26312 , ecl_kw_iget_as_double( tran_kw , 207 ));
}
free( init_file_name );
free(grid_file_name);
ecl_grid_free( grid );
ecl_file_close( grid_file );
ecl_file_close( init_file );
}
static int gravity_check_input( const ecl_grid_type * ecl_grid ,
const ecl_file_type * init_file ,
const ecl_file_type * restart_file1,
const ecl_file_type * restart_file2,
int * __model_phases,
int * __file_phases) {
{
int model_phases = 0;
int file_phases = 0;
/* Check which phases are present in the model */
if (ecl_file_has_kw(restart_file1 , "OIL_DEN")) {
model_phases += OIL;
simulator = ECLIPSE100 ;
} else if (ecl_file_has_kw(restart_file1 , "DENO")) {
model_phases += OIL;
simulator = ECLIPSE300 ;
} ;
if (ecl_file_has_kw(restart_file1 , "WAT_DEN")) {
model_phases += WATER;
simulator = ECLIPSE100 ;
} else if (ecl_file_has_kw(restart_file1 , "DENW")) {
model_phases += WATER;
simulator = ECLIPSE300 ;
} ;
if (ecl_file_has_kw(restart_file1 , "GAS_DEN")) {
model_phases += GAS;
simulator = ECLIPSE100 ;
} else if (ecl_file_has_kw(restart_file1 , "DENG")) {
model_phases += GAS;
simulator = ECLIPSE300 ;
} ;
/* Check which phases are present in the restart files. We assume the restart file NEVER has SOIL information */
if (ecl_file_has_kw(restart_file1 , "SWAT"))
file_phases += WATER;
if (ecl_file_has_kw(restart_file1 , "SGAS"))
file_phases += GAS;
/* Consiency check */
{
/**
The following assumptions are made:
1. All restart files should have water, i.e. the SWAT keyword.
2. All phases present in the restart file should also be present as densities,
in addition the model must contain one additional phase.
3. The restart files can never contain oil saturation.
*/
if ( !has_phase( file_phases , WATER ) )
util_exit("Could not locate SWAT keyword in restart files\n");
if ( has_phase( file_phases , OIL ))
util_exit("Can not handle restart files with SOIL keyword\n");
if (! has_phase( model_phases , WATER ) )
util_exit("Could not locate WAT_DEN keyword in restart files\n");
if ( has_phase( file_phases , GAS )) {
/** Restart file has both water and gas - means we need all three densities. */
if (! (has_phase( model_phases , GAS) && has_phase( model_phases , OIL)))
util_exit("Could not find GAS_DEN and OIL_DEN keywords in restart files\n");
} else {
/* This is (water + oil) or (water + gas) system. We enforce one of the densities.*/
if ( !has_phase( model_phases , GAS + OIL))
util_exit("Could not find either GAS_DEN or OIL_DEN kewyords in restart files\n");
}
}
*__model_phases = model_phases;
*__file_phases = file_phases;
}
/* Check that the restart files have RPORV information. This is ensured by giving the argument RPORV to the RPTRST keyword. */
if ( !(ecl_file_has_kw( restart_file1 , "RPORV") && ecl_file_has_kw( restart_file2 , "RPORV")) )
util_exit("Sorry: the restartfiles do not contain RPORV\n");
/**
Check that the rporv values are in the right ballpark. For
ECLIPSE version 2008.2 they are way f*****g off. Check PORV
versus RPORV for ten 'random' locations in the grid.
*/
{
const ecl_kw_type * rporv1_kw = ecl_file_iget_named_kw( restart_file1 , "RPORV" , 0);
const ecl_kw_type * rporv2_kw = ecl_file_iget_named_kw( restart_file2 , "RPORV" , 0);
const ecl_kw_type * init_porv_kw = ecl_file_iget_named_kw( init_file , "PORV" , 0);
int active_index;
int active_delta;
int active_size;
ecl_grid_get_dims( ecl_grid , NULL , NULL , NULL , &active_size );
active_delta = active_size / 12;
for (active_index = active_delta; active_index < active_size; active_index += active_delta) {
int global_index = ecl_grid_get_global_index1A( ecl_grid , active_index );
double init_porv = ecl_kw_iget_as_double( init_porv_kw , global_index ); /* NB - this uses global indexing. */
double rporv1 = ecl_kw_iget_as_double( rporv1_kw , active_index );
double rporv2 = ecl_kw_iget_as_double( rporv2_kw , active_index );
double rporv12 = 0.5 * ( rporv1 + rporv2 );
double fraction = util_double_min( init_porv , rporv12 ) / util_double_max( init_porv , rporv12 );
if (fraction < 0.50) {
fprintf(stderr,"-----------------------------------------------------------------\n");
fprintf(stderr,"INIT PORV: %g \n",init_porv);
fprintf(stderr,"RPORV1 : %g \n",rporv1);
fprintf(stderr,"RPORV2 : %g \n",rporv2);
fprintf(stderr,"Hmmm - the RPORV values extracted from the restart file seem to be \n");
fprintf(stderr,"veeery different from the initial rporv value. This might indicated\n");
fprintf(stderr,"an ECLIPSE bug. Version 2007.2 is known to be ok in this respect, \n");
fprintf(stderr,"whereas version 2008.2 is known to have a bug. \n");
fprintf(stderr,"-----------------------------------------------------------------\n");
exit(1);
}
}
}
return 0;
}
