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);
}
