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