void enkf_tui_export_fieldP(void * arg) {
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
const enkf_config_node_type * config_node = enkf_tui_util_scanf_key(ensemble_config , PROMPT_LEN , FIELD , INVALID_VAR );
int iens1 = 0;
int iens2 = enkf_main_get_ensemble_size( enkf_main );
const int last_report = enkf_main_get_history_length( enkf_main );
int report_step = util_scanf_int_with_limits("Report step: ", PROMPT_LEN , 0 , last_report);
double lower_limit = util_scanf_double("Lower limit", PROMPT_LEN);
double upper_limit = util_scanf_double("Upper limit", PROMPT_LEN);
char * export_file;
util_printf_prompt("Filename to store file: " , PROMPT_LEN , '=' , "=> ");
export_file = util_alloc_stdin_line();
{
enkf_fs_type * fs = enkf_main_tui_get_fs(enkf_main);
enkf_node_type ** ensemble = enkf_node_load_alloc_ensemble( config_node , fs , report_step , iens1 , iens2 );
enkf_node_type * sum = enkf_node_alloc( config_node );
int active_ens_size = 0;
int iens;
enkf_node_clear( sum );
{
/* OK going low level */
field_type * sum_field = (field_type *) enkf_node_value_ptr( sum );
for (iens = iens1; iens < iens2; iens++) {
if (ensemble[iens - iens1] != NULL) {
field_type * field = (field_type *) enkf_node_value_ptr( ensemble[iens - iens1] );
field_update_sum( sum_field , field , lower_limit , upper_limit);
active_ens_size++;
}
}
if (active_ens_size > 0) {
field_scale( sum_field , 1.0 / active_ens_size );
{
char * path;
util_alloc_file_components( export_file , &path , NULL , NULL);
if (path != NULL) {
util_make_path( path );
free( path );
}
}
field_export(sum_field , export_file , NULL , RMS_ROFF_FILE , false, NULL);
} else fprintf(stderr,"Warning: no data found \n");
}
for (iens = iens1; iens < iens2; iens++) {
if (ensemble[iens - iens1] != NULL)
enkf_node_free( ensemble[iens - iens1] );
}
free( ensemble );
enkf_node_free( sum );
}
free( export_file );
}
extern int plot(opt_t *opt)
{
int err = ERROR_BUG;
#ifndef HAVE_GETRUSAGE
/* simple timer */
clock_t c0, c1;
c0 = clock();
#endif
#ifdef HAVE_GETTIMEOFDAY
/* high resolution elapsed time */
struct timeval tv0;
gettimeofday(&tv0, NULL);
#endif
#ifdef HAVE_PTHREAD_H
if (opt->v.verbose)
{
printf("using %i thread%s\n", opt->v.threads,
(opt->v.threads == 1 ? "" : "s"));
}
#endif
if (opt->test != test_none)
{
/* test field */
switch (opt->test)
{
case test_circular:
TFMSG("circular");
err = plot_circular(opt);
break;
case test_electro2:
TFMSG("two-point electrostatic");
err = plot_electro2(opt);
break;
case test_electro3:
TFMSG("three-point electrostatic");
err = plot_electro3(opt);
break;
case test_cylinder:
TFMSG("cylindrical flow");
err = plot_cylinder(opt);
break;
default:
err = ERROR_BUG;
}
}
else
{
/* data field */
if (opt->v.verbose)
{
int i;
printf("reading field from\n");
for (i=0 ; i<opt->input.n ; i++)
{
printf(" %s\n", opt->input.file[i]);
}
}
field_t *field = field_read(opt->input.format,
opt->input.n,
opt->input.file);
if (!field)
{
fprintf(stderr, "failed to read field\n");
return ERROR_READ_OPEN;
}
/* this needs to be in libvfplot */
field_scale(field, opt->v.arrow.scale);
domain_t* dom;
if (opt->domain.file)
dom = domain_read(opt->domain.file);
else
dom = field_domain(field);
if (!dom)
{
fprintf(stderr, "no domain\n");
return ERROR_BUG;
}
err = plot_generic(dom, (vfun_t)fv_field, (cfun_t)fc_field, (void*)field, opt);
field_destroy(field);
domain_destroy(dom);
}
#ifdef HAVE_STAT
/* if success then stat the output file */
if (err == ERROR_OK)
{
struct stat sb;
if ((opt->v.file.output.path != NULL) &&
(stat(opt->v.file.output.path, &sb) != 0))
{
fprintf(stderr,
"problem with %s : %s\n",
opt->v.file.output.path,
strerror(errno));
}
else
{
if (opt->v.verbose)
printf("wrote %li bytes to %s\n",
(long)sb.st_size,
opt->v.file.output.path);
}
}
#endif
if (opt->v.verbose)
{
#ifdef HAVE_GETRUSAGE
/* datailed stats on POSIX systems */
struct rusage usage;
if (getrusage(RUSAGE_SELF, &usage) == 0)
{
double
user = usage.ru_utime.tv_sec + (double)usage.ru_utime.tv_usec/1e6,
sys = usage.ru_stime.tv_sec + (double)usage.ru_stime.tv_usec/1e6;
printf("CPU time %.3f s (user) %.3f s (system)\n", user, sys);
}
else
{
fprintf(stderr, "no usage stats (not fatal) ; error %s\n", strerror(errno));
}
#else
/* simple stats on C89 systems */
c1 = clock();
double wall = ((double)(c1 - c0))/(double)CLOCKS_PER_SEC;
printf("CPU time %.3f s\n", wall);
#endif
#ifdef HAVE_GETTIMEOFDAY
struct timeval tv1, dtv;
gettimeofday(&tv1, NULL);
timeval_subtract(&dtv, &tv1, &tv0);
printf("elapsed time %ld.%03ld s\n", dtv.tv_sec, dtv.tv_usec/1000);
#endif
}
return err;
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
const char * config_file = argv[1];
const char * init_file = argv[2];
const char * key = "PORO";
int iens = 0;
ert_test_context_type * test_context = ert_test_context_alloc("ExportInactiveCellsTest" , config_file);
enkf_main_type * enkf_main = ert_test_context_get_main(test_context);
enkf_fs_type * fs = enkf_main_get_fs(enkf_main);
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
const enkf_config_node_type * config_node = ensemble_config_get_node(ensemble_config , key);
const field_config_type * field_config = enkf_config_node_get_ref( config_node );
enkf_state_type * state = enkf_main_iget_state( enkf_main , iens );
enkf_node_type * field_node = enkf_state_get_node( state , key );
field_type * field = enkf_node_value_ptr(field_node);
{
forward_initialize_node(enkf_main, init_file, field_node);
node_id_type node_id = {.report_step = 0 , .iens = iens , .state = BOTH };
test_assert_true(enkf_node_try_load(field_node , fs , node_id));
field_scale(field, 3.0);
}
int nx,ny,nz;
field_config_get_dims(field_config , &nx , &ny , &nz);
const char * export_file_grdecl = "my_test_dir/exported_field_test_file_grdecl";
const char * export_file_roff = "my_test_dir/exported_field_test_file_roff";
field_file_format_type file_type;
char * found_init_file = enkf_main_alloc_abs_path_to_init_file(enkf_main, config_node);
{
file_type = ECL_GRDECL_FILE;
field_export(field, export_file_grdecl, NULL, file_type, false, found_init_file);
check_exported_data(export_file_grdecl, init_file, file_type, field_config, field, nx, ny, nz);
}
{
file_type = RMS_ROFF_FILE;
field_export(field, export_file_roff, NULL, file_type, false, found_init_file);
check_exported_data(export_file_roff, init_file, file_type, field_config, field, nx, ny, nz);
}
free(found_init_file);
found_init_file = NULL;
{
file_type = ECL_GRDECL_FILE;
field_export(field, export_file_grdecl, NULL, file_type, false, found_init_file);
check_exported_data(export_file_grdecl, found_init_file, file_type, field_config, field, nx, ny, nz);
}
{
file_type = RMS_ROFF_FILE;
field_export(field, export_file_roff, NULL, file_type, false, found_init_file);
check_exported_data(export_file_roff, found_init_file, file_type, field_config, field, nx, ny, nz);
}
ert_test_context_free(test_context);
exit(0);
}
