static void data_ranking_init(data_ranking_type * ranking ,
enkf_fs_type * fs ,
enkf_config_node_type * config_node,
const char * key_index ,
int step ,
state_enum state ) {
enkf_node_type * enkf_node = enkf_node_alloc( config_node );
int iens;
for (iens = 0; iens < ranking->ens_size; iens++) {
double value;
node_id_type node_id = {.report_step = step ,
.iens = iens ,
.state = state
};
if (enkf_node_user_get( enkf_node , fs , key_index , node_id , &value)) {
double_vector_iset( ranking->data_ensemble , iens , value );
bool_vector_iset( ranking->valid , iens , true );
}
}
if (ranking->sort_increasing)
ranking->sort_permutation = double_vector_alloc_sort_perm( ranking->data_ensemble );
else
ranking->sort_permutation = double_vector_alloc_rsort_perm( ranking->data_ensemble );
enkf_node_free( enkf_node );
}
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 );
}
double obs_vector_chi2(const obs_vector_type * obs_vector , enkf_fs_type * fs , node_id_type node_id) {
enkf_node_type * enkf_node = enkf_node_alloc( obs_vector->config_node );
double chi2 = 0;
if (enkf_node_try_load( enkf_node , fs , node_id))
chi2 = obs_vector_chi2__(obs_vector , node_id.report_step , enkf_node , node_id);
enkf_node_free( enkf_node );
return chi2;
}
enkf_node_type * enkf_node_copyc(const enkf_node_type * enkf_node) {
FUNC_ASSERT(enkf_node->copy);
{
const enkf_node_type * src = enkf_node;
enkf_node_type * target;
target = enkf_node_alloc(src->config);
src->copy( src->data , target->data ); /* Calling the low level copy function */
return target;
}
}
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_config_node_update_min_std( enkf_config_node_type * config_node , const char * min_std_file ) {
if (!util_string_equal( config_node->min_std_file , min_std_file )) {
/* The current min_std_file and the new input are different, and
the min_std node must be cleared. */
if (config_node->min_std != NULL) {
enkf_node_free( config_node->min_std );
config_node->min_std = NULL;
free( config_node->min_std_file );
}
}
config_node->min_std_file = util_realloc_string_copy( config_node->min_std_file , min_std_file );
if (config_node->min_std_file != NULL) {
config_node->min_std = enkf_node_alloc( config_node );
enkf_node_fload( config_node->min_std , min_std_file );
}
}
void obs_vector_ensemble_chi2(const obs_vector_type * obs_vector ,
enkf_fs_type * fs,
bool_vector_type * valid ,
int step1 ,
int step2 ,
int iens1 ,
int iens2 ,
state_enum load_state ,
double ** chi2) {
int step;
enkf_node_type * enkf_node = enkf_node_alloc( obs_vector->config_node );
node_id_type node_id;
node_id.state = load_state;
for (step = step1; step <= step2; step++) {
int iens;
node_id.report_step = step;
{
void * obs_node = vector_iget( obs_vector->nodes , step);
if (obs_node == NULL) {
for (iens = iens1; iens < iens2; iens++)
chi2[step][iens] = 0;
} else {
for (iens = iens1; iens < iens2; iens++) {
node_id.iens = iens;
if (enkf_node_try_load( enkf_node , fs , node_id))
chi2[step][iens] = obs_vector_chi2__(obs_vector , step , enkf_node , node_id);
else {
chi2[step][iens] = 0;
// Missing data - this member will be marked as invalid in the misfit calculations.
bool_vector_iset( valid , iens , false );
}
}
}
}
}
enkf_node_free( enkf_node );
}
double obs_vector_total_chi2(const obs_vector_type * obs_vector , enkf_fs_type * fs , int iens, state_enum load_state) {
int report_step;
double sum_chi2 = 0;
enkf_node_type * enkf_node = enkf_node_alloc( obs_vector->config_node );
node_id_type node_id = {.report_step = 0, .iens = iens , .state = load_state };
for (report_step = 0; report_step < vector_get_size( obs_vector->nodes ); report_step++) {
if (vector_iget(obs_vector->nodes , report_step) != NULL) {
node_id.report_step = report_step;
if (enkf_node_try_load( enkf_node , fs , node_id))
sum_chi2 += obs_vector_chi2__(obs_vector , report_step , enkf_node, node_id);
}
}
enkf_node_free( enkf_node );
return sum_chi2;
}
/**
This function will sum up all timesteps of the obs_vector, for all ensemble members.
*/
void obs_vector_ensemble_total_chi2(const obs_vector_type * obs_vector , enkf_fs_type * fs , int ens_size , state_enum load_state , double * sum_chi2) {
const bool verbose = true;
msg_type * msg;
int report_step;
int iens;
char * msg_text = NULL;
for (iens = 0; iens < ens_size; iens++)
sum_chi2[iens] = 0;
if (verbose) {
msg = msg_alloc("Observation: " , false);
msg_show(msg);
}
{
node_id_type node_id = {.report_step = 0, .iens = iens , .state = load_state };
enkf_node_type * enkf_node = enkf_node_alloc( obs_vector->config_node );
for (report_step = 0; report_step < vector_get_size( obs_vector->nodes); report_step++) {
if (verbose) {
msg_text = util_realloc_sprintf( msg_text , "%s[%03d]" , obs_vector->obs_key , report_step);
msg_update(msg , msg_text);
}
if (vector_iget(obs_vector->nodes , report_step) != NULL) {
node_id.report_step = report_step;
for (iens = 0; iens < ens_size; iens++) {
node_id.iens = iens;
if (enkf_node_try_load( enkf_node , fs , node_id))
sum_chi2[iens] += obs_vector_chi2__(obs_vector , report_step , enkf_node, node_id);
}
}
}
enkf_node_free( enkf_node );
}
if (verbose) {
msg_free(msg , true);
util_safe_free( msg_text );
}
}
const char * obs_vector_get_obs_key( const obs_vector_type * obs_vector) {
return obs_vector->obs_key;
}
/*****************************************************************/
VOID_FREE(obs_vector)
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);
}