void enkf_main_user_select_fs(enkf_main_type * enkf_main , const char * input_case ) {
const char * ens_path = model_config_get_enspath( enkf_main->model_config);
int root_version = enkf_fs_get_version104( ens_path );
if (root_version == -1 || root_version == 105) {
if (input_case == NULL) {
char * current_mount_point = util_alloc_filename( ens_path , CURRENT_CASE , NULL);
if (enkf_main_current_case_file_exists(enkf_main)) {
char * current_case = enkf_main_read_alloc_current_case_name(enkf_main);
enkf_main_select_fs(enkf_main, current_case);
free (current_case);
} else if (enkf_fs_exists( current_mount_point ) && util_is_link( current_mount_point )) {
/*If the current_case file does not exists, but the 'current' symlink does we use readlink to
get hold of the actual target before calling the enkf_main_select_fs() function. We then
write the current_case file and delete the symlink.*/
char * target_case = util_alloc_atlink_target( ens_path , CURRENT_CASE );
enkf_main_select_fs( enkf_main , target_case );
unlink(current_mount_point);
enkf_main_write_current_case_file(enkf_main, target_case);
free( target_case );
} else
enkf_main_select_fs( enkf_main , DEFAULT_CASE ); // Selecting (a new) default case
free( current_mount_point );
} else
enkf_main_select_fs( enkf_main , input_case );
} else {
fprintf(stderr,"Sorry: the filesystem located in %s must be upgraded before the current ERT version can read it.\n" , ens_path);
exit(1);
}
}
int test_load_manually_to_new_case(enkf_main_type * enkf_main) {
int result = 0;
int iens = 0;
int iter = 0;
const char * casename = "new_case";
enkf_main_select_fs( enkf_main , casename );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
run_arg_type * run_arg = run_arg_alloc_ENSEMBLE_EXPERIMENT(fs , iens , iter , "simulations/run0");
{
arg_pack_type * arg_pack = arg_pack_alloc();
arg_pack_append_ptr( arg_pack , enkf_main_iget_state(enkf_main, 0));
arg_pack_append_ptr( arg_pack , run_arg );
arg_pack_append_bool( arg_pack , true );
arg_pack_append_owned_ptr( arg_pack , stringlist_alloc_new() , stringlist_free__);
arg_pack_append_bool( arg_pack, true );
arg_pack_append_ptr( arg_pack, &result );
enkf_state_load_from_forward_model_mt(arg_pack);
arg_pack_free(arg_pack);
}
return result;
}
int main( int argc , char ** argv) {
const char * model_config = argv[1];
const char * site_config = NULL;
ert_test_context_type * test_context = ert_test_context_alloc( "MAGIC-STRINGS" , model_config , site_config);
enkf_main_type * enkf_main = ert_test_context_get_main( test_context );
{
test_has_job( test_context );
enkf_main_select_fs(enkf_main , "default");
test_assert_string_equal( "default" , enkf_fs_get_case_name( enkf_main_get_fs( enkf_main )));
test_magic_strings( test_context );
enkf_main_select_fs(enkf_main , "extraCase");
test_assert_string_equal( "extraCase" , enkf_fs_get_case_name( enkf_main_get_fs( enkf_main )));
test_magic_strings( test_context );
}
ert_test_context_free( test_context );
}
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_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_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);
}
/*
Will create the new case if it does not exist.
*/
void * enkf_main_select_case_JOB( void * self , const stringlist_type * args) {
enkf_main_type * enkf_main = enkf_main_safe_cast( self );
const char * new_case = stringlist_iget( args , 0 );
enkf_main_select_fs( enkf_main , new_case );
return NULL;
}
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);
}
