void test_init_case_job(ert_test_context_type * test_context, const char * job_name , const char * job_file) { stringlist_type * args = stringlist_alloc_new(); enkf_main_type * enkf_main = ert_test_context_get_main(test_context); test_assert_true( ert_test_context_install_workflow_job( test_context , "JOB" , job_file ) ); //Test init current case from existing { enkf_fs_type * cur_fs = enkf_main_mount_alt_fs( enkf_main , "new_current_case" , true ); enkf_main_select_fs(enkf_main, "new_current_case"); test_assert_ptr_not_equal(cur_fs , enkf_main_get_fs( enkf_main )); stringlist_append_copy( args, "default"); //case to init from test_assert_true( ert_test_context_run_worklow_job( test_context , "JOB" , args) ); enkf_fs_decref(cur_fs); } { const char * current_case = enkf_main_get_current_fs( enkf_main ); test_assert_string_equal(current_case, "new_current_case"); test_assert_true(enkf_fs_has_node(enkf_main_get_fs(enkf_main), "PERMZ", PARAMETER, 0, 0, ANALYZED)); enkf_fs_type * default_fs = enkf_main_mount_alt_fs( enkf_main , "default" , true ); state_map_type * default_state_map = enkf_fs_get_state_map(default_fs); state_map_type * current_state_map = enkf_fs_get_state_map(enkf_main_get_fs(enkf_main)); test_assert_int_equal(state_map_get_size(default_state_map), state_map_get_size(current_state_map)); enkf_fs_decref(default_fs); } //Test init case from existing case: stringlist_clear(args); stringlist_append_copy(args, "default"); //case to init from stringlist_append_copy(args, "new_not_current_case"); test_assert_true( ert_test_context_run_worklow_job( test_context , "JOB" , args) ); { enkf_fs_type * fs = enkf_main_mount_alt_fs(enkf_main, "new_not_current_case", true); test_assert_not_NULL( fs ); test_assert_true( enkf_fs_has_node(fs, "PERMZ", PARAMETER, 0, 0, ANALYZED )); enkf_fs_type * default_fs = enkf_main_mount_alt_fs( enkf_main , "default" , true ); state_map_type * default_state_map = enkf_fs_get_state_map(default_fs); state_map_type * new_state_map = enkf_fs_get_state_map(fs); test_assert_int_equal(state_map_get_size(default_state_map), state_map_get_size(new_state_map)); enkf_fs_decref(fs); } stringlist_free( args ); }
void enkf_plot_gen_kw_load( enkf_plot_gen_kw_type * plot_gen_kw, enkf_fs_type * fs, bool transform_data , int report_step, const bool_vector_type * input_mask ) { state_map_type * state_map = enkf_fs_get_state_map( fs ); int ens_size = state_map_get_size( state_map ); bool_vector_type * mask; if (input_mask) mask = bool_vector_alloc_copy( input_mask ); else mask = bool_vector_alloc( ens_size , true ); enkf_plot_gen_kw_resize( plot_gen_kw , ens_size ); { int iens; for (iens = 0; iens < ens_size; ++iens) { if (bool_vector_iget( mask , iens)) { enkf_plot_gen_kw_vector_type * vector = enkf_plot_gen_kw_iget( plot_gen_kw , iens ); enkf_plot_gen_kw_vector_load( vector , fs , transform_data , report_step ); } } } }
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 ); } }
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) { const char * config_file = argv[1]; test_work_area_type * work_area = test_work_area_alloc( "enkf_main_fs" ); char * model_config; util_alloc_file_components( config_file , NULL , &model_config , NULL); test_work_area_copy_parent_content( work_area , config_file ); { const char * site_config = "/project/res/etc/ERT/site-config"; enkf_main_type * enkf_main = enkf_main_bootstrap( site_config , model_config , false , false ); enkf_main_select_fs( enkf_main , "enkf"); test_assert_true( enkf_main_case_is_current( enkf_main , "enkf")); test_assert_false( enkf_main_case_is_current( enkf_main , "default_fs")); test_assert_false( enkf_main_case_is_current( enkf_main , "does_not_exist")); test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); { enkf_fs_type * fs_ref = enkf_main_get_fs_ref( enkf_main ); test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); enkf_fs_decref( fs_ref ); test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); } { state_map_type * map1 = enkf_fs_get_state_map( enkf_main_get_fs( enkf_main )); state_map_type * map2 = enkf_main_alloc_readonly_state_map(enkf_main , "enkf"); test_assert_true(state_map_equal( map1 , map2 )); state_map_free( map2 ); } { enkf_fs_type * fs1 = enkf_main_mount_alt_fs( enkf_main , "default" , false ); enkf_fs_type * fs2 = enkf_main_mount_alt_fs( enkf_main , "enkf" , false ); test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); test_assert_int_equal( 2 , enkf_fs_get_refcount( fs2 )); test_assert_int_equal( 1 , enkf_fs_get_refcount( fs1 )); enkf_fs_decref( fs1 ); enkf_fs_decref( fs2 ); } { enkf_fs_type * enkf_fs = enkf_main_mount_alt_fs( enkf_main , "enkf" , false ); enkf_main_select_fs( enkf_main , "default"); test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); enkf_fs_decref( enkf_fs ); } { enkf_fs_type * default_fs = enkf_main_mount_alt_fs( enkf_main , "default" , false ); test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); enkf_main_select_fs( enkf_main , "default"); test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); enkf_fs_decref( default_fs ); test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); } /*****************************************************************/ { enkf_fs_type * fs = enkf_main_mount_alt_fs( enkf_main , "default" , false ); test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); enkf_main_set_fs( enkf_main , fs , NULL ); enkf_fs_decref( fs ); test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); } { enkf_fs_type * fs = enkf_main_mount_alt_fs( enkf_main , "enkf" , false ); enkf_fs_type * current = enkf_main_mount_alt_fs( enkf_main , "default" , false ); test_assert_int_equal( 2 , enkf_fs_get_refcount( current )); test_assert_int_equal( 1 , enkf_fs_get_refcount( fs)); enkf_main_set_fs( enkf_main , fs , NULL); test_assert_int_equal( 2 , enkf_fs_get_refcount( fs)); test_assert_int_equal( 1 , enkf_fs_get_refcount( current )); enkf_fs_decref( current ); enkf_fs_decref( fs); } test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main ))); enkf_main_free( enkf_main ); } test_work_area_free( work_area ); exit(0); }