/**
this is called by the enkf_state function while loading results,
that code is run in parallell by many threads.
*/
void ensemble_config_ensure_static_key(ensemble_config_type * ensemble_config , const char * kw ) {
pthread_mutex_lock( &ensemble_config->mutex );
{
if (!ensemble_config_has_key(ensemble_config , kw))
ensemble_config_add_STATIC_node(ensemble_config , kw );
}
pthread_mutex_unlock( &ensemble_config->mutex );
}
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_get_alt_fs( enkf_main , source_case , true , false );
enkf_fs_type * target_fs = enkf_main_get_alt_fs( enkf_main , target_case , false, true );
stringlist_type * nodes;
if(only_parameters)
nodes = ensemble_config_alloc_keylist_from_var_type(config, PARAMETER);
else {
/* Must explicitly load the static nodes. */
stringlist_type * restart_kw_list = stringlist_alloc_new();
int i;
enkf_fs_fread_restart_kw_list(src_fs , report_step_from , 0 , restart_kw_list);
for (i = 0; i < stringlist_get_size( restart_kw_list ); i++) {
const char * kw = stringlist_iget( restart_kw_list , i);
if (!ensemble_config_has_key(config , kw))
ensemble_config_add_STATIC_node(config , kw );
}
for (i=0; i < ens_size; i++)
enkf_fs_fwrite_restart_kw_list(target_fs , report_step_to , i , restart_kw_list);
stringlist_free( restart_kw_list );
nodes = ensemble_config_alloc_keylist(config);
}
/***/
{
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_main_close_alt_fs( enkf_main , src_fs );
enkf_main_close_alt_fs( enkf_main , target_fs );
msg_free(msg , true);
stringlist_free(nodes);
}
free( identity_permutation );
}
