void gen_kw_read_from_buffer(gen_kw_type * gen_kw , buffer_type * buffer, int report_step, state_enum state) { const int data_size = gen_kw_config_get_data_size( gen_kw->config ); ert_impl_type file_type; file_type = buffer_fread_int(buffer); if ((file_type == GEN_KW) || (file_type == MULTFLT)) buffer_fread(buffer , gen_kw->data , sizeof *gen_kw->data , data_size); }
void gen_kw_copy(const gen_kw_type * src , gen_kw_type * target) { if (src->config == target->config) { int buffer_size = gen_kw_config_get_data_size( src->config ) * sizeof src->data; memcpy( target->data , src->data , buffer_size ); } else util_abort("%s: two elements do not share config object \n",__func__); }
gen_kw_type * gen_kw_alloc(const gen_kw_config_type * config) { gen_kw_type * gen_kw = util_malloc(sizeof *gen_kw ); gen_kw->__type_id = GEN_KW; gen_kw->config = config; gen_kw->subst_list = subst_list_alloc( NULL ); gen_kw->data = util_calloc( gen_kw_config_get_data_size( config ) , sizeof * gen_kw->data ); return gen_kw; }
void gen_kw_fload(gen_kw_type * gen_kw , const char * filename) { const int size = gen_kw_config_get_data_size(gen_kw->config ); FILE * stream = util_fopen( filename , "r"); bool readOK = true; /* First try reading all the data as one long vector. */ { int index = 0; while ((index < size) && readOK) { double value; if (fscanf(stream,"%lg" , &value) == 1) gen_kw->data[index] = value; else readOK = false; index++; } } /* OK - rewind and try again with interlaced key + value pairs. Observe that we still require that ALL the elements in the gen_kw instance are set, i.e. it is not allowed to read only some of the keywords; but the ordering is not relevant. The code will be fooled (and give undefined erronous results) if the same key appears several times. Be polite! */ if (!readOK) { int counter = 0; readOK = true; fseek( stream , 0 , SEEK_SET ); while ((counter < size) && readOK) { char key[128]; double value; int fscanf_return = fscanf(stream , "%s %lg" , key , &value); if (fscanf_return == 2) { int index = gen_kw_config_get_index(gen_kw->config , key); if (index >= 0) gen_kw->data[index] = value; else util_abort("%s: key:%s not recognized as part of GEN_KW instance - error when reading file:%s \n",__func__ , key , filename); counter++; } else { util_abort("%s: failed to read (key,value) pair at line:%d in file:%s \n",__func__ , util_get_current_linenr( stream ) , filename); readOK = false; } } } if (!readOK) util_abort("%s: failed loading from file:%s \n",__func__ , filename); fclose(stream); }
void gen_kw_set_inflation(gen_kw_type * inflation , const gen_kw_type * std , const gen_kw_type * min_std) { const int data_size = gen_kw_config_get_data_size(std->config ); const double * std_data = std->data; const double * min_std_data = min_std->data; double * inflation_data = inflation->data; { for (int i=0; i < data_size; i++) { if (std_data[i] > 0) inflation_data[i] = util_double_max( 1.0 , min_std_data[i] / std_data[i]); else inflation_data[i] = 1; } } }
bool gen_kw_initialize(gen_kw_type *gen_kw , int iens , const char * init_file , rng_type * rng ) { if (init_file != NULL) gen_kw_fload(gen_kw , init_file ); else { const double mean = 0.0; /* Mean and std are hardcoded - the variability should be in the transformation. */ const double std = 1.0; const int data_size = gen_kw_config_get_data_size( gen_kw->config ); int i; for (i=0; i < data_size; i++) gen_kw->data[i] = enkf_util_rand_normal(mean , std , rng); } return true; }
double gen_kw_data_iget( gen_kw_type * gen_kw, int index , bool do_transform ) { double value; int size = gen_kw_config_get_data_size( gen_kw->config ); if (( index < 0 ) || ( index >= size )) util_abort( "%s: index:%d invalid. Valid interval: [0,%d>.\n" , __func__ , index , size ); if (do_transform) { value = gen_kw_config_transform(gen_kw->config, index, gen_kw->data[index]); } else { value = gen_kw->data[index]; } return value; }
/** Will return -1 if the index is invalid. */ int gen_kw_config_get_index(const gen_kw_config_type * config , const char * key) { const int size = gen_kw_config_get_data_size(config); bool have_key = false; int index = 0; while (index < size && !have_key) { const gen_kw_parameter_type * parameter = vector_iget_const( config->parameters , index ); if (strcmp(parameter->name , key) == 0) have_key = true; else index++; } if (have_key) return index; else return -1; }
bool gen_kw_initialize(gen_kw_type *gen_kw , int iens , const char * init_file , rng_type * rng ) { if (!init_file && !rng) util_abort("%s internal error: both init_file and rng are NULL", __func__); bool ret = false; if (init_file) ret = gen_kw_fload(gen_kw , init_file ); else { const double mean = 0.0; /* Mean and std are hardcoded - the variability should be in the transformation. */ const double std = 1.0; const int data_size = gen_kw_config_get_data_size( gen_kw->config ); int i; for (i=0; i < data_size; i++) gen_kw->data[i] = enkf_util_rand_normal(mean , std , rng); ret = true; } return ret; }
void gen_kw_filter_file(const gen_kw_type * gen_kw , const char * target_file) { const char * template_file = gen_kw_config_get_template_file(gen_kw->config); if (template_file != NULL) { const int size = gen_kw_config_get_data_size(gen_kw->config ); int ikw; for (ikw = 0; ikw < size; ikw++) { const char * key = gen_kw_config_get_tagged_name(gen_kw->config , ikw); subst_list_append_owned_ref(gen_kw->subst_list , key , util_alloc_sprintf("%g" , gen_kw_config_transform( gen_kw->config , ikw , gen_kw->data[ikw] )) , NULL); } /* If the target_file already exists as a symbolic link the symbolic link is removed before creating the target file. The is to ensure against existing symlinks pointing to a common file outside the realization root. */ if (util_is_link( target_file )) remove( target_file ); subst_list_filter_file( gen_kw->subst_list , template_file , target_file); } else util_abort("%s: internal error - tried to filter gen_kw instance without template file.\n",__func__); }
int gen_kw_data_size( gen_kw_type * gen_kw ) { return gen_kw_config_get_data_size( gen_kw->config ); }
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); }
void gen_kw_clear(gen_kw_type * gen_kw) { int i; for (i=0; i < gen_kw_config_get_data_size( gen_kw->config ); i++) gen_kw->data[i] = 0.0; }
void gen_kw_isqrt( gen_kw_type * gen_kw ) { const int data_size = gen_kw_config_get_data_size( gen_kw->config ); for(int i=0; i < data_size; i++) gen_kw->data[i] = sqrt( gen_kw->data[i] ); }
void gen_kw_scale( gen_kw_type * gen_kw , double scale_factor) { const int data_size = gen_kw_config_get_data_size( gen_kw->config ); for(int i=0; i < data_size; i++) gen_kw->data[i] *= scale_factor; }
void gen_kw_imul( gen_kw_type * gen_kw , const gen_kw_type * delta) { const int data_size = gen_kw_config_get_data_size( gen_kw->config ); for(int i=0; i < data_size; i++) gen_kw->data[i] *= delta->data[i]; }
void gen_kw_iaddsqr( gen_kw_type * gen_kw , const gen_kw_type * delta) { const int data_size = gen_kw_config_get_data_size( gen_kw->config ); for(int i=0; i < data_size; i++) gen_kw->data[i] += (delta->data[i] * delta->data[i]); }
bool gen_kw_write_to_buffer(const gen_kw_type *gen_kw , buffer_type * buffer, int report_step, state_enum state) { const int data_size = gen_kw_config_get_data_size( gen_kw->config ); buffer_fwrite_int( buffer , GEN_KW ); buffer_fwrite(buffer , gen_kw->data , sizeof *gen_kw->data , data_size); return true; }
void gen_kw_deserialize(gen_kw_type *gen_kw , node_id_type node_id , const active_list_type * active_list , const matrix_type * A , int row_offset , int column) { const int data_size = gen_kw_config_get_data_size( gen_kw->config ); enkf_matrix_deserialize( gen_kw->data , data_size , ECL_DOUBLE_TYPE , active_list , A , row_offset , column); }