static void enkf_main_update_current_case( enkf_main_type * enkf_main , const char * case_path /* Can be NULL */) { if (!case_path) case_path = enkf_fs_get_case_name( enkf_main_get_fs(enkf_main) ); enkf_main_write_current_case_file(enkf_main, case_path); update_case_log(enkf_main , case_path); enkf_main_gen_data_special( enkf_main ); enkf_main_add_subst_kw( enkf_main , "ERT-CASE" , enkf_main_get_current_fs( enkf_main ) , "Current case" , true ); enkf_main_add_subst_kw( enkf_main , "ERTCASE" , enkf_main_get_current_fs( enkf_main ) , "Current case" , true ); }
void * enkf_main_init_case_from_existing_JOB( void * self , const stringlist_type * args) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); const char * source_case = stringlist_iget( args , 0 ); enkf_fs_type * source_fs = enkf_main_mount_alt_fs( enkf_main , source_case , true ); { enkf_fs_type * target_fs; if (stringlist_get_size(args) > 1) { const char * current_case = enkf_main_get_current_fs(enkf_main); const char * target_case = stringlist_iget( args , 1 ); if (0 != strcmp(current_case, target_case)) { target_fs = enkf_main_mount_alt_fs( enkf_main , target_case , true ); } else target_fs = enkf_fs_get_ref( enkf_main_get_fs(enkf_main) ); // Using get_ref so that we can unconditionally call decref() further down. } else target_fs = enkf_fs_get_ref( enkf_main_get_fs(enkf_main) ); // Using get_ref so that we can unconditionally call decref() further down. enkf_main_init_case_from_existing(enkf_main, source_fs, 0, ANALYZED, target_fs); enkf_fs_decref(target_fs); } enkf_fs_decref(source_fs); return NULL; }
void * enkf_main_create_reports_JOB(void * self , const stringlist_type * args ) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); ert_report_list_type * report_list = enkf_main_get_report_list( enkf_main ); ert_report_list_create( report_list , enkf_main_get_current_fs( enkf_main ) , true ); return NULL; }
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_tui_fs_copy_ensemble_of_parameters(void * arg) { int prompt_len = 35; char * source_case; int last_report; int report_step_from; char * report_step_from_as_char; int report_step_to; state_enum state_from; state_enum state_to; enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); source_case = util_alloc_string_copy(enkf_main_get_current_fs( enkf_main )); last_report = enkf_main_get_history_length( enkf_main ); report_step_from_as_char = util_scanf_int_with_limits_return_char("Source report step",prompt_len , 0 , last_report); if(strlen(report_step_from_as_char) !=0){ util_sscanf_int(report_step_from_as_char , &report_step_from); state_from = enkf_tui_util_scanf_state("Source analyzed/forecast [a|f]" , prompt_len , false); if(state_from != UNDEFINED){ util_printf_prompt("Target case" , prompt_len , '=' , "=> "); char target_case[256]; if ( fgets(target_case, prompt_len, stdin) ) { char *newline = strchr(target_case, '\n'); if (newline) *newline = 0; } if (strlen(target_case)) { char * report_step_to_as_char = util_scanf_int_with_limits_return_char("Target report step",prompt_len , 0 , last_report); if(strlen(report_step_to_as_char) !=0){ util_sscanf_int(report_step_to_as_char , &report_step_to); state_to = enkf_tui_util_scanf_state("Target analyzed/forecast [a|f]" , prompt_len , false); if(state_to != UNDEFINED){ enkf_tui_fs_copy_ensemble__(enkf_main, source_case, target_case, report_step_from, state_from, report_step_to, state_to, true); } } free(report_step_to_as_char); } } } free(source_case); free(report_step_from_as_char); }
void enkf_tui_fs_select_case(void * arg) { int prompt_len = 40; char * new_case; char * menu_title; arg_pack_type * arg_pack = arg_pack_safe_cast( arg ); enkf_main_type * enkf_main = enkf_main_safe_cast( arg_pack_iget_ptr(arg_pack, 0) ); menu_type * menu = arg_pack_iget_ptr(arg_pack, 1); new_case = enkf_tui_fs_alloc_existing_case( enkf_main , "Name of case" , prompt_len); if (new_case != NULL) { enkf_main_select_fs( enkf_main , new_case ); menu_title = util_alloc_sprintf("Manage cases. Current: %s", enkf_main_get_current_fs( enkf_main )); menu_set_title(menu, menu_title); free(menu_title); free(new_case); } }
void enkf_tui_fs_menu(void * arg) { enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); const char * menu_title = util_alloc_sprintf("Manage cases - current: %s", enkf_main_get_current_fs( enkf_main )); menu_type * menu = menu_alloc(menu_title , "Back" , "bB"); menu_add_item(menu , "List available cases" , "lL" , enkf_tui_fs_ls_case , enkf_main , NULL); { arg_pack_type * arg_pack = arg_pack_alloc(); arg_pack_append_ptr(arg_pack , enkf_main); arg_pack_append_ptr(arg_pack , menu); menu_add_item(menu , "Create and select new case" , "cC" , enkf_tui_fs_create_case, arg_pack , arg_pack_free__); } { arg_pack_type * arg_pack = arg_pack_alloc(); arg_pack_append_ptr(arg_pack , enkf_main); arg_pack_append_ptr(arg_pack , menu); menu_add_item(menu , "Select case" , "sS" , enkf_tui_fs_select_case, arg_pack , arg_pack_free__); } menu_add_separator(menu); menu_add_item(menu, "Initialize case from scratch" , "iI" , enkf_tui_init_menu , enkf_main , NULL); menu_add_item(menu, "Initialize case from existing case" , "aA" , enkf_tui_fs_initialize_case_from_copy , enkf_main , NULL); menu_add_item(menu, "Initialize case FOR PREDICTIONS from existing case", "pP" , enkf_tui_fs_initialize_case_for_predictions , enkf_main , NULL); menu_add_separator(menu); /* Are these two in use??? */ menu_add_item(menu, "Copy full ensemble to another case", "eE", enkf_tui_fs_copy_ensemble, enkf_main, NULL); menu_add_item(menu, "Copy ensemble of parameters to another case", "oO", enkf_tui_fs_copy_ensemble_of_parameters, enkf_main, NULL); menu_add_item(menu , "Help" , "hH" , enkf_tui_help_menu_cases , enkf_main , NULL); menu_run(menu); menu_free(menu); }
void enkf_tui_fs_create_case(void * arg) { int prompt_len = 50; char new_case[256]; char * menu_title; arg_pack_type * arg_pack = arg_pack_safe_cast( arg ); enkf_main_type * enkf_main = enkf_main_safe_cast( arg_pack_iget_ptr(arg_pack, 0) ); menu_type * menu = arg_pack_iget_ptr(arg_pack, 1); util_printf_prompt("Name of new case" , prompt_len , '=' , "=> "); if (fgets(new_case, prompt_len, stdin) != NULL){ char *newline = strchr(new_case, '\n'); if (newline) *newline = 0; if(strlen(new_case) != 0) enkf_main_select_fs( enkf_main , new_case ); } menu_title = util_alloc_sprintf("Manage cases. Current: %s", enkf_main_get_current_fs(enkf_main)); menu_set_title(menu, menu_title); free(menu_title); }
void enkf_tui_run_menu(void * arg) { enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); model_config_type * model_config = enkf_main_get_model_config( enkf_main ); path_fmt_type * runpath_fmt = model_config_get_runpath_fmt( model_config ); menu_type * menu; { char * title = util_alloc_sprintf("Run menu [case:%s Runpath:%s]" , enkf_main_get_current_fs( enkf_main ) , path_fmt_get_fmt ( runpath_fmt )); menu = menu_alloc(title , "Back" , "bB"); free(title); } menu_add_item(menu , "Ensemble run: history" , "xX" , enkf_tui_run_exp , enkf_main , NULL); menu_add_separator( menu ); { const ecl_config_type * ecl_config = enkf_main_get_ecl_config( enkf_main ); const model_config_type * model_config = enkf_main_get_model_config( enkf_main ); const analysis_config_type * analysis_config = enkf_main_get_analysis_config(enkf_main); menu_item_type * enkf_item = menu_add_item(menu , "Start EnKF run from beginning" , "sS" , enkf_tui_run_start , enkf_main , NULL); menu_item_type * restart_enkf_item = menu_add_item(menu , "Restart EnKF run from arbitrary state" , "rR" , enkf_tui_run_restart__ , enkf_main , NULL); menu_item_type * ES_item = menu_add_item(menu , "Integrated smoother update" , "iI" , enkf_tui_run_smoother , enkf_main , NULL); menu_item_type * it_ES_item = menu_add_item(menu , "Iterated smoother [RML-EnKF]" , "tT" , enkf_tui_run_iterated_ES , enkf_main , NULL); menu_item_type * one_more_item = menu_add_item(menu , "One more iteration (disabled)" , "mM" , enkf_tui_run_one_more_iteration , enkf_main , NULL); if (!ecl_config_has_schedule( ecl_config )) { menu_item_disable( enkf_item ); menu_item_disable( restart_enkf_item ); } if (!ecl_config_has_init_section( ecl_config )) menu_item_disable( enkf_item ); menu_item_disable( one_more_item ); if (!analysis_config_get_module_option(analysis_config , ANALYSIS_ITERABLE)) { menu_item_disable( it_ES_item ); menu_item_disable( one_more_item ); } else { menu_item_disable( enkf_item ); menu_item_disable( restart_enkf_item ); menu_item_disable( ES_item ); } if (!model_config_has_history( model_config )) { menu_item_disable( it_ES_item ); menu_item_disable( ES_item ); menu_item_disable( one_more_item ); } } menu_add_separator(menu); menu_add_item(menu , "Create runpath directories - NO simulation" , "cC" , enkf_tui_run_create_runpath__ , enkf_main , NULL ); menu_add_item(menu , "Load results manually" , "lL" , enkf_tui_run_manual_load__ , enkf_main , NULL); menu_add_separator(menu); { menu_item_type * analysis_item = menu_add_item(menu , "Analysis menu" , "aA" , enkf_tui_analysis_menu , enkf_main , NULL); if (!enkf_main_have_obs( enkf_main )) menu_item_disable( analysis_item ); } /* Option to set runpath runtime - currently dismantled. menu_add_separator(menu); { model_config_type * model_config = enkf_main_get_model_config( enkf_main ); path_fmt_type * runpath_fmt = model_config_get_runpath_fmt( model_config ); arg_pack_type * arg_pack = arg_pack_alloc(); char * runpath_label = util_alloc_sprintf("Set new value for RUNPATH:%s" , path_fmt_get_fmt ( runpath_fmt )); arg_pack_append_ptr(arg_pack , model_config); arg_pack_append_ptr(arg_pack , menu_add_item(menu , runpath_label , "dD" , enkf_tui_run_set_runpath , arg_pack , arg_pack_free__)); free(runpath_label); } */ menu_add_item(menu , "Help" , "hH" , enkf_tui_help_menu_run , enkf_main , NULL); menu_run(menu); menu_free(menu); }