void ensemble_config_init_SUMMARY( ensemble_config_type * ensemble_config , const config_type * config , const ecl_sum_type * refcase) {
const config_content_item_type * item = config_get_content_item( config , SUMMARY_KEY );
if (item != NULL) {
int i;
for (i=0; i < config_content_item_get_size( item ); i++) {
const config_content_node_type * node = config_content_item_iget_node( item , i );
int j;
for (j= 0; j < config_content_node_get_size( node ); j++) {
const char * key = config_content_node_iget( node , j );
if (util_string_has_wildcard( key )) {
if (ensemble_config->refcase != NULL) {
int k;
stringlist_type * keys = stringlist_alloc_new ( );
ecl_sum_select_matching_general_var_list( ensemble_config->refcase , key , keys ); /* expanding the wildcard notatition with help of the refcase. */
for (k=0; k < stringlist_get_size( keys ); k++)
ensemble_config_add_summary(ensemble_config , stringlist_iget(keys , k) , LOAD_FAIL_SILENT );
stringlist_free( keys );
} else
util_exit("error: when using summary wildcards like: \"%s\" you must supply a valid refcase.\n",key);
} else
ensemble_config_add_summary(ensemble_config , key , LOAD_FAIL_SILENT);
}
}
}
}
void ensemble_config_init_SUMMARY( ensemble_config_type * ensemble_config , const config_content_type * config , const ecl_sum_type * refcase) {
if (config_content_has_item(config , SUMMARY_KEY)) {
const config_content_item_type * item = config_content_get_item( config , SUMMARY_KEY );
int i;
for (i=0; i < config_content_item_get_size( item ); i++) {
const config_content_node_type * node = config_content_item_iget_node( item , i );
int j;
for (j= 0; j < config_content_node_get_size( node ); j++) {
const char * key = config_content_node_iget( node , j );
summary_key_matcher_add_summary_key(ensemble_config->summary_key_matcher, key);
if (util_string_has_wildcard( key )) {
//todo: DEPRECATED. In the Future the matcher should take care of this.
if (ensemble_config->refcase != NULL) {
int k;
stringlist_type * keys = stringlist_alloc_new ( );
ecl_sum_select_matching_general_var_list( ensemble_config->refcase , key , keys ); /* expanding the wildcard notation with help of the refcase. */
for (k=0; k < stringlist_get_size( keys ); k++)
ensemble_config_add_summary(ensemble_config , stringlist_iget(keys , k) , LOAD_FAIL_SILENT );
stringlist_free( keys );
}
} else
ensemble_config_add_summary(ensemble_config , key , LOAD_FAIL_SILENT);
}
}
}
}
enkf_config_node_type * ensemble_config_add_summary_observation(ensemble_config_type * ensemble_config , const char * key , load_fail_type load_fail) {
enkf_config_node_type * config_node = ensemble_config_add_summary(ensemble_config, key, load_fail);
summary_key_matcher_add_summary_key(ensemble_config->summary_key_matcher, key);
return config_node;
}
enkf_config_node_type * ensemble_config_get_or_create_summary_node(ensemble_config_type * ensemble_config, const char * key) {
if (!hash_has_key(ensemble_config->config_nodes , key)) {
ensemble_config_add_summary(ensemble_config, key, LOAD_FAIL_SILENT);
}
return ensemble_config_get_node(ensemble_config, key);
}
static void enkf_main_update_summary_config_from_fs__(enkf_main_type * enkf_main, enkf_fs_type * fs) {
ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main);
summary_key_set_type * summary_key_set = enkf_fs_get_summary_key_set(fs);
stringlist_type * keys = summary_key_set_get_keys(summary_key_set);
for(int i = 0; i < stringlist_get_size(keys); i++) {
const char * key = stringlist_iget(keys, i);
ensemble_config_add_summary(ensemble_config, key, LOAD_FAIL_SILENT);
}
}
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;
}
}
