void enkf_main_init_case_from_existing(const enkf_main_type * enkf_main,
enkf_fs_type * source_case_fs,
int source_report_step,
state_enum source_state,
enkf_fs_type * target_case_fs ) {
stringlist_type * param_list = ensemble_config_alloc_keylist_from_var_type( enkf_main_get_ensemble_config(enkf_main) , PARAMETER ); /* Select only paramters - will fail for GEN_DATA of type DYNAMIC_STATE. */
int target_report_step = 0;
state_enum target_state = ANALYZED;
bool_vector_type * iactive = bool_vector_alloc( 0 , true );
enkf_main_copy_ensemble(enkf_main,
source_case_fs,
source_report_step,
source_state,
target_case_fs,
target_report_step,
target_state ,
iactive,
NULL,
param_list);
enkf_fs_fsync(target_case_fs);
bool_vector_free(iactive);
stringlist_free(param_list);
}
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 );
}
static void enkf_main_update_summary_config_from_fs__(enkf_main_type * enkf_main, enkf_fs_type * fs) {
ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
summary_key_set_type * summary_key_set = enkf_fs_get_summary_key_set(fs);
stringlist_type * keys = summary_key_set_get_keys(summary_key_set);
for(int i = 0; i < stringlist_get_size(keys); i++) {
const char * key = stringlist_iget(keys, i);
ensemble_config_add_summary(ensemble_config, key, LOAD_FAIL_SILENT);
}
}
void enkf_tui_init(enkf_main_type * enkf_main, bool all_members , bool all_parameters , bool interval ) {
const int prompt_len = 35;
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
int ens_size = enkf_main_get_ensemble_size( enkf_main );
int iens1, iens2;
init_mode_enum init_mode = INIT_FORCE;
bool iens_valid = false;
/* iens2 should be interpreted as __inclusive__ */
if ( all_members ) {
iens1 = 0;
iens2 = ens_size - 1;
iens_valid = true;
} else {
if( interval ) {
char * iens1char = util_scanf_int_with_limits_return_char("First ensemble member in interval" , prompt_len , 0 , ens_size - 1);
if (strlen(iens1char)) {
util_sscanf_int(iens1char , &iens1);
char * iens2char = util_scanf_int_with_limits_return_char("Second ensemble member in interval" , prompt_len , iens1 , ens_size - 1);
if (strlen(iens2char)) {
util_sscanf_int(iens2char , &iens2);
iens_valid = true;
}
free(iens2char);
}
free(iens1char);
} else {
char * iens1char = util_scanf_int_with_limits_return_char("Initialize ensemble member" , prompt_len , 0 , ens_size - 1);
if (strlen(iens1char)) {
util_sscanf_int(iens1char , &iens1);
iens2 = iens1;
iens_valid = true;
}
free(iens1char);
}
}
if (iens_valid) {
stringlist_type * param_list = NULL;
if (all_parameters)
param_list = ensemble_config_alloc_keylist_from_var_type( ensemble_config , PARAMETER );
else {
const enkf_config_node_type * config_node = NULL;
param_list = stringlist_alloc_new();
config_node = enkf_tui_util_scanf_key(ensemble_config , prompt_len , INVALID , INVALID_VAR);
if( config_node != NULL )
stringlist_append_copy( param_list , enkf_config_node_get_key(config_node));
}
if (param_list != NULL) {
enkf_main_initialize_from_scratch(enkf_main , param_list , iens1 , iens2 , init_mode);
stringlist_free( param_list );
}
}
}
static void enkf_main_copy_ensemble( const enkf_main_type * enkf_main,
enkf_fs_type * source_case_fs,
int source_report_step,
state_enum source_state,
enkf_fs_type * target_case_fs,
int target_report_step,
state_enum target_state,
const bool_vector_type * iens_mask,
const char * ranking_key , /* It is OK to supply NULL - but if != NULL it must exist */
const stringlist_type * node_list) {
const int ens_size = enkf_main_get_ensemble_size( enkf_main );
state_map_type * target_state_map = enkf_fs_get_state_map(target_case_fs);
{
int * ranking_permutation;
int inode , src_iens;
if (ranking_key != NULL) {
ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main );
ranking_permutation = (int *) ranking_table_get_permutation( ranking_table , ranking_key );
} else {
ranking_permutation = util_calloc( ens_size , sizeof * ranking_permutation );
for (src_iens = 0; src_iens < ens_size; src_iens++)
ranking_permutation[src_iens] = src_iens;
}
for (inode =0; inode < stringlist_get_size( node_list ); inode++) {
enkf_config_node_type * config_node = ensemble_config_get_node( enkf_main_get_ensemble_config(enkf_main) , stringlist_iget( node_list , inode ));
for (src_iens = 0; src_iens < enkf_main_get_ensemble_size( enkf_main ); src_iens++) {
if (bool_vector_safe_iget(iens_mask , src_iens)) {
int target_iens = ranking_permutation[src_iens];
node_id_type src_id = {.report_step = source_report_step , .iens = src_iens , .state = source_state };
node_id_type target_id = {.report_step = target_report_step , .iens = target_iens , .state = target_state };
/* The copy is careful ... */
if (enkf_config_node_has_node( config_node , source_case_fs , src_id))
enkf_node_copy( config_node ,
source_case_fs , target_case_fs ,
src_id , target_id );
if (0 == target_report_step)
state_map_iset(target_state_map, target_iens, STATE_INITIALIZED);
}
}
}
if (ranking_permutation == NULL)
free( ranking_permutation );
}
}
void enkf_tui_export_gen_data(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);
{
int report_step;
int iens1 , iens2;
const int last_report = enkf_main_get_history_length( enkf_main );
const enkf_config_node_type * config_node;
path_fmt_type * file_fmt;
config_node = enkf_tui_util_scanf_key(ensemble_config , PROMPT_LEN , GEN_DATA , INVALID_VAR);
report_step = util_scanf_int_with_limits("Report step: ", PROMPT_LEN , 0 , last_report);
enkf_tui_util_scanf_iens_range("Realizations members to export(0 - %d)" , enkf_main_get_ensemble_size( enkf_main ) , PROMPT_LEN , &iens1 , &iens2);
{
char path_fmt[512];
util_printf_prompt("Filename to store files in (with %d) in: " , PROMPT_LEN , '=' , "=> ");
scanf("%s" , path_fmt);
file_fmt = path_fmt_alloc_path_fmt( path_fmt );
}
{
enkf_fs_type * fs = enkf_main_tui_get_fs(enkf_main);
enkf_node_type * node = enkf_node_alloc(config_node);
gen_data_file_format_type export_type = gen_data_guess_export_type( (const gen_data_type *) enkf_node_value_ptr(node) );
int iens;
for (iens = iens1; iens <= iens2; iens++) {
node_id_type node_id = {.report_step = report_step , .iens = iens};
if (enkf_node_try_load(node , fs, node_id)) {
char * full_path = path_fmt_alloc_path( file_fmt , false , iens);
char * path;
util_alloc_file_components(full_path , &path , NULL , NULL);
if (path != NULL) util_make_path( path );
{
const gen_data_type * gen_data = (const gen_data_type *) enkf_node_value_ptr(node);
gen_data_export(gen_data , full_path , export_type);
}
free(full_path);
free(path);
}
}
enkf_node_free(node);
}
}
}
void enkf_tui_export_field(const enkf_main_type * enkf_main , field_file_format_type file_type) {
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
const bool output_transform = true;
const enkf_config_node_type * config_node;
const int last_report = enkf_main_get_history_length( enkf_main );
int iens1 , iens2 , iens , report_step;
path_fmt_type * export_path;
config_node = enkf_tui_util_scanf_key(ensemble_config , PROMPT_LEN , FIELD , INVALID_VAR );
report_step = util_scanf_int_with_limits("Report step: ", PROMPT_LEN , 0 , last_report);
enkf_tui_util_scanf_iens_range("Realizations members to export(0 - %d)" , enkf_main_get_ensemble_size( enkf_main ) , PROMPT_LEN , &iens1 , &iens2);
{
char * path_fmt;
util_printf_prompt("Filename to store files in (with %d) in: " , PROMPT_LEN , '=' , "=> ");
path_fmt = util_alloc_stdin_line();
export_path = path_fmt_alloc_path_fmt( path_fmt );
free( path_fmt );
}
{
enkf_fs_type * fs = enkf_main_tui_get_fs(enkf_main);
enkf_node_type * node = enkf_node_alloc(config_node);
for (iens = iens1; iens <= iens2; iens++) {
node_id_type node_id = {.report_step = report_step , .iens = iens };
if (enkf_node_try_load(node , fs , node_id)) {
char * filename = path_fmt_alloc_path( export_path , false , iens);
{
char * path;
util_alloc_file_components(filename , &path , NULL , NULL);
if (path != NULL) {
util_make_path( path );
free( path );
}
}
{
const field_type * field = (const field_type *) enkf_node_value_ptr(node);
field_export(field , filename , NULL , file_type , output_transform, NULL);
}
free(filename);
} else
printf("Warning: could not load realization:%d \n", iens);
}
enkf_node_free(node);
}
}
void * enkf_main_init_misfit_table_JOB(void * self, const stringlist_type * args) {
enkf_main_type * enkf_main = enkf_main_safe_cast( self );
int history_length = enkf_main_get_history_length(enkf_main);
enkf_obs_type * enkf_obs = enkf_main_get_obs(enkf_main);
int ens_size = enkf_main_get_ensemble_size(enkf_main);
enkf_fs_type * fs = enkf_main_get_fs(enkf_main);
bool force_update = true;
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs );
misfit_ensemble_initialize( misfit_ensemble , ensemble_config , enkf_obs , fs , ens_size , history_length, force_update);
return NULL;
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
const char * root_path = argv[1];
const char * config_file = argv[2];
const char * init_file = argv[3];
const char * forward_init_string = argv[4];
test_work_area_type * work_area = test_work_area_alloc(config_file );
test_work_area_copy_directory_content( work_area , root_path );
test_work_area_install_file( work_area , init_file );
test_work_area_set_store(work_area, true);
bool strict = true;
enkf_main_type * enkf_main = enkf_main_bootstrap( NULL , config_file , strict , true );
enkf_fs_type * init_fs = enkf_main_get_fs(enkf_main);
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
run_arg_type * run_arg = run_arg_alloc_ENSEMBLE_EXPERIMENT( init_fs , 0 ,0 , "simulations/run0");
enkf_node_type * field_node = enkf_state_get_node( state , "PORO" );
bool forward_init;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
test_assert_bool_equal( enkf_node_use_forward_init( field_node ) , forward_init );
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
util_clear_directory( "Storage" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
if (forward_init)
util_copy_file( init_file , "simulations/run0/petro.grdecl");
{
bool_vector_type * iactive = bool_vector_alloc( enkf_main_get_ensemble_size(enkf_main) , true);
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
bool_vector_free( iactive );
test_assert_int_equal(error, 0);
}
test_assert_true(check_original_exported_data_equal(field_node));
run_arg_free( run_arg );
enkf_main_free(enkf_main);
test_work_area_free(work_area);
}
static void enkf_tui_ranking_create_data__( void * arg , bool sort_increasing) {
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config( enkf_main );
//const int history_length = enkf_main_get_history_length( enkf_main );
const int prompt_len = 60;
const char * prompt1 = "Data key to use for ranking";
const char * prompt2 = "Report step of data";
const char * ranking_name = "Name of new ranking";
const char * store_prompt = "Name of file to store ranking [Blank - no store]";
int step;
state_enum state = FORECAST;
char * user_key;
util_printf_prompt(prompt1 , prompt_len , '=' , "=> ");
user_key = util_alloc_stdin_line();
if (user_key != NULL) {
util_printf_prompt( prompt2 , prompt_len , '=' , "=> ");
{
char * step_char = util_alloc_stdin_line();
if (step_char == NULL)
step = 0;
else {
if (util_sscanf_int( step_char , &step )) {
const enkf_config_node_type * config_node;
char * key_index;
config_node = ensemble_config_user_get_node( ensemble_config , user_key , &key_index);
if (config_node) {
util_printf_prompt(ranking_name , prompt_len , '=' , "=> ");
char * ranking_key = util_alloc_stdin_line();
if (ranking_key != NULL) {
ranking_table_add_data_ranking( ranking_table , sort_increasing , ranking_key , user_key , key_index , fs , config_node, step , state );
ranking_table_display_ranking( ranking_table , ranking_key );
}
util_safe_free( ranking_key );
}
}
}
util_safe_free( step_char );
}
}
util_safe_free( user_key );
}
static void enkf_tui_ranking_make_misfit_ensemble( void * arg) {
arg_pack_type * arg_pack = arg_pack_safe_cast( arg );
enkf_main_type * enkf_main = arg_pack_iget_ptr( arg_pack , 0 );
enkf_fs_type * fs = enkf_main_get_fs(enkf_main);
enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main );
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
const int history_length = enkf_main_get_history_length( enkf_main );
const int ens_size = enkf_main_get_ensemble_size( enkf_main );
misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs );
misfit_ensemble_update( misfit_ensemble , ensemble_config , enkf_obs , fs , ens_size , history_length );
{
menu_item_type * obs_item = arg_pack_iget_ptr( arg_pack , 1 );
menu_item_enable( obs_item );
}
}
void enkf_tui_export_scalar2csv(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;
char * user_key, *key_index;
util_printf_prompt("Scalar to export (KEY:INDEX)" , PROMPT_LEN , '=' , "=> "); user_key = util_alloc_stdin_line();
config_node = ensemble_config_user_get_node( ensemble_config , user_key , &key_index);
if (config_node != NULL) {
int report_step , first_report, last_report;
int iens1 , iens2, iens;
char * csv_file;
iens2 = enkf_main_get_ensemble_size( enkf_main ) - 1;
iens1 = 0;
first_report = 0;
last_report = enkf_main_get_history_length( enkf_main );
{
char * path;
char * prompt = util_alloc_sprintf("File to store \'%s\'", user_key);
util_printf_prompt(prompt , PROMPT_LEN , '=' , "=> ");
csv_file = util_alloc_stdin_line();
util_alloc_file_components( csv_file , &path , NULL , NULL);
if (path != NULL) {
if (util_entry_exists( path )) {
if (!util_is_directory( path )) {
/* The path component already exists in the filesystem - and it is not a directory - we leave the building. */
fprintf(stderr,"Sorry: %s already exists - and is not a directory.\n",path);
free(path);
free(csv_file);
free(user_key);
return ;
}
} else {
/* The path does not exist - we make it. */
enkf_tui_util_msg("Creating new directory: %s\n" , path);
util_make_path( path );
}
}
free(prompt);
}
{
/* Seriously manual creation of csv file. */
enkf_fs_type * fs = enkf_main_tui_get_fs(enkf_main);
enkf_node_type * node = enkf_node_alloc( config_node );
FILE * stream = util_fopen( csv_file , "w");
node_id_type node_id;
/* Header line */
fprintf(stream , "\"Report step\"");
for (iens = iens1; iens <= iens2; iens++)
fprintf(stream , "%s\"%s(%d)\"" , CSV_SEP , user_key , iens);
fprintf(stream , CSV_NEWLINE);
for (report_step = first_report; report_step <= last_report; report_step++) {
fprintf(stream , "%6d" , report_step);
node_id.report_step = report_step;
for (iens = iens1; iens <= iens2; iens++) {
double value;
char label[32];
/*
Have not implemented a choice on forecast/analyzed. Tries
analyzed first, then forecast.
*/
node_id.iens = iens;
sprintf(label , "%03d/%03d" , report_step , iens);
if (enkf_node_user_get( node , fs , key_index , node_id , &value))
fprintf(stream , "%s%g" , CSV_SEP , value);
else
fprintf(stream , "%s%s" , CSV_SEP , CSV_MISSING_VALUE);
}
fprintf(stream , CSV_NEWLINE);
}
enkf_node_free( node );
fclose(stream);
}
} else
fprintf(stderr,"Sorry - could not find any nodes with key:%s\n",user_key);
free(user_key);
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
const char * root_path = argv[1];
const char * config_file = argv[2];
const char * forward_init_string = argv[3];
test_work_area_type * work_area = test_work_area_alloc(config_file );
test_work_area_copy_directory_content( work_area , root_path );
{
bool forward_init;
bool strict = true;
enkf_main_type * enkf_main;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
util_clear_directory( "Storage" , true , true );
enkf_main = enkf_main_bootstrap( NULL , config_file , strict , true );
{
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_node_type * gen_kw_node = enkf_state_get_node( state , "MULTFLT" );
{
const enkf_config_node_type * gen_kw_config_node = enkf_node_get_config( gen_kw_node );
char * init_file1 = enkf_config_node_alloc_initfile( gen_kw_config_node , NULL , 0);
char * init_file2 = enkf_config_node_alloc_initfile( gen_kw_config_node , "/tmp", 0);
test_assert_bool_equal( enkf_config_node_use_forward_init( gen_kw_config_node ) , forward_init );
test_assert_string_equal( init_file1 , "MULTFLT_INIT");
test_assert_string_equal( init_file2 , "/tmp/MULTFLT_INIT");
free( init_file1 );
free( init_file2 );
}
test_assert_bool_equal( enkf_node_use_forward_init( gen_kw_node ) , forward_init );
if (forward_init)
test_assert_bool_not_equal( enkf_node_initialize( gen_kw_node , 0 , enkf_state_get_rng( state )) , forward_init);
// else hard_failure()
}
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
if (forward_init) {
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
run_arg_type * run_arg = run_arg_alloc_ENSEMBLE_EXPERIMENT( fs , 0 , 0 , "simulations/run0");
enkf_node_type * gen_kw_node = enkf_state_get_node( state , "MULTFLT" );
node_id_type node_id = {.report_step = 0 ,
.iens = 0,
.state = ANALYZED };
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
{
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
bool_vector_type * iactive = bool_vector_alloc( enkf_main_get_ensemble_size( enkf_main ) , true);
test_assert_false( enkf_node_has_data( gen_kw_node , fs, node_id ));
util_unlink_existing( "simulations/run0/MULTFLT_INIT" );
test_assert_false( enkf_node_forward_init( gen_kw_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , run_arg , &error );
test_assert_true(LOAD_FAILURE & error);
error = 0;
{
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
state_map_type * state_map = enkf_fs_get_state_map(fs);
state_map_iset(state_map , 0 , STATE_INITIALIZED);
}
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
bool_vector_free( iactive );
test_assert_true(LOAD_FAILURE & error);
}
{
FILE * stream = util_fopen("simulations/run0/MULTFLT_INIT" , "w");
fprintf(stream , "123456.0\n" );
fclose( stream );
}
{
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
test_assert_true( enkf_node_forward_init( gen_kw_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , run_arg , &error );
test_assert_int_equal(0, error);
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
test_assert_int_equal(0, error);
{
double value;
test_assert_true( enkf_node_user_get( gen_kw_node , fs , "MULTFLT" , node_id , &value));
test_assert_double_equal( 123456.0 , value);
}
}
test_assert_true( util_is_file ("simulations/run0/parameters.txt")); //Export of gen kw params
util_clear_directory( "simulations" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
test_assert_true( util_is_file( "simulations/run0/MULTFLT.INC" ));
{
FILE * stream = util_fopen("simulations/run0/MULTFLT.INC" , "r");
double value;
fscanf(stream , "%lg" , &value);
fclose( stream );
test_assert_double_equal( 123456.0 , value);
}
util_clear_directory( "simulations" , true , true );
run_arg_free( run_arg );
}
enkf_main_free( enkf_main );
}
test_work_area_free( work_area );
}
static void enkf_tui_fs_copy_ensemble__(
enkf_main_type * enkf_main,
const char * source_case,
const char * target_case,
int report_step_from,
state_enum state_from,
int report_step_to,
state_enum state_to,
bool only_parameters)
{
msg_type * msg = msg_alloc("Copying: " , false);
ensemble_config_type * config = enkf_main_get_ensemble_config(enkf_main);
int ens_size = enkf_main_get_ensemble_size(enkf_main);
char * ranking_key;
const int * ranking_permutation = NULL;
int * identity_permutation;
ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main );
if (ranking_table_get_size( ranking_table ) > 0) {
util_printf_prompt("Name of ranking to resort by (or blank)" , 50 , '=' , "=> ");
ranking_key = util_alloc_stdin_line();
if (ranking_table_has_ranking( ranking_table , ranking_key ))
ranking_permutation = ranking_table_get_permutation( ranking_table , ranking_key );
else {
fprintf(stderr," Sorry: ranking:%s does not exist \n", ranking_key );
return;
}
}
identity_permutation = util_calloc( ens_size , sizeof * identity_permutation );
{
int iens;
for (iens =0; iens < ens_size; iens++)
identity_permutation[iens] = iens;
}
if (ranking_permutation == NULL)
ranking_permutation = identity_permutation;
{
/* If the current target_case does not exist it is automatically created by the select_write_dir function */
enkf_fs_type * src_fs = enkf_main_mount_alt_fs( enkf_main , source_case , false );
enkf_fs_type * target_fs = enkf_main_mount_alt_fs( enkf_main , target_case , true );
stringlist_type * nodes = ensemble_config_alloc_keylist_from_var_type(config, PARAMETER);
{
int num_nodes = stringlist_get_size(nodes);
msg_show(msg);
for(int i = 0; i < num_nodes; i++) {
const char * key = stringlist_iget(nodes, i);
enkf_config_node_type * config_node = ensemble_config_get_node(config , key);
msg_update(msg , key);
enkf_node_copy_ensemble(config_node, src_fs , target_fs , report_step_from, state_from, report_step_to , state_to , ens_size , ranking_permutation);
}
}
enkf_fs_decref( src_fs );
enkf_fs_decref( target_fs );
msg_free(msg , true);
stringlist_free(nodes);
}
free( identity_permutation );
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
const char * root_path = argv[1];
const char * config_file = argv[2];
const char * forward_init_string = argv[3];
test_work_area_type * work_area = test_work_area_alloc(config_file , false);
test_work_area_copy_directory_content( work_area , root_path );
{
bool forward_init;
bool strict = true;
enkf_main_type * enkf_main;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
util_clear_directory( "Storage" , true , true );
enkf_main = enkf_main_bootstrap( NULL , config_file , strict , true );
{
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_node_type * gen_param_node = enkf_state_get_node( state , "PARAM" );
{
const enkf_config_node_type * gen_param_config_node = enkf_node_get_config( gen_param_node );
char * init_file1 = enkf_config_node_alloc_initfile( gen_param_config_node , NULL , 0);
char * init_file2 = enkf_config_node_alloc_initfile( gen_param_config_node , "/tmp", 0);
test_assert_bool_equal( enkf_config_node_use_forward_init( gen_param_config_node ) , forward_init );
test_assert_string_equal( init_file1 , "PARAM_INIT");
test_assert_string_equal( init_file2 , "/tmp/PARAM_INIT");
free( init_file1 );
free( init_file2 );
}
test_assert_bool_equal( enkf_node_use_forward_init( gen_param_node ) , forward_init );
if (forward_init)
test_assert_bool_not_equal( enkf_node_initialize( gen_param_node , 0 , enkf_state_get_rng( state )) , forward_init);
// else hard_failure()
}
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
if (forward_init) {
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
enkf_node_type * gen_param_node = enkf_state_get_node( state , "PARAM" );
node_id_type node_id = {.report_step = 0 ,
.iens = 0,
.state = ANALYZED };
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
{
run_mode_type run_mode = ENSEMBLE_EXPERIMENT;
enkf_main_init_run(enkf_main , run_mode); /* This is ugly */
test_assert_false( enkf_node_has_data( gen_param_node , fs, node_id ));
util_unlink_existing( "simulations/run0/PARAM_INIT" );
}
{
FILE * stream = util_fopen("simulations/run0/PARAM_INIT" , "w");
fprintf(stream , "0\n1\n2\n3\n" );
fclose( stream );
}
{
bool loadOK = true;
stringlist_type * msg_list = stringlist_alloc_new();
{
run_mode_type run_mode = ENSEMBLE_EXPERIMENT;
enkf_main_init_run(enkf_main , run_mode); /* This is ugly */
}
test_assert_true( enkf_node_forward_init( gen_param_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , fs , &loadOK );
test_assert_true( loadOK );
enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list );
stringlist_free( msg_list );
test_assert_true( loadOK );
{
double value;
test_assert_true( enkf_node_user_get( gen_param_node , fs , "0" , node_id , &value));
test_assert_double_equal( 0 , value);
test_assert_true( enkf_node_user_get( gen_param_node , fs , "1" , node_id , &value));
test_assert_double_equal( 1 , value);
test_assert_true( enkf_node_user_get( gen_param_node , fs , "2" , node_id , &value));
test_assert_double_equal( 2 , value);
}
}
util_clear_directory( "simulations" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
test_assert_true( util_is_file( "simulations/run0/PARAM.INC" ));
{
FILE * stream = util_fopen("simulations/run0/PARAM.INC" , "r");
double v0,v1,v2,v3;
fscanf(stream , "%lg %lg %lg %lg" , &v0,&v1,&v2,&v3);
fclose( stream );
test_assert_double_equal( 0 , v0);
test_assert_double_equal( 1 , v1);
test_assert_double_equal( 2 , v2);
test_assert_double_equal( 3 , v3);
}
util_clear_directory( "simulations" , true , true );
}
enkf_main_free( enkf_main );
}
test_work_area_free( work_area );
}
static void enkf_main_update_custom_kw_config_from_fs__(enkf_main_type * enkf_main, enkf_fs_type * fs) {
ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
custom_kw_config_set_type * custom_kw_config_set = enkf_fs_get_custom_kw_config_set(fs);
ensemble_config_update_custom_kw_config(ensemble_config, custom_kw_config_set);
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
{
const char * config_file = argv[1];
const char * init_file = argv[2];
const char * forward_init_string = argv[3];
bool forward_init;
bool strict = true;
enkf_main_type * enkf_main;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
util_clear_directory( "/tmp/Storage" , true , true );
enkf_main = enkf_main_bootstrap( NULL , config_file , strict , true );
{
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_node_type * surface_node = enkf_state_get_node( state , "SURFACE" );
{
const enkf_config_node_type * surface_config_node = enkf_node_get_config( surface_node );
char * init_file1 = enkf_config_node_alloc_initfile( surface_config_node , NULL , 0);
char * init_file2 = enkf_config_node_alloc_initfile( surface_config_node , "/tmp", 0);
test_assert_bool_equal( enkf_config_node_use_forward_init( surface_config_node ) , forward_init );
test_assert_string_equal( init_file1 , "Surface.irap");
test_assert_string_equal( init_file2 , "/tmp/Surface.irap");
free( init_file1 );
free( init_file2 );
}
test_assert_bool_equal( enkf_node_use_forward_init( surface_node ) , forward_init );
if (forward_init)
test_assert_bool_not_equal( enkf_node_initialize( surface_node , 0 , enkf_state_get_rng( state )) , forward_init);
// else hard_failure()
}
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
if (forward_init) {
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
enkf_node_type * surface_node = enkf_state_get_node( state , "SURFACE" );
node_id_type node_id = {.report_step = 0 ,
.iens = 0,
.state = ANALYZED };
create_runpath( enkf_main );
test_assert_true( util_is_directory( "/tmp/simulations/run0" ));
{
bool loadOK = true;
stringlist_type * msg_list = stringlist_alloc_new();
{
run_mode_type run_mode = ENSEMBLE_EXPERIMENT;
enkf_main_init_run(enkf_main , run_mode); /* This is ugly */
}
test_assert_false( enkf_node_has_data( surface_node , fs, node_id ));
util_unlink_existing( "/tmp/simulations/run0/Surface.irap" );
test_assert_false( enkf_node_forward_init( surface_node , "/tmp/simulations/run0" , 0 ));
enkf_state_forward_init( state , fs , &loadOK );
test_assert_false( loadOK );
loadOK = true;
enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list );
stringlist_free( msg_list );
test_assert_false( loadOK );
}
util_copy_file( init_file , "/tmp/simulations/run0/Surface.irap");
{
bool loadOK = true;
stringlist_type * msg_list = stringlist_alloc_new();
{
run_mode_type run_mode = ENSEMBLE_EXPERIMENT;
enkf_main_init_run(enkf_main , run_mode); /* This is ugly */
}
test_assert_true( enkf_node_forward_init( surface_node , "/tmp/simulations/run0" , 0 ));
enkf_state_forward_init( state , fs , &loadOK );
test_assert_true( loadOK );
enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list );
stringlist_free( msg_list );
test_assert_true( loadOK );
{
double value;
test_assert_true( enkf_node_user_get( surface_node , fs , "0" , node_id , &value));
test_assert_double_equal( 2735.7461 , value);
test_assert_true( enkf_node_user_get( surface_node , fs , "5" , node_id , &value));
test_assert_double_equal( 2737.0122 , value);
}
}
util_clear_directory( "/tmp/simulations" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "/tmp/simulations/run0" ));
test_assert_true( util_is_file( "/tmp/simulations/run0/SURFACE.INC" ));
test_assert_true( enkf_node_fload( surface_node , "/tmp/simulations/run0/SURFACE.INC"));
{
double value;
test_assert_true( enkf_node_user_get( surface_node , fs , "0" , node_id , &value));
test_assert_double_equal( 2735.7461 , value);
test_assert_true( enkf_node_user_get( surface_node , fs , "5" , node_id , &value));
test_assert_double_equal( 2737.0122 , value);
}
util_clear_directory( "/tmp/simulations" , true , true );
}
enkf_main_free( enkf_main );
}
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
const char * root_path = argv[1];
const char * config_file = argv[2];
const char * init_file = argv[3];
const char * forward_init_string = argv[4];
test_work_area_type * work_area = test_work_area_alloc(config_file );
test_work_area_copy_directory_content( work_area , root_path );
test_work_area_install_file( work_area , init_file );
{
bool forward_init;
bool strict = true;
enkf_main_type * enkf_main;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
util_clear_directory( "Storage" , true , true );
enkf_main = enkf_main_bootstrap( config_file , strict , true );
{
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_node_type * surface_node = enkf_state_get_node( state , "SURFACE" );
{
const enkf_config_node_type * surface_config_node = enkf_node_get_config( surface_node );
char * init_file1 = enkf_config_node_alloc_initfile( surface_config_node , NULL , 0);
char * init_file2 = enkf_config_node_alloc_initfile( surface_config_node , "/tmp", 0);
test_assert_bool_equal( enkf_config_node_use_forward_init( surface_config_node ) , forward_init );
test_assert_string_equal( init_file1 , "Surface.irap");
test_assert_string_equal( init_file2 , "/tmp/Surface.irap");
free( init_file1 );
free( init_file2 );
}
test_assert_bool_equal( enkf_node_use_forward_init( surface_node ) , forward_init );
if (forward_init)
test_assert_bool_not_equal( enkf_node_initialize( surface_node , 0 , enkf_state_get_rng( state )) , forward_init);
// else hard_failure()
}
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
if (forward_init) {
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
run_arg_type * run_arg = run_arg_alloc_ENSEMBLE_EXPERIMENT( fs , 0 ,0 , "simulations/run0");
enkf_node_type * surface_node = enkf_state_get_node( state , "SURFACE" );
node_id_type node_id = {.report_step = 0 ,
.iens = 0,
.state = ANALYZED };
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
{
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
test_assert_false( enkf_node_has_data( surface_node , fs, node_id ));
util_unlink_existing( "simulations/run0/Surface.irap" );
test_assert_false( enkf_node_forward_init( surface_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , run_arg , &error );
test_assert_true(LOAD_FAILURE & error);
error = 0;
{
enkf_fs_type * fs = enkf_main_get_fs(enkf_main);
state_map_type * state_map = enkf_fs_get_state_map(fs);
state_map_iset(state_map, 0, STATE_INITIALIZED);
}
enkf_state_load_from_forward_model(state, run_arg , &error, false, msg_list);
stringlist_free( msg_list );
test_assert_true(LOAD_FAILURE & error);
}
util_copy_file( init_file , "simulations/run0/Surface.irap");
{
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
test_assert_true( enkf_node_forward_init( surface_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , run_arg , &error );
test_assert_int_equal(0, error);
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
test_assert_int_equal(0, error);
{
double value;
test_assert_true( enkf_node_user_get( surface_node , fs , "0" , node_id , &value));
test_assert_double_equal( 2735.7461 , value);
test_assert_true( enkf_node_user_get( surface_node , fs , "5" , node_id , &value));
test_assert_double_equal( 2737.0122 , value);
}
}
util_clear_directory( "simulations" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
test_assert_true( util_is_file( "simulations/run0/SURFACE.INC" ));
test_assert_true( enkf_node_fload( surface_node , "simulations/run0/SURFACE.INC"));
{
double value;
test_assert_true( enkf_node_user_get( surface_node , fs , "0" , node_id , &value));
test_assert_double_equal( 2735.7461 , value);
test_assert_true( enkf_node_user_get( surface_node , fs , "5" , node_id , &value));
test_assert_double_equal( 2737.0122 , value);
}
util_clear_directory( "simulations" , true , true );
}
enkf_main_free( enkf_main );
}
}
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);
}
void enkf_tui_init(enkf_main_type * enkf_main, bool all_members , bool all_parameters , bool interval ) {
const int prompt_len = 35;
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
int ens_size = enkf_main_get_ensemble_size( enkf_main );
int iens1, iens2;
bool iens_valid = false;
/* iens2 should be interpreted as __inclusive__ */
if ( all_members ) {
iens1 = 0;
iens2 = ens_size - 1;
iens_valid = true;
} else {
if( interval ) {
char * iens1char = util_scanf_int_with_limits_return_char("First ensemble member in interval" , prompt_len , 0 , ens_size - 1);
if (strlen(iens1char)) {
util_sscanf_int(iens1char , &iens1);
char * iens2char = util_scanf_int_with_limits_return_char("Second ensemble member in interval" , prompt_len , iens1 , ens_size - 1);
if (strlen(iens2char)) {
util_sscanf_int(iens2char , &iens2);
iens_valid = true;
}
free(iens2char);
}
free(iens1char);
} else {
char * iens1char = util_scanf_int_with_limits_return_char("Initialize ensemble member" , prompt_len , 0 , ens_size - 1);
if (strlen(iens1char)) {
util_sscanf_int(iens1char , &iens1);
iens2 = iens1;
iens_valid = true;
}
free(iens1char);
}
}
if (iens_valid) {
stringlist_type * param_list = NULL;
if (all_parameters)
param_list = ensemble_config_alloc_keylist_from_var_type( ensemble_config , PARAMETER );
else {
const enkf_config_node_type * config_node = NULL;
param_list = stringlist_alloc_new();
config_node = enkf_tui_util_scanf_key(ensemble_config , prompt_len , INVALID , INVALID_VAR);
if( config_node != NULL )
stringlist_append_copy( param_list , enkf_config_node_get_key(config_node));
}
if (param_list != NULL) {
enkf_fs_type * init_fs = enkf_main_tui_get_fs( enkf_main );
bool_vector_type * iens_mask = bool_vector_alloc( ens_size , false );
path_fmt_type * runpath_fmt = model_config_get_runpath_fmt(enkf_main_get_model_config(enkf_main));
subst_list_type * subst_list = enkf_main_get_data_kw(enkf_main);
int iter = 0;
bool_vector_iset_block( iens_mask , iens1 , iens2 - iens1 + 1, true );
{
ert_run_context_type * run_context = ert_run_context_alloc_INIT_ONLY(init_fs, INIT_CONDITIONAL, iens_mask, runpath_fmt, subst_list , iter );
enkf_main_initialize_from_scratch(enkf_main , param_list , run_context);
ert_run_context_free(run_context);
}
stringlist_free( param_list );
bool_vector_free( iens_mask );
}
}
}
