void enkf_tui_workflow_run( void * arg ) {
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
{
ert_workflow_list_type * workflow_list = enkf_main_get_workflow_list( enkf_main );
util_printf_prompt("Name of workflow" , PROMPT_LEN , '=' , "=> ");
{
char * workflow_name = util_alloc_stdin_line();
if (workflow_name != NULL) {
if (ert_workflow_list_has_workflow( workflow_list , workflow_name )) {
bool runOK = ert_workflow_list_run_workflow_blocking( workflow_list , workflow_name , enkf_main);
if (!runOK) {
printf("Errors in workflow:%s \n", workflow_name );
printf("-----------------------------------------------------------------\n");
config_error_fprintf( ert_workflow_list_get_last_error( workflow_list ) , true , stdout);
printf("-----------------------------------------------------------------\n");
}
}
}
util_safe_free( workflow_name );
}
}
}
void enkf_tui_run_create_runpath__(void * __enkf_main) {
enkf_main_type * enkf_main = enkf_main_safe_cast(__enkf_main);
const int ens_size = enkf_main_get_ensemble_size( enkf_main );
bool_vector_type * iactive = bool_vector_alloc(0,false);
state_enum init_state = ANALYZED;
int start_report = 0;
int init_step_parameters = 0;
{
char * prompt = util_alloc_sprintf("Which realizations to create[ensemble size:%d] : " , ens_size);
char * select_string;
util_printf_prompt(prompt , PROMPT_LEN , '=' , "=> ");
select_string = util_alloc_stdin_line();
enkf_tui_util_sscanf_active_list( iactive , select_string , ens_size );
util_safe_free( select_string );
free( prompt );
}
enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state, true);
bool_vector_free(iactive);
}
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_mount_alt_fs( enkf_main , source_case , false );
enkf_fs_type * target_fs = enkf_main_mount_alt_fs( enkf_main , target_case , true );
stringlist_type * nodes = ensemble_config_alloc_keylist_from_var_type(config, PARAMETER);
{
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_fs_decref( src_fs );
enkf_fs_decref( target_fs );
msg_free(msg , true);
stringlist_free(nodes);
}
free( identity_permutation );
}
void enkf_tui_run_manual_load__( void * arg ) {
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
const int last_report = -1;
const int ens_size = enkf_main_get_ensemble_size( enkf_main );
int step1,step2;
bool_vector_type * iactive = bool_vector_alloc( 0 , false );
run_mode_type run_mode = ENSEMBLE_EXPERIMENT;
enkf_main_init_run(enkf_main , run_mode); /* This is ugly */
step1 = 0;
step2 = last_report; /** Observe that for the summary data it will load all the available data anyway. */
{
char * prompt = util_alloc_sprintf("Which realizations to load (Ex: 1,3-5) <Enter for all> [M to return to menu] : [ensemble size:%d] : " , ens_size);
char * select_string;
util_printf_prompt(prompt , PROMPT_LEN , '=' , "=> ");
select_string = util_alloc_stdin_line();
enkf_tui_util_sscanf_active_list( iactive , select_string , ens_size );
util_safe_free( select_string );
free( prompt );
}
if (bool_vector_count_equal( iactive , true )) {
int iens;
arg_pack_type ** arg_list = util_calloc( ens_size , sizeof * arg_list );
thread_pool_type * tp = thread_pool_alloc( 4 , true ); /* num_cpu - HARD coded. */
for (iens = 0; iens < ens_size; iens++) {
arg_pack_type * arg_pack = arg_pack_alloc();
arg_list[iens] = arg_pack;
if (bool_vector_iget(iactive , iens)) {
enkf_state_type * enkf_state = enkf_main_iget_state( enkf_main , iens );
arg_pack_append_ptr( arg_pack , enkf_state); /* 0: */
arg_pack_append_ptr( arg_pack , fs ); /* 1: */
arg_pack_append_int( arg_pack , step1 ); /* 2: This will be the load start parameter for the run_info struct. */
arg_pack_append_int( arg_pack , step1 ); /* 3: Step1 */
arg_pack_append_int( arg_pack , step2 ); /* 4: Step2 For summary data it will load the whole goddamn thing anyway.*/
arg_pack_append_bool( arg_pack , true ); /* 5: Interactive */
arg_pack_append_owned_ptr( arg_pack , stringlist_alloc_new() , stringlist_free__); /* 6: List of interactive mode messages. */
thread_pool_add_job( tp , enkf_state_load_from_forward_model_mt , arg_pack);
}
}
thread_pool_join( tp );
thread_pool_free( tp );
printf("\n");
{
qc_module_type * qc_module = enkf_main_get_qc_module( enkf_main );
runpath_list_type * runpath_list = qc_module_get_runpath_list( qc_module );
for (iens = 0; iens < ens_size; iens++) {
if (bool_vector_iget(iactive , iens)) {
const enkf_state_type * state = enkf_main_iget_state( enkf_main , iens );
runpath_list_add( runpath_list , iens , enkf_state_get_run_path( state ) , enkf_state_get_eclbase( state ));
}
}
qc_module_export_runpath_list( qc_module );
}
for (iens = 0; iens < ens_size; iens++) {
if (bool_vector_iget(iactive , iens)) {
stringlist_type * msg_list = arg_pack_iget_ptr( arg_list[iens] , 6 );
if (stringlist_get_size( msg_list ))
enkf_tui_display_load_msg( iens , msg_list );
}
}
for (iens = 0; iens < ens_size; iens++)
arg_pack_free( arg_list[iens]);
free( arg_list );
}
bool_vector_free( iactive );
}
void enkf_tui_run_manual_load__( void * arg ) {
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
const int ens_size = enkf_main_get_ensemble_size( enkf_main );
bool_vector_type * iactive = bool_vector_alloc( 0 , false );
run_mode_type run_mode = ENSEMBLE_EXPERIMENT;
int iter = 0;
enkf_main_init_run(enkf_main , iactive , run_mode , INIT_NONE); /* This is ugly */
{
char * prompt = util_alloc_sprintf("Which realizations to load (Ex: 1,3-5) <Enter for all> [M to return to menu] : [ensemble size:%d] : " , ens_size);
char * select_string;
util_printf_prompt(prompt , PROMPT_LEN , '=' , "=> ");
select_string = util_alloc_stdin_line();
enkf_tui_util_sscanf_active_list( iactive , select_string , ens_size );
util_safe_free( select_string );
free( prompt );
}
{
const model_config_type * model_config = enkf_main_get_model_config( enkf_main );
if (model_config_runpath_requires_iter( model_config )) {
const char * prompt = "Which iteration to load from [0...?) : ";
char * input;
bool OK;
util_printf_prompt(prompt , PROMPT_LEN , '=' , "=> ");
input = util_alloc_stdin_line();
if (input == NULL)
return;
OK = util_sscanf_int( input , &iter );
free( input );
if (!OK)
return;
}
}
if (bool_vector_count_equal( iactive , true )) {
stringlist_type ** realizations_msg_list = util_calloc( ens_size , sizeof * realizations_msg_list );
int iens = 0;
for (; iens < ens_size; ++iens) {
realizations_msg_list[iens] = stringlist_alloc_new();
}
enkf_main_load_from_forward_model(enkf_main, iter , iactive, realizations_msg_list);
{
qc_module_type * qc_module = enkf_main_get_qc_module( enkf_main );
runpath_list_type * runpath_list = qc_module_get_runpath_list( qc_module );
for (iens = 0; iens < ens_size; ++iens) {
if (bool_vector_iget(iactive , iens)) {
const enkf_state_type * state = enkf_main_iget_state( enkf_main , iens );
runpath_list_add( runpath_list , iens , enkf_state_get_run_path( state ) , enkf_state_get_eclbase( state ));
}
}
qc_module_export_runpath_list( qc_module );
}
for (iens = 0; iens < ens_size; ++iens) {
stringlist_type * msg_list = realizations_msg_list[iens];
if (bool_vector_iget(iactive, iens)) {
if (stringlist_get_size( msg_list )) {
enkf_tui_display_load_msg( iens , msg_list );
}
}
stringlist_free(msg_list);
}
free(realizations_msg_list);
}
bool_vector_free( iactive );
}
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);
}
