void enkf_tui_fs_initialize_case_for_predictions(void * arg)
{
int prompt_len = 35;
char source_case[256];
int report_step_from;
int report_step_to;
state_enum state_from;
state_enum state_to;
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
state_from = ANALYZED;
state_to = ANALYZED;
report_step_from = enkf_main_get_history_length( enkf_main );
report_step_to = enkf_main_get_history_length( enkf_main );
{
char * target_case = util_alloc_string_copy( NULL );
util_printf_prompt("Source case" , prompt_len , '=' , "=> ");
fgets(source_case, prompt_len, stdin);
char *newline = strchr(source_case,'\n');
if(newline)
*newline = 0;
if(strlen(source_case) !=0)
enkf_tui_fs_copy_ensemble__(enkf_main, source_case, target_case, report_step_from, state_from, report_step_to, state_to, false);
free(target_case);
}
}
void enkf_tui_fs_initialize_case_from_copy(void * arg)
{
int prompt_len =50;
char * source_case;
int ens_size;
int last_report;
int src_step;
state_enum src_state;
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
ens_size = enkf_main_get_ensemble_size( enkf_main );
last_report = enkf_main_get_history_length( enkf_main );
source_case = enkf_tui_fs_alloc_existing_case( enkf_main , "Initialize from case" , prompt_len);
if (source_case != NULL) {
src_step = util_scanf_int_with_limits("Source report step",prompt_len , 0 , last_report);
src_state = enkf_tui_util_scanf_state("Source analyzed/forecast [A|F]" , prompt_len , false);
enkf_fs_type * source_fs = enkf_main_mount_alt_fs( enkf_main , source_case , false );
enkf_main_init_current_case_from_existing(enkf_main, source_fs , src_step , src_state);
enkf_fs_decref(source_fs);
}
util_safe_free( source_case );
}
void enkf_tui_run_restart__(void * enkf_main) {
const int ens_size = enkf_main_get_ensemble_size( enkf_main );
const int last_report = enkf_main_get_history_length( enkf_main );
int start_report;
char * start_report_as_char;
bool wronginput = false;
state_enum state;
bool_vector_type * iactive = bool_vector_alloc(0,true);
bool_vector_iset( iactive , ens_size - 1 , true );
start_report_as_char = util_scanf_int_with_limits_return_char("Report step",PROMPT_LEN , 0 , last_report);
if(strlen(start_report_as_char) != 0){
util_sscanf_int(start_report_as_char , &start_report);
}
else
wronginput = true;
if(!wronginput){
state = enkf_tui_util_scanf_state("Analyzed/forecast" , PROMPT_LEN , false);
if(state == UNDEFINED)
wronginput = true;
}
if(!wronginput)
enkf_main_run_assimilation(enkf_main , iactive , start_report , start_report , state);
bool_vector_free(iactive);
free(start_report_as_char);
}
void enkf_tui_fs_initialize_case_from_copy(void * arg)
{
int prompt_len =50;
char * source_case;
int ens_size;
int last_report;
int src_step;
state_enum src_state;
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
ens_size = enkf_main_get_ensemble_size( enkf_main );
last_report = enkf_main_get_history_length( enkf_main );
source_case = enkf_tui_fs_alloc_existing_case( enkf_main , "Initialize from case" , prompt_len);
if (source_case != NULL) {
char * ranking_key = NULL;
bool_vector_type * iens_mask = bool_vector_alloc( 0 , true );
src_step = util_scanf_int_with_limits("Source report step",prompt_len , 0 , last_report);
src_state = enkf_tui_util_scanf_state("Source analyzed/forecast [A|F]" , prompt_len , false);
enkf_main_initialize_from_existing( enkf_main , source_case , src_step , src_state , iens_mask , ranking_key );
bool_vector_free( iens_mask );
}
util_safe_free( source_case );
}
void * enkf_main_rank_on_observations_JOB(void * self, const stringlist_type * args) {
enkf_main_type * enkf_main = enkf_main_safe_cast( self );
const char * ranking_name = stringlist_iget(args, 0);
bool step_arguments = false;
bool obs_arguments = false;
int delimiter = 0;
{
delimiter = stringlist_find_first(args, "|");
if (delimiter > -1) {
step_arguments = (delimiter > 1) ? true : false;
obs_arguments = (stringlist_get_size(args) > delimiter + 1) ? true : false;
} else if (stringlist_get_size(args) > 1) {
step_arguments = true;
delimiter = stringlist_get_size(args);
}
}
int_vector_type * steps_vector = NULL;
{
char * report_steps = NULL;
if (step_arguments)
report_steps = stringlist_alloc_joined_substring(args, 1, delimiter, ",");
else
report_steps = util_alloc_sprintf("0-%d", enkf_main_get_history_length(enkf_main));
steps_vector = string_util_alloc_value_list(report_steps);
free(report_steps);
}
stringlist_type * obs_ranking_keys = NULL;
{
char * obs_key_char = NULL;
if (obs_arguments)
obs_key_char = stringlist_alloc_joined_substring( args , delimiter+1 , stringlist_get_size(args) , " ");
enkf_obs_type * enkf_obs = enkf_main_get_obs(enkf_main);
obs_ranking_keys = enkf_obs_alloc_matching_keylist( enkf_obs , obs_key_char );
if ((obs_arguments) && (stringlist_get_size(obs_ranking_keys) == 0)) {
fprintf(stderr,"The input string : \"%s\" did not resolve to any valid observation keys. Job not started\n", obs_key_char);
return NULL;
}
if (obs_arguments)
free(obs_key_char);
}
enkf_main_rank_on_observations(enkf_main, ranking_name, obs_ranking_keys, steps_vector);
stringlist_free(obs_ranking_keys);
int_vector_free(steps_vector);
return NULL;
}
void enkf_tui_export_fieldP(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 = enkf_tui_util_scanf_key(ensemble_config , PROMPT_LEN , FIELD , INVALID_VAR );
int iens1 = 0;
int iens2 = enkf_main_get_ensemble_size( enkf_main );
const int last_report = enkf_main_get_history_length( enkf_main );
int report_step = util_scanf_int_with_limits("Report step: ", PROMPT_LEN , 0 , last_report);
double lower_limit = util_scanf_double("Lower limit", PROMPT_LEN);
double upper_limit = util_scanf_double("Upper limit", PROMPT_LEN);
char * export_file;
util_printf_prompt("Filename to store file: " , PROMPT_LEN , '=' , "=> ");
export_file = util_alloc_stdin_line();
{
enkf_fs_type * fs = enkf_main_tui_get_fs(enkf_main);
enkf_node_type ** ensemble = enkf_node_load_alloc_ensemble( config_node , fs , report_step , iens1 , iens2 );
enkf_node_type * sum = enkf_node_alloc( config_node );
int active_ens_size = 0;
int iens;
enkf_node_clear( sum );
{
/* OK going low level */
field_type * sum_field = (field_type *) enkf_node_value_ptr( sum );
for (iens = iens1; iens < iens2; iens++) {
if (ensemble[iens - iens1] != NULL) {
field_type * field = (field_type *) enkf_node_value_ptr( ensemble[iens - iens1] );
field_update_sum( sum_field , field , lower_limit , upper_limit);
active_ens_size++;
}
}
if (active_ens_size > 0) {
field_scale( sum_field , 1.0 / active_ens_size );
{
char * path;
util_alloc_file_components( export_file , &path , NULL , NULL);
if (path != NULL) {
util_make_path( path );
free( path );
}
}
field_export(sum_field , export_file , NULL , RMS_ROFF_FILE , false, NULL);
} else fprintf(stderr,"Warning: no data found \n");
}
for (iens = iens1; iens < iens2; iens++) {
if (ensemble[iens - iens1] != NULL)
enkf_node_free( ensemble[iens - iens1] );
}
free( ensemble );
enkf_node_free( sum );
}
free( export_file );
}
void enkf_tui_run_one_more_iteration(void * arg){
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
const ecl_config_type * ecl_config = enkf_main_get_ecl_config( enkf_main );
const int last_report = enkf_main_get_history_length( enkf_main );
int step2;
if (ecl_config_has_schedule( ecl_config ))
step2 = util_scanf_int_with_limits("Last report",PROMPT_LEN , 0 , last_report);
else
step2 = last_report;
enkf_main_run_one_more_iteration(enkf_main, step2);
}
void enkf_tui_export_gen_data(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);
{
int report_step;
int iens1 , iens2;
const int last_report = enkf_main_get_history_length( enkf_main );
const enkf_config_node_type * config_node;
path_fmt_type * file_fmt;
config_node = enkf_tui_util_scanf_key(ensemble_config , PROMPT_LEN , GEN_DATA , INVALID_VAR);
report_step = util_scanf_int_with_limits("Report step: ", PROMPT_LEN , 0 , last_report);
enkf_tui_util_scanf_iens_range("Realizations members to export(0 - %d)" , enkf_main_get_ensemble_size( enkf_main ) , PROMPT_LEN , &iens1 , &iens2);
{
char path_fmt[512];
util_printf_prompt("Filename to store files in (with %d) in: " , PROMPT_LEN , '=' , "=> ");
scanf("%s" , path_fmt);
file_fmt = path_fmt_alloc_path_fmt( path_fmt );
}
{
enkf_fs_type * fs = enkf_main_tui_get_fs(enkf_main);
enkf_node_type * node = enkf_node_alloc(config_node);
gen_data_file_format_type export_type = gen_data_guess_export_type( (const gen_data_type *) enkf_node_value_ptr(node) );
int iens;
for (iens = iens1; iens <= iens2; iens++) {
node_id_type node_id = {.report_step = report_step , .iens = iens};
if (enkf_node_try_load(node , fs, node_id)) {
char * full_path = path_fmt_alloc_path( file_fmt , false , iens);
char * path;
util_alloc_file_components(full_path , &path , NULL , NULL);
if (path != NULL) util_make_path( path );
{
const gen_data_type * gen_data = (const gen_data_type *) enkf_node_value_ptr(node);
gen_data_export(gen_data , full_path , export_type);
}
free(full_path);
free(path);
}
}
enkf_node_free(node);
}
}
}
void enkf_tui_export_field(const enkf_main_type * enkf_main , field_file_format_type file_type) {
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
const bool output_transform = true;
const enkf_config_node_type * config_node;
const int last_report = enkf_main_get_history_length( enkf_main );
int iens1 , iens2 , iens , report_step;
path_fmt_type * export_path;
config_node = enkf_tui_util_scanf_key(ensemble_config , PROMPT_LEN , FIELD , INVALID_VAR );
report_step = util_scanf_int_with_limits("Report step: ", PROMPT_LEN , 0 , last_report);
enkf_tui_util_scanf_iens_range("Realizations members to export(0 - %d)" , enkf_main_get_ensemble_size( enkf_main ) , PROMPT_LEN , &iens1 , &iens2);
{
char * path_fmt;
util_printf_prompt("Filename to store files in (with %d) in: " , PROMPT_LEN , '=' , "=> ");
path_fmt = util_alloc_stdin_line();
export_path = path_fmt_alloc_path_fmt( path_fmt );
free( path_fmt );
}
{
enkf_fs_type * fs = enkf_main_tui_get_fs(enkf_main);
enkf_node_type * node = enkf_node_alloc(config_node);
for (iens = iens1; iens <= iens2; iens++) {
node_id_type node_id = {.report_step = report_step , .iens = iens };
if (enkf_node_try_load(node , fs , node_id)) {
char * filename = path_fmt_alloc_path( export_path , false , iens);
{
char * path;
util_alloc_file_components(filename , &path , NULL , NULL);
if (path != NULL) {
util_make_path( path );
free( path );
}
}
{
const field_type * field = (const field_type *) enkf_node_value_ptr(node);
field_export(field , filename , NULL , file_type , output_transform, NULL);
}
free(filename);
} else
printf("Warning: could not load realization:%d \n", iens);
}
enkf_node_free(node);
}
}
void * enkf_main_init_misfit_table_JOB(void * self, const stringlist_type * args) {
enkf_main_type * enkf_main = enkf_main_safe_cast( self );
int history_length = enkf_main_get_history_length(enkf_main);
enkf_obs_type * enkf_obs = enkf_main_get_obs(enkf_main);
int ens_size = enkf_main_get_ensemble_size(enkf_main);
enkf_fs_type * fs = enkf_main_get_fs(enkf_main);
bool force_update = true;
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs );
misfit_ensemble_initialize( misfit_ensemble , ensemble_config , enkf_obs , fs , ens_size , history_length, force_update);
return NULL;
}
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);
}
static void enkf_tui_ranking_create_obs( void * arg ) {
enkf_main_type * enkf_main = enkf_main_safe_cast( arg );
enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs );
if (!misfit_ensemble_initialized( misfit_ensemble )) {
fprintf(stderr,"Sorry: must initialzie the misfit table first \n");
return;
} else {
ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main );
const int history_length = enkf_main_get_history_length( enkf_main );
const int prompt_len = 50;
const char * prompt1 = "Observations to use for ranking";
const char * prompt2 = "Name to store ranking under";
const char * store_prompt = "Name of file to store ranking";
int step1,step2;
stringlist_type * ranking_keys;
char * obs_keys_input;
char * ranking_key;
char * ranking_file;
util_printf_prompt(prompt1 , prompt_len , '=' , "=> ");
obs_keys_input = util_alloc_stdin_line();
ranking_keys = enkf_obs_alloc_matching_keylist( enkf_obs , obs_keys_input );
enkf_tui_util_scanf_report_steps(history_length , prompt_len , &step1 , &step2);
util_printf_prompt(prompt2 , prompt_len , '=' , "=> ");
ranking_key = util_alloc_stdin_line();
if (ranking_key == NULL)
ranking_key = util_alloc_string_copy( MISFIT_DEFAULT_RANKING_KEY );
util_printf_prompt(store_prompt , prompt_len , '=' , "=> ");
ranking_file = util_alloc_stdin_line();
if (stringlist_get_size( ranking_keys ) > 0) {
ranking_table_add_misfit_ranking( ranking_table , misfit_ensemble , ranking_keys , step1 , step2 , ranking_key );
ranking_table_display_ranking( ranking_table , ranking_key);
} else
fprintf(stderr,"The input string : \"%s\" did not resolve to any valid observation keys \n", obs_keys_input);
free( obs_keys_input );
stringlist_free( ranking_keys );
free( ranking_key );
util_safe_free( ranking_file );
}
}
static void enkf_tui_ranking_make_misfit_ensemble( void * arg) {
arg_pack_type * arg_pack = arg_pack_safe_cast( arg );
enkf_main_type * enkf_main = arg_pack_iget_ptr( arg_pack , 0 );
enkf_fs_type * fs = enkf_main_get_fs(enkf_main);
enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main );
const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
const int history_length = enkf_main_get_history_length( enkf_main );
const int ens_size = enkf_main_get_ensemble_size( enkf_main );
misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs );
misfit_ensemble_update( misfit_ensemble , ensemble_config , enkf_obs , fs , ens_size , history_length );
{
menu_item_type * obs_item = arg_pack_iget_ptr( arg_pack , 1 );
menu_item_enable( obs_item );
}
}
void * enkf_main_rank_on_data_JOB(void * self, const stringlist_type * args) {
enkf_main_type * enkf_main = enkf_main_safe_cast( self );
const char * ranking_name = stringlist_iget(args, 0);
const char * data_key = stringlist_iget(args, 1);
bool valid = true;
bool sort_increasing = stringlist_iget_as_bool(args, 2, &valid);
if (!valid) {
fprintf(stderr,"** Third argument \"sort increasing\" not recognized as bool value, job not started\n");
return NULL;
}
int report_step = (stringlist_get_size(args) > 3) ? stringlist_iget_as_int(args, 3, &valid) : enkf_main_get_history_length(enkf_main) ;
if (!valid) {
fprintf(stderr,"** Fourth argument \"step\" not recognized as integer value, job not started\n");
return NULL;
}
if (report_step < 0) {
fprintf(stderr,"** Negative report step, job not started\n");
return NULL;
}
enkf_main_rank_on_data(enkf_main, ranking_name, data_key, sort_increasing, report_step);
return NULL;
}
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);
}
