obs_vector_type * obs_vector_alloc_from_GENERAL_OBSERVATION(const conf_instance_type * conf_instance , const history_type * history, const ensemble_config_type * ensemble_config) { if(!conf_instance_is_of_class(conf_instance, "GENERAL_OBSERVATION")) util_abort("%s: internal error. expected \"GENERAL_OBSERVATION\" instance, got \"%s\".\n", __func__, conf_instance_get_class_name_ref(conf_instance) ); const char * obs_key = conf_instance_get_name_ref(conf_instance); const char * state_kw = conf_instance_get_item_value_ref( conf_instance, "DATA" ); if (ensemble_config_has_key( ensemble_config , state_kw )) { const char * obs_key = conf_instance_get_name_ref(conf_instance); int size = history_get_last_restart( history ); obs_vector_type * obs_vector = obs_vector_alloc( GEN_OBS , obs_key , ensemble_config_get_node(ensemble_config , state_kw ), size); int obs_restart_nr = __conf_instance_get_restart_nr(conf_instance , obs_key , history , size); const char * index_file = NULL; const char * index_list = NULL; const char * obs_file = NULL; const char * error_covar_file = NULL; if (conf_instance_has_item(conf_instance , "INDEX_FILE")) index_file = conf_instance_get_item_value_ref( conf_instance, "INDEX_FILE" ); if (conf_instance_has_item(conf_instance , "INDEX_LIST")) index_list = conf_instance_get_item_value_ref( conf_instance, "INDEX_LIST" ); if (conf_instance_has_item(conf_instance , "OBS_FILE")) obs_file = conf_instance_get_item_value_ref( conf_instance, "OBS_FILE" ); if (conf_instance_has_item(conf_instance , "ERROR_COVAR")) error_covar_file = conf_instance_get_item_value_ref( conf_instance, "ERROR_COVAR" ); { const enkf_config_node_type * config_node = ensemble_config_get_node( ensemble_config , state_kw); if (enkf_config_node_get_impl_type(config_node) == GEN_DATA) { double scalar_error = -1; double scalar_value = -1; gen_obs_type * gen_obs ; if (conf_instance_has_item(conf_instance , "VALUE")) { scalar_value = conf_instance_get_item_value_double(conf_instance , "VALUE"); scalar_error = conf_instance_get_item_value_double(conf_instance , "ERROR"); } /** The config system has ensured that we have either OBS_FILE or (VALUE and ERROR). */ gen_obs = gen_obs_alloc( enkf_config_node_get_ref( config_node ) , obs_key , obs_file , scalar_value , scalar_error , index_file , index_list , error_covar_file); obs_vector_install_node( obs_vector , obs_restart_nr , gen_obs ); } else { ert_impl_type impl_type = enkf_config_node_get_impl_type(config_node); util_abort("%s: %s has implementation type:\'%s\' - expected:\'%s\'.\n",__func__ , state_kw , enkf_types_get_impl_name(impl_type) , enkf_types_get_impl_name(GEN_DATA)); } } return obs_vector; } else { fprintf(stderr,"** Warning the ensemble key:%s does not exist - observation:%s not added \n", state_kw , obs_key); return NULL; } }
void ensemble_config_set_gen_kw_format( ensemble_config_type * ensemble_config , const char * gen_kw_format_string) { if (!util_string_equal( gen_kw_format_string , ensemble_config->gen_kw_format_string)) { stringlist_type * gen_kw_keys = ensemble_config_alloc_keylist_from_impl_type( ensemble_config , GEN_KW ); int i; ensemble_config->gen_kw_format_string = util_realloc_string_copy( ensemble_config->gen_kw_format_string , gen_kw_format_string ); for (i=0; i < stringlist_get_size( gen_kw_keys ); i++) { enkf_config_node_type * config_node = ensemble_config_get_node( ensemble_config , stringlist_iget( gen_kw_keys , i )); gen_kw_config_update_tag_format( enkf_config_node_get_ref( config_node ) , gen_kw_format_string ); } stringlist_free( gen_kw_keys ); } }
static void enkf_main_gen_data_special( enkf_main_type * enkf_main , enkf_fs_type * fs ) { stringlist_type * gen_data_keys = ensemble_config_alloc_keylist_from_impl_type( enkf_main->ensemble_config , GEN_DATA); for (int i=0; i < stringlist_get_size( gen_data_keys ); i++) { enkf_config_node_type * config_node = ensemble_config_get_node( enkf_main->ensemble_config , stringlist_iget( gen_data_keys , i)); gen_data_config_type * gen_data_config = enkf_config_node_get_ref( config_node ); if (gen_data_config_is_dynamic( gen_data_config )) gen_data_config_set_ens_size( gen_data_config , enkf_main->ens_size ); } stringlist_free( gen_data_keys ); }
void ensemble_config_update_custom_kw_config(ensemble_config_type * config, custom_kw_config_set_type * config_set) { stringlist_type * keys = custom_kw_config_set_get_keys_alloc(config_set); for(int i = 0; i < stringlist_get_size(keys); i++) { const char * key = stringlist_iget(keys, i); if(!ensemble_config_has_key(config, key)) { ensemble_config_add_custom_kw(config, key, NULL, NULL); printf("[%s] CustomKW key: '%s' not in ensemble! Adding from storage.\n", __func__, key); } enkf_config_node_type * config_node = ensemble_config_get_node(config, key); custom_kw_config_type * custom_kw_config = (custom_kw_config_type*) enkf_config_node_get_ref(config_node); custom_kw_config_set_update_config(config_set, custom_kw_config); } stringlist_free(keys); }
enkf_config_node_type * ensemble_config_add_summary(ensemble_config_type * ensemble_config , const char * key , load_fail_type load_fail) { enkf_config_node_type * config_node = NULL; if (hash_has_key(ensemble_config->config_nodes, key)) { config_node = hash_get(ensemble_config->config_nodes, key); if (enkf_config_node_get_impl_type( config_node ) != SUMMARY) { util_abort("%s: ensemble key:%s already exists - but it is not of summary type\n",__func__ , key); } summary_config_type * summary_config = enkf_config_node_get_ref( config_node ); summary_config_update_load_fail_mode( summary_config , load_fail ); } else { config_node = enkf_config_node_alloc_summary( key , load_fail); ensemble_config_add_node(ensemble_config , config_node ); } return config_node; }
enkf_config_node_type * ensemble_config_add_summary(ensemble_config_type * ensemble_config , const char * key , load_fail_type load_fail) { enkf_config_node_type * config_node = NULL; if (hash_has_key(ensemble_config->config_nodes, key)) { config_node = hash_get(ensemble_config->config_nodes, key); if (enkf_config_node_get_impl_type( config_node ) != SUMMARY) util_abort("%s: ensemble key:%s already exists - but it is not of summary type\n",__func__ , key); { summary_config_type * summary_config = enkf_config_node_get_ref( config_node ); summary_config_update_load_fail_mode( summary_config , load_fail ); } } else { if ((ensemble_config->refcase == NULL) || (ecl_sum_has_general_var( ensemble_config->refcase , key ))) { config_node = enkf_config_node_alloc_summary( key , load_fail); ensemble_config_add_node(ensemble_config , config_node ); } else fprintf(stderr,"** warning: the refcase:%s does not contain the summary key:\"%s\" - will be ignored.\n", ecl_sum_get_case( ensemble_config->refcase ) , key); } return config_node; }
obs_vector_type * obs_vector_alloc_from_BLOCK_OBSERVATION(const conf_instance_type * conf_instance , const ecl_grid_type * grid , const ecl_sum_type * refcase , const history_type * history, ensemble_config_type * ensemble_config) { if(!conf_instance_is_of_class(conf_instance, "BLOCK_OBSERVATION")) util_abort("%s: internal error. expected \"BLOCK_OBSERVATION\" instance, got \"%s\".\n", __func__, conf_instance_get_class_name_ref(conf_instance) ); block_obs_source_type source_type = SOURCE_SUMMARY; const char * obs_label = conf_instance_get_name_ref(conf_instance); const char * source_string = conf_instance_get_item_value_ref(conf_instance , "SOURCE"); const char * field_name = conf_instance_get_item_value_ref(conf_instance , "FIELD"); const char * sum_kw = NULL; bool OK = true; if (strcmp(source_string , "FIELD") == 0) { source_type = SOURCE_FIELD; if (!ensemble_config_has_key( ensemble_config , field_name)) { OK = false; fprintf(stderr,"** Warning the ensemble key:%s does not exist - observation:%s not added \n", field_name , obs_label); } } else if (strcmp( source_string , "SUMMARY") == 0) { source_type = SOURCE_SUMMARY; sum_kw = __summary_kw( field_name ); } else util_abort("%s: internal error \n",__func__); if (OK) { obs_vector_type * obs_vector = NULL; int size = history_get_last_restart( history ); int obs_restart_nr ; stringlist_type * summary_keys = stringlist_alloc_new(); stringlist_type * obs_pt_keys = conf_instance_alloc_list_of_sub_instances_of_class_by_name(conf_instance, "OBS"); int num_obs_pts = stringlist_get_size(obs_pt_keys); double * obs_value = util_calloc(num_obs_pts , sizeof * obs_value); double * obs_std = util_calloc(num_obs_pts , sizeof * obs_std ); int * obs_i = util_calloc(num_obs_pts , sizeof * obs_i ); int * obs_j = util_calloc(num_obs_pts , sizeof * obs_j ); int * obs_k = util_calloc(num_obs_pts , sizeof * obs_k ); obs_restart_nr = __conf_instance_get_restart_nr(conf_instance , obs_label , history , size); /** Build the observation. */ for(int obs_pt_nr = 0; obs_pt_nr < num_obs_pts; obs_pt_nr++) { const char * obs_key = stringlist_iget(obs_pt_keys, obs_pt_nr); const conf_instance_type * obs_instance = conf_instance_get_sub_instance_ref(conf_instance, obs_key); const char * error_mode = conf_instance_get_item_value_ref(obs_instance, "ERROR_MODE"); double error = conf_instance_get_item_value_double(obs_instance, "ERROR"); double value = conf_instance_get_item_value_double(obs_instance, "VALUE"); double min_error = conf_instance_get_item_value_double(obs_instance, "ERROR_MIN"); if (strcmp( error_mode , "REL") == 0) error *= value; else if (strcmp( error_mode , "RELMIN") == 0) error = util_double_max( error * value , min_error ); obs_value[obs_pt_nr] = value; obs_std [obs_pt_nr] = error; /** The input values i,j,k come from the user, and are offset 1. They are immediately shifted with -1 to become C-based offset zero. */ obs_i[obs_pt_nr] = conf_instance_get_item_value_int( obs_instance, "I") - 1; obs_j[obs_pt_nr] = conf_instance_get_item_value_int( obs_instance, "J") - 1; obs_k[obs_pt_nr] = conf_instance_get_item_value_int( obs_instance, "K") - 1; if (source_type == SOURCE_SUMMARY) { char * summary_key = smspec_alloc_block_ijk_key( SUMMARY_KEY_JOIN_STRING , sum_kw , obs_i[obs_pt_nr] + 1 , obs_j[obs_pt_nr] + 1 , obs_k[obs_pt_nr] + 1 ); stringlist_append_owned_ref( summary_keys , summary_key ); } } if (source_type == SOURCE_FIELD) { const enkf_config_node_type * config_node = ensemble_config_get_node( ensemble_config , field_name); const field_config_type * field_config = enkf_config_node_get_ref( config_node ); block_obs_type * block_obs = block_obs_alloc_complete(obs_label, source_type , NULL , field_config , grid , num_obs_pts, obs_i, obs_j, obs_k, obs_value, obs_std); if (block_obs != NULL) { obs_vector = obs_vector_alloc( BLOCK_OBS , obs_label , ensemble_config_get_node(ensemble_config , field_name), size ); obs_vector_install_node( obs_vector , obs_restart_nr , block_obs); } } else if (source_type == SOURCE_SUMMARY) { OK = true; if (refcase != NULL) { for (int i=0; i < stringlist_get_size( summary_keys ); i++) { const char * sum_key = stringlist_iget( summary_keys , i ); if (!ecl_sum_has_key(refcase , sum_key)) { /* If the */ fprintf(stderr,"** Warning missing summary %s for cell: (%d,%d,%d) in refcase - make sure that \"BPR %d %d %d\" is included in ECLIPSE summary specification \n" , sum_key , obs_i[i]+1 , obs_j[i]+1 , obs_k[i]+1 , obs_i[i]+1 , obs_j[i]+1 , obs_k[i]+1 ); //OK = false; } } } if (OK) { // We can create the container node and add the summary nodes. enkf_config_node_type * container_config = ensemble_config_add_container( ensemble_config , NULL ); for (int i=0; i < stringlist_get_size( summary_keys ); i++) { const char * sum_key = stringlist_iget( summary_keys , i ); enkf_config_node_type * child_node = ensemble_config_add_summary( ensemble_config , sum_key , LOAD_FAIL_WARN ); enkf_config_node_update_container( container_config , child_node ); } { block_obs_type * block_obs = block_obs_alloc_complete(obs_label, source_type , summary_keys , enkf_config_node_get_ref(container_config) , grid , num_obs_pts, obs_i, obs_j, obs_k, obs_value, obs_std); if (block_obs != NULL) { obs_vector = obs_vector_alloc( BLOCK_OBS , obs_label , container_config, size ); obs_vector_install_node( obs_vector , obs_restart_nr , block_obs); } } } } else util_abort("%s: invalid source value \n",__func__); free(obs_value); free(obs_std); free(obs_i); free(obs_j); free(obs_k); stringlist_free(obs_pt_keys); stringlist_free(summary_keys); return obs_vector; } else { fprintf(stderr,"** Warning the ensemble key:%s does not exist - observation:%s not added \n", field_name , obs_label); return NULL; } }
int main(int argc , char ** argv) { enkf_main_install_SIGNALS(); const char * config_file = argv[1]; const char * init_file = argv[2]; const char * key = "PORO"; int iens = 0; ert_test_context_type * test_context = ert_test_context_alloc("ExportInactiveCellsTest" , config_file); enkf_main_type * enkf_main = ert_test_context_get_main(test_context); enkf_fs_type * fs = enkf_main_get_fs(enkf_main); const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main); const enkf_config_node_type * config_node = ensemble_config_get_node(ensemble_config , key); const field_config_type * field_config = enkf_config_node_get_ref( config_node ); enkf_state_type * state = enkf_main_iget_state( enkf_main , iens ); enkf_node_type * field_node = enkf_state_get_node( state , key ); field_type * field = enkf_node_value_ptr(field_node); { forward_initialize_node(enkf_main, init_file, field_node); node_id_type node_id = {.report_step = 0 , .iens = iens , .state = BOTH }; test_assert_true(enkf_node_try_load(field_node , fs , node_id)); field_scale(field, 3.0); } int nx,ny,nz; field_config_get_dims(field_config , &nx , &ny , &nz); const char * export_file_grdecl = "my_test_dir/exported_field_test_file_grdecl"; const char * export_file_roff = "my_test_dir/exported_field_test_file_roff"; field_file_format_type file_type; char * found_init_file = enkf_main_alloc_abs_path_to_init_file(enkf_main, config_node); { file_type = ECL_GRDECL_FILE; field_export(field, export_file_grdecl, NULL, file_type, false, found_init_file); check_exported_data(export_file_grdecl, init_file, file_type, field_config, field, nx, ny, nz); } { file_type = RMS_ROFF_FILE; field_export(field, export_file_roff, NULL, file_type, false, found_init_file); check_exported_data(export_file_roff, init_file, file_type, field_config, field, nx, ny, nz); } free(found_init_file); found_init_file = NULL; { file_type = ECL_GRDECL_FILE; field_export(field, export_file_grdecl, NULL, file_type, false, found_init_file); check_exported_data(export_file_grdecl, found_init_file, file_type, field_config, field, nx, ny, nz); } { file_type = RMS_ROFF_FILE; field_export(field, export_file_roff, NULL, file_type, false, found_init_file); check_exported_data(export_file_roff, found_init_file, file_type, field_config, field, nx, ny, nz); } ert_test_context_free(test_context); exit(0); }
void enkf_node_alloc_domain_object(enkf_node_type * node) { if (node->data != NULL) node->freef( node->data ); node->data = node->alloc(enkf_config_node_get_ref(node->config)); }
bool enkf_plot_gen_kw_should_use_log_scale(const enkf_plot_gen_kw_type * gen_kw , int index) { const gen_kw_config_type * gen_kw_config = enkf_config_node_get_ref( gen_kw->config_node ); return gen_kw_config_should_use_log_scale(gen_kw_config, index); }
int enkf_plot_gen_kw_get_keyword_count( const enkf_plot_gen_kw_type * gen_kw ){ const gen_kw_config_type * gen_kw_config = enkf_config_node_get_ref( gen_kw->config_node ); return gen_kw_config_get_data_size(gen_kw_config); }
const char * enkf_plot_gen_kw_iget_key( const enkf_plot_gen_kw_type * plot_gen_kw, int index) { const gen_kw_config_type * gen_kw_config = enkf_config_node_get_ref( plot_gen_kw->config_node ); return gen_kw_config_iget_name( gen_kw_config , index ); }