static void data_ranking_init(data_ranking_type * ranking ,
enkf_fs_type * fs ,
enkf_config_node_type * config_node,
const char * key_index ,
int step ,
state_enum state ) {
enkf_node_type * enkf_node = enkf_node_alloc( config_node );
int iens;
for (iens = 0; iens < ranking->ens_size; iens++) {
double value;
node_id_type node_id = {.report_step = step ,
.iens = iens ,
.state = state
};
if (enkf_node_user_get( enkf_node , fs , key_index , node_id , &value)) {
double_vector_iset( ranking->data_ensemble , iens , value );
bool_vector_iset( ranking->valid , iens , true );
}
}
if (ranking->sort_increasing)
ranking->sort_permutation = double_vector_alloc_sort_perm( ranking->data_ensemble );
else
ranking->sort_permutation = double_vector_alloc_rsort_perm( ranking->data_ensemble );
enkf_node_free( enkf_node );
}
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 );
}
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 * 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 );
}
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 );
}
}
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);
}
