static void gen_data_ecl_write_ASCII(const gen_data_type * gen_data , const char * file , gen_data_file_format_type export_format) {
FILE * stream = util_fopen(file , "w");
char * template_buffer;
int template_data_offset, template_buffer_size , template_data_skip;
if (export_format == ASCII_TEMPLATE) {
gen_data_config_get_template_data( gen_data->config , &template_buffer , &template_data_offset , &template_buffer_size , &template_data_skip);
util_fwrite( template_buffer , 1 , template_data_offset , stream , __func__);
}
{
ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data->config);
const int size = gen_data_config_get_data_size( gen_data->config , gen_data->current_report_step );
int i;
if (internal_type == ECL_FLOAT_TYPE) {
float * float_data = (float *) gen_data->data;
for (i=0; i < size; i++)
fprintf(stream , "%g\n",float_data[i]);
} else if (internal_type == ECL_DOUBLE_TYPE) {
double * double_data = (double *) gen_data->data;
for (i=0; i < size; i++)
fprintf(stream , "%lg\n",double_data[i]);
} else
util_abort("%s: internal error - wrong type \n",__func__);
}
if (export_format == ASCII_TEMPLATE) {
int new_offset = template_data_offset + template_data_skip;
util_fwrite( &template_buffer[new_offset] , 1 , template_buffer_size - new_offset , stream , __func__);
}
fclose(stream);
}
void gen_data_serialize(const gen_data_type * gen_data , node_id_type node_id , const active_list_type * active_list , matrix_type * A , int row_offset , int column) {
const gen_data_config_type *config = gen_data->config;
const int data_size = gen_data_config_get_data_size( gen_data->config , gen_data->current_report_step );
ecl_type_enum ecl_type = gen_data_config_get_internal_type( config );
enkf_matrix_serialize( gen_data->data , data_size , ecl_type , active_list , A , row_offset , column );
}
void gen_data_export_data(const gen_data_type * gen_data , double_vector_type * export_data) {
ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data->config);
if (internal_type == ECL_DOUBLE_TYPE)
double_vector_memcpy_from_data( export_data , (const double *) gen_data->data , gen_data_get_size( gen_data ));
else {
double_vector_reset( export_data );
float * float_data = (float *) gen_data->data;
for (int i = 0; i < gen_data_get_size( gen_data ); i++)
double_vector_iset( export_data , i , float_data[i]);
}
}
bool gen_data_fload_with_report_step( gen_data_type * gen_data , const char * filename , int report_step) {
bool has_file = util_file_exists(filename);
void * buffer = NULL;
int size = 0;
ecl_type_enum load_type;
if ( has_file ) {
ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data->config);
gen_data_file_format_type input_format = gen_data_config_get_input_format( gen_data->config );
buffer = gen_common_fload_alloc( filename , input_format , internal_type , &load_type , &size);
/*
Look for file @filename_active - if that file is found it is
interpreted as a an active|inactive mask created by the forward
model.
The file is assumed to be an ASCII file with integers, 0
indicates inactive elements and 1 active elements. The file
should of course be as long as @filename.
If the file is not found the gen_data->active_mask is set to
all-true (i.e. the default true value is invoked).
*/
if (gen_data_config_is_dynamic( gen_data->config )) {
bool_vector_reset( gen_data->active_mask );
bool_vector_iset( gen_data->active_mask , size - 1, true );
{
char * active_file = util_alloc_sprintf("%s_active" , filename );
if (util_file_exists( active_file )) {
FILE * stream = util_fopen( active_file , "r");
int active_int;
for (int index=0; index < size; index++) {
if (fscanf( stream , "%d" , &active_int) == 1) {
if (active_int == 1)
bool_vector_iset( gen_data->active_mask , index , true);
else if (active_int == 0)
bool_vector_iset( gen_data->active_mask , index , false);
else
util_abort("%s: error when loading active mask from:%s only 0 and 1 allowed \n",__func__ , active_file);
} else
util_abort("%s: error when loading active mask from:%s - file not long enough.\n",__func__ , active_file );
}
fclose( stream );
}
free( active_file );
}
}
}
gen_data_set_data__(gen_data , size , report_step , load_type , buffer );
util_safe_free(buffer);
return has_file;
}
double gen_data_iget_double(const gen_data_type * gen_data, int index) {
gen_data_assert_index(gen_data , index);
{
ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data->config);
if (internal_type == ECL_DOUBLE_TYPE) {
double * data = (double *) gen_data->data;
return data[index];
} else {
float * data = (float *) gen_data->data;
return data[index];
}
}
}
void gen_data_isqrt(gen_data_type * gen_data) {
const int data_size = gen_data_config_get_data_size( gen_data->config , gen_data->current_report_step );
const ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data->config);
if (internal_type == ECL_FLOAT_TYPE) {
float * data = (float *) gen_data->data;
for (int i=0; i < data_size; i++)
data[i] = sqrtf( data[i] );
} else if (internal_type == ECL_DOUBLE_TYPE) {
double * data = (double *) gen_data->data;
for (int i=0; i < data_size; i++)
data[i] = sqrt( data[i] );
}
}
void gen_data_read_from_buffer(gen_data_type * gen_data , buffer_type * buffer , int report_step, state_enum state) {
int size;
enkf_util_assert_buffer_type(buffer , GEN_DATA);
size = buffer_fread_int(buffer);
buffer_fskip_int( buffer ); /* Skipping report_step from the buffer - was a mistake to store it - I think ... */
{
size_t byte_size = size * ecl_util_get_sizeof_ctype( gen_data_config_get_internal_type ( gen_data->config ));
size_t compressed_size = buffer_get_remaining_size( buffer );
gen_data->data = util_realloc( gen_data->data , byte_size );
buffer_fread_compressed( buffer , compressed_size , gen_data->data , byte_size );
}
gen_data_assert_size( gen_data , size , report_step );
gen_data_config_load_active( gen_data->config , report_step , false );
}
void gen_data_copy_to_double_vector(const gen_data_type * gen_data , double_vector_type * vector){
const ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data->config);
int size = gen_data_get_size( gen_data );
if (internal_type == ECL_FLOAT_TYPE) {
float * data = (float *) gen_data->data;
double_vector_reset(vector);
for (int i = 0; i < size; i++){
double_vector_append(vector , data[i]);
}
} else if (internal_type == ECL_DOUBLE_TYPE) {
double * data = (double *) gen_data->data;
double_vector_memcpy_from_data( vector , data , size );
}
}
void gen_data_scale(gen_data_type * gen_data, double scale_factor) {
//gen_data_config_assert_unary(gen_data->config, __func__);
{
const int data_size = gen_data_config_get_data_size( gen_data->config , gen_data->current_report_step );
const ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data->config);
int i;
if (internal_type == ECL_FLOAT_TYPE) {
float * data = (float *) gen_data->data;
for (i = 0; i < data_size; i++)
data[i] *= scale_factor;
} else if (internal_type == ECL_DOUBLE_TYPE) {
double * data = (double *) gen_data->data;
for (i = 0; i < data_size; i++)
data[i] *= scale_factor;
}
}
}
void gen_data_set_inflation(gen_data_type * inflation , const gen_data_type * std , const gen_data_type * min_std) {
const gen_data_config_type * config = inflation->config;
ecl_type_enum ecl_type = gen_data_config_get_internal_type( config );
const int data_size = gen_data_config_get_data_size( std->config , std->current_report_step );
if (ecl_type == ECL_FLOAT_TYPE) {
float * inflation_data = (float *) inflation->data;
const float * std_data = (const float *) std->data;
const float * min_std_data = (const float *) min_std->data;
INFLATE(inflation_data , std_data , min_std_data );
} else {
double * inflation_data = (double *) inflation->data;
const double * std_data = (const double *) std->data;
const double * min_std_data = (const double *) min_std->data;
INFLATE(inflation_data , std_data , min_std_data );
}
}
void gen_data_iaddsqr(gen_data_type * gen_data1, const gen_data_type * gen_data2) {
//gen_data_config_assert_binary(gen_data1->config , gen_data2->config , __func__);
{
const int data_size = gen_data_config_get_data_size( gen_data1->config , gen_data1->current_report_step );
const ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data1->config);
int i;
if (internal_type == ECL_FLOAT_TYPE) {
float * data1 = (float *) gen_data1->data;
const float * data2 = (const float *) gen_data2->data;
for (i = 0; i < data_size; i++)
data1[i] += data2[i] * data2[i];
} else if (internal_type == ECL_DOUBLE_TYPE) {
double * data1 = (double *) gen_data1->data;
const double * data2 = (const double *) gen_data2->data;
for (i = 0; i < data_size; i++)
data1[i] += data2[i] * data2[i];
}
}
}
bool gen_data_fload_with_report_step( gen_data_type * gen_data , const char * filename , int report_step) {
bool file_exists = util_file_exists(filename);
void * buffer = NULL;
int size = 0;
ecl_type_enum load_type;
if ( file_exists ) {
ecl_type_enum internal_type = gen_data_config_get_internal_type(gen_data->config);
gen_data_file_format_type input_format = gen_data_config_get_input_format( gen_data->config );
buffer = gen_common_fload_alloc( filename , input_format , internal_type , &load_type , &size);
if (size > 0) {
gen_data_fload_active__(gen_data, filename, size);
} else {
bool_vector_reset( gen_data->active_mask );
}
gen_data_set_data__(gen_data , size , report_step , load_type , buffer );
util_safe_free(buffer);
}
return file_exists;
}
static void gen_data_set_data__(gen_data_type * gen_data , int size, int report_step , ecl_type_enum load_type , const void * data) {
gen_data_assert_size(gen_data , size, report_step);
if (gen_data_config_is_dynamic( gen_data->config ))
gen_data_config_update_active( gen_data->config , report_step , gen_data->active_mask);
gen_data_realloc_data(gen_data);
if (size > 0) {
ecl_type_enum internal_type = gen_data_config_get_internal_type( gen_data->config );
int byte_size = ecl_util_get_sizeof_ctype( internal_type ) * size ;
if (load_type == internal_type)
memcpy(gen_data->data , data , byte_size );
else {
if (load_type == ECL_FLOAT_TYPE)
util_float_to_double((double *) gen_data->data , data , size);
else
util_double_to_float((float *) gen_data->data , data , size);
}
}
}
