void test_trace_edge( const ecl_grid_type * grid) { const int k = 1; fault_block_layer_type * layer = fault_block_layer_alloc( grid , k ); double_vector_type * x_list = double_vector_alloc( 0,0); double_vector_type * y_list = double_vector_alloc( 0,0); fault_block_type * block = fault_block_layer_safe_get_block( layer , 99); int_vector_type * cell_list = int_vector_alloc(0,0); test_assert_false( fault_block_trace_edge( block , x_list , y_list , cell_list)); fault_block_add_cell( block , 0,0); test_assert_true( fault_block_trace_edge( block , x_list , y_list , cell_list)); test_assert_int_equal( 4 , double_vector_size( x_list )); test_assert_int_equal( 4 , double_vector_size( y_list )); test_assert_double_equal( 0 , double_vector_iget( x_list , 0 )); test_assert_double_equal( 1 , double_vector_iget( x_list , 1 )); test_assert_double_equal( 1 , double_vector_iget( x_list , 2 )); test_assert_double_equal( 0 , double_vector_iget( x_list , 3 )); test_assert_double_equal( 0 , double_vector_iget( y_list , 0 )); test_assert_double_equal( 0 , double_vector_iget( y_list , 1 )); test_assert_double_equal( 1 , double_vector_iget( y_list , 2 )); test_assert_double_equal( 1 , double_vector_iget( y_list , 3 )); test_assert_int_equal( 1 , int_vector_size( cell_list )); test_assert_int_equal( 0 , int_vector_iget( cell_list , 0)); int_vector_free( cell_list ); double_vector_free( x_list ); double_vector_free( y_list ); }
void test_approx_equal() { double_vector_type * d1 = double_vector_alloc(0,0); double_vector_type * d2 = double_vector_alloc(0,0); double_vector_type * d3 = double_vector_alloc(0,0); double_vector_append( d1 , 1.0 ); double_vector_append( d1 , 2.0 ); double_vector_append( d1 , 3.0 ); double_vector_append( d2 , 1.0 ); double_vector_append( d2 , 2.0 ); test_assert_false( double_vector_approx_equal( d1 , d2 ,1e-6)); double_vector_append( d2 , 3.0 ); test_assert_true( double_vector_approx_equal( d1 , d2 ,1e-6)); double_vector_append( d3 , 1.0 ); double_vector_append( d3 , 2.0 ); double_vector_append( d3 , 3.0 ); double_vector_scale( d3 , 1 + 1e-6 ); test_assert_true( double_vector_approx_equal( d1 , d3 ,1e-4)); test_assert_false( double_vector_approx_equal( d1 , d3 ,1e-8)); double_vector_free(d1); double_vector_free(d2); double_vector_free(d3); }
int enkf_config_node_load_obs( const enkf_config_node_type * config_node , enkf_obs_type * enkf_obs ,const char * key_index , int obs_count , time_t * _sim_time , double * _y , double * _std) { ert_impl_type impl_type = enkf_config_node_get_impl_type(config_node); int num_obs = 0; int iobs; for (iobs = 0; iobs < stringlist_get_size( config_node->obs_keys ); iobs++) { obs_vector_type * obs_vector = enkf_obs_get_vector( enkf_obs , stringlist_iget( config_node->obs_keys , iobs)); int report_step = -1; while (true) { report_step = obs_vector_get_next_active_step( obs_vector , report_step); if (report_step == -1) break; { bool valid; double value , std1; /** The user index used when calling the user_get function on the gen_obs data type is different depending on whether is called with a data context user_key (as here) or with a observation context user_key (as when plotting an observation plot). See more documentation of the function gen_obs_user_get_data_index(). */ if (impl_type == GEN_DATA) gen_obs_user_get_with_data_index( obs_vector_iget_node( obs_vector , report_step ) , key_index , &value , &std1 , &valid); else obs_vector_user_get( obs_vector , key_index , report_step , &value , &std1 , &valid); if (valid) { if (obs_count > 0) { _sim_time[num_obs] = enkf_obs_iget_obs_time( enkf_obs , report_step ); _y[num_obs] = value; _std[num_obs] = std1; } num_obs++; } } } } /* Sorting the observations in time order. */ if (obs_count > 0) { double_vector_type * y = double_vector_alloc_shared_wrapper( 0 , 0 , _y , obs_count ); double_vector_type * std = double_vector_alloc_shared_wrapper( 0 , 0 , _std , obs_count ); time_t_vector_type * sim_time = time_t_vector_alloc_shared_wrapper( 0 , 0 , _sim_time , obs_count ); int * sort_perm = time_t_vector_alloc_sort_perm( sim_time ); time_t_vector_permute( sim_time , sort_perm ); double_vector_permute( y , sort_perm ); double_vector_permute( std , sort_perm ); free( sort_perm ); double_vector_free( y ); double_vector_free( std ); time_t_vector_free( sim_time ); } return num_obs; }
void well_rate_free( well_rate_type * well_rate ) { free( well_rate->name ); double_vector_free( well_rate->shift ); double_vector_free( well_rate->mean_shift ); double_vector_free( well_rate->std_shift ); double_vector_free( well_rate->base_value ); bool_vector_free( well_rate->percent_std ); free( well_rate ); }
void group_rate_free( group_rate_type * group_rate ) { free( group_rate->name ); double_vector_free( group_rate->shift ); double_vector_free( group_rate->base_rate ); double_vector_free( group_rate->min_shift ); double_vector_free( group_rate->max_shift ); vector_free( group_rate->well_rates ); free( group_rate ); }
int ecl_sum_data_get_report_step_from_days(const ecl_sum_data_type * data , double sim_days) { if ((sim_days < data->days_start) || (sim_days > data->sim_length)) return -1; else { int report_step = -1; double_vector_type * days_map = double_vector_alloc( 0 , 0 ); int_vector_type * report_map = int_vector_alloc( 0 , 0 ); int i; for (i=1; i < int_vector_size( data->report_last_index ); i++) { int ministep_index = int_vector_iget( data->report_last_index , i ); const ecl_sum_tstep_type * ministep = vector_iget_const( data->data , ministep_index ); double_vector_iset( days_map , i , ecl_sum_tstep_get_sim_days( ministep )); int_vector_iset( report_map , i , ecl_sum_tstep_get_report( ministep )); } { /** Hmmmm - double == comparison ... */ int index = double_vector_index_sorted( days_map , sim_days ); if (index >= 0) report_step = int_vector_iget( report_map , index ); } int_vector_free( report_map ); double_vector_free( days_map ); return report_step; } }
void test_content() { rng_type * rng = rng_alloc(MZRAN , INIT_DEFAULT); matrix_type * PC = matrix_alloc( 3 , 10); matrix_type * PC_obs = matrix_alloc( 3 , 1 ); double_vector_type * singular_values = double_vector_alloc(3 , 1); matrix_random_init( PC , rng ); matrix_random_init( PC_obs , rng ); { pca_plot_data_type * data = pca_plot_data_alloc("KEY" , PC , PC_obs, singular_values); for (int i=0; i < matrix_get_rows( PC ); i++) { const pca_plot_vector_type * vector = pca_plot_data_iget_vector( data , i ); test_assert_double_equal( matrix_iget( PC_obs , i , 0) , pca_plot_vector_get_obs_value( vector ) ); test_assert_double_equal( double_vector_iget( singular_values , i), pca_plot_vector_get_singular_value( vector ) ); for (int j=0; j < matrix_get_columns( PC ); j++) test_assert_double_equal( matrix_iget( PC , i , j ) , pca_plot_vector_iget_sim_value( vector , j )); test_assert_int_equal( matrix_get_columns( PC ) , pca_plot_vector_get_size( vector )); } pca_plot_data_free( data ); } double_vector_free( singular_values ); matrix_free( PC ); matrix_free( PC_obs ); }
void data_ranking_free( data_ranking_type * ranking ) { double_vector_free( ranking->data_ensemble ); bool_vector_free( ranking->valid ); util_safe_free( ranking->sort_permutation ); util_safe_free( ranking->user_key ); free( ranking ); }
void test_insert_double() { double_vector_type * vec = double_vector_alloc(0,0); double_vector_append( vec , 1 ); double_vector_insert( vec , 0 , 0 ); test_assert_double_equal( 0 , double_vector_iget( vec , 0 )); test_assert_double_equal( 1 , double_vector_iget( vec , 1 )); double_vector_free( vec ); }
pca_plot_data_type * create_data() { matrix_type * PC = matrix_alloc( 3 , 10); matrix_type * PC_obs = matrix_alloc( 3 , 1 ); double_vector_type * singular_values = double_vector_alloc(3 , 1); pca_plot_data_type * data = pca_plot_data_alloc("KEY" , PC , PC_obs , singular_values); double_vector_free( singular_values ); matrix_free( PC ); matrix_free( PC_obs ); return data; }
void test_update_vector() { plot_range_type * range = plot_range_alloc(); double_vector_type * xl = double_vector_alloc(0,0); double_vector_type * yl = double_vector_alloc(0,0); const int N = 100; int i; for (i=0; i < N; i++) { double x = 2*3.14159265 * i / (N - 1); double_vector_append( xl , sin(x)); double_vector_append( yl , cos(x)); } plot_range_update_vector( range , xl , yl ); test_assert_double_equal( plot_range_get_current_xmin( range ) , -1 ); test_assert_double_equal( plot_range_get_current_xmax( range ) , 1 ); test_assert_double_equal( plot_range_get_current_ymin( range ) , -1 ); test_assert_double_equal( plot_range_get_current_ymax( range ) , 1 ); for (i=0; i < N; i++) { double x = 2*3.14159265 * i / (N - 1); double_vector_append( xl , 2*sin(x)); double_vector_append( yl , 2*cos(x)); } plot_range_update_vector_x( range , xl ); plot_range_update_vector_y( range , yl ); test_assert_double_equal( plot_range_get_current_xmin( range ) , -2 ); test_assert_double_equal( plot_range_get_current_xmax( range ) , 2 ); test_assert_double_equal( plot_range_get_current_ymin( range ) , -2 ); test_assert_double_equal( plot_range_get_current_ymax( range ) , 2 ); plot_range_free( range ); double_vector_free( xl ); double_vector_free( yl ); }
time_t_vector_type * ecl_sum_alloc_time_solution( const ecl_sum_type * ecl_sum , const char * gen_key , double cmp_value , bool rates_clamp_lower) { time_t_vector_type * solution = time_t_vector_alloc( 0 , 0); { double_vector_type * seconds = ecl_sum_alloc_seconds_solution( ecl_sum , gen_key , cmp_value , rates_clamp_lower ); time_t start_time = ecl_sum_get_start_time(ecl_sum); for (int i=0; i < double_vector_size( seconds ); i++) { time_t t = start_time; util_inplace_forward_seconds( &t , double_vector_iget( seconds , i )); time_t_vector_append( solution , t ); } double_vector_free( seconds ); } return solution; }
void test_create_vector() { matrix_type * PC = matrix_alloc( 3 , 10); matrix_type * PC_obs = matrix_alloc( 3 , 1 ); double_vector_type * singular_values = double_vector_alloc(3 , 1); { pca_plot_vector_type * vector = pca_plot_vector_alloc(0 , PC , PC_obs, singular_values); test_assert_true( pca_plot_vector_is_instance( vector )); pca_plot_vector_free( vector ); } double_vector_free( singular_values ); matrix_free( PC ); matrix_free( PC_obs ); }
void test_range_fill_double() { double_vector_type * double_vector = double_vector_alloc(0,0); double_vector_range_fill( double_vector , 1,2,10 ); /* 1 , 3 , 5 , 7 , 9 */ test_assert_double_equal( double_vector_size( double_vector ), 5); test_assert_double_equal( double_vector_iget( double_vector , 0 ) , 1 ); test_assert_double_equal( double_vector_iget( double_vector , 1 ) , 3 ); test_assert_double_equal( double_vector_iget( double_vector , 2 ) , 5 ); test_assert_double_equal( double_vector_iget( double_vector , 3 ) , 7 ); test_assert_double_equal( double_vector_iget( double_vector , 4 ) , 9 ); double_vector_range_fill( double_vector , 3,3,9 ); /* 3,6,9 */ test_assert_double_equal( double_vector_size( double_vector ), 3); test_assert_double_equal( double_vector_iget( double_vector , 0 ) , 3 ); test_assert_double_equal( double_vector_iget( double_vector , 1 ) , 6 ); test_assert_double_equal( double_vector_iget( double_vector , 2 ) , 9 ); double_vector_free( double_vector ); }
void test_create_data() { matrix_type * PC = matrix_alloc( 3 , 10); matrix_type * PC_obs = matrix_alloc( 3 , 1 ); double_vector_type * singular_values = double_vector_alloc(3 , 1); { pca_plot_data_type * data = pca_plot_data_alloc("KEY" , PC , PC_obs , singular_values); test_assert_true( pca_plot_data_is_instance( data )); test_assert_int_equal( 3 , pca_plot_data_get_size( data )); test_assert_int_equal( 10 , pca_plot_data_get_ens_size( data )); test_assert_string_equal( "KEY" , pca_plot_data_get_name( data )); pca_plot_data_free( data ); } matrix_resize( PC , 4 , 10 , false); test_assert_NULL( pca_plot_data_alloc( "KEY" , PC , PC_obs , singular_values)); matrix_resize( PC_obs , 3 , 2 , false); test_assert_NULL( pca_plot_data_alloc( "KEY" , PC , PC_obs , singular_values)); double_vector_free( singular_values ); matrix_free( PC ); matrix_free( PC_obs ); }
static void misfit_ts_free( misfit_ts_type * misfit_ts) { double_vector_free( misfit_ts->data ); free( misfit_ts ); }
bool obs_vector_load_from_HISTORY_OBSERVATION(obs_vector_type * obs_vector , const conf_instance_type * conf_instance , const history_type * history , ensemble_config_type * ensemble_config, double std_cutoff ) { if(!conf_instance_is_of_class(conf_instance, "HISTORY_OBSERVATION")) util_abort("%s: internal error. expected \"HISTORY_OBSERVATION\" instance, got \"%s\".\n",__func__, conf_instance_get_class_name_ref(conf_instance) ); { bool initOK = false; int size , restart_nr; double_vector_type * value = double_vector_alloc(0,0); double_vector_type * std = double_vector_alloc(0,0); bool_vector_type * valid = bool_vector_alloc(0 , false); /* The auto_corrf parameters can not be "segmentized" */ double auto_corrf_param = -1; const char * auto_corrf_name = NULL; double error = conf_instance_get_item_value_double(conf_instance, "ERROR" ); double error_min = conf_instance_get_item_value_double(conf_instance, "ERROR_MIN" ); const char * error_mode = conf_instance_get_item_value_ref( conf_instance, "ERROR_MODE"); const char * sum_key = conf_instance_get_name_ref( conf_instance ); if(conf_instance_has_item(conf_instance, "AUTO_CORRF")) { auto_corrf_name = conf_instance_get_item_value_ref( conf_instance , "AUTO_CORRF"); auto_corrf_param = conf_instance_get_item_value_double(conf_instance, "AUTO_CORRF_PARAM"); if(conf_instance_has_item(conf_instance, "AUTO_CORRF_PARAM")) auto_corrf_param = conf_instance_get_item_value_double(conf_instance, "AUTO_CORRF_PARAM"); else util_abort("%s: When specifying AUTO_CORRF you must also give a vlaue for AUTO_CORRF_PARAM",__func__); } // Get time series data from history object and allocate size = history_get_last_restart(history); if (history_init_ts( history , sum_key , value , valid )) { // Create the standard deviation vector if(strcmp(error_mode, "ABS") == 0) { for( restart_nr = 0; restart_nr < size; restart_nr++) double_vector_iset( std , restart_nr , error ); } else if(strcmp(error_mode, "REL") == 0) { for( restart_nr = 0; restart_nr < size; restart_nr++) double_vector_iset( std , restart_nr , error * abs( double_vector_iget( value , restart_nr ))); } else if(strcmp(error_mode, "RELMIN") == 0) { for(restart_nr = 0; restart_nr < size; restart_nr++) { double tmp_std = util_double_max( error_min , error * abs( double_vector_iget( value , restart_nr ))); double_vector_iset( std , restart_nr , tmp_std); } } else util_abort("%s: Internal error. Unknown error mode \"%s\"\n", __func__, error_mode); // Handle SEGMENTs which can be used to customize the observation error. */ { stringlist_type * segment_keys = conf_instance_alloc_list_of_sub_instances_of_class_by_name(conf_instance, "SEGMENT"); stringlist_sort( segment_keys , NULL ); int num_segments = stringlist_get_size(segment_keys); for(int segment_nr = 0; segment_nr < num_segments; segment_nr++) { const char * segment_name = stringlist_iget(segment_keys, segment_nr); const conf_instance_type * segment_conf = conf_instance_get_sub_instance_ref(conf_instance, segment_name); int start = conf_instance_get_item_value_int( segment_conf, "START" ); int stop = conf_instance_get_item_value_int( segment_conf, "STOP" ); double error_segment = conf_instance_get_item_value_double(segment_conf, "ERROR" ); double error_min_segment = conf_instance_get_item_value_double(segment_conf, "ERROR_MIN" ); const char * error_mode_segment = conf_instance_get_item_value_ref( segment_conf, "ERROR_MODE"); if(start < 0) { printf("%s: WARNING - Segment out of bounds. Truncating start of segment to 0.\n", __func__); start = 0; } if(stop >= size) { printf("%s: WARNING - Segment out of bounds. Truncating end of segment to %d.\n", __func__, size - 1); stop = size -1; } if(start > stop) { printf("%s: WARNING - Segment start after stop. Truncating end of segment to %d.\n", __func__, start ); stop = start; } // Create the standard deviation vector if(strcmp(error_mode_segment, "ABS") == 0) { for( restart_nr = start; restart_nr <= stop; restart_nr++) double_vector_iset( std , restart_nr , error_segment) ; } else if(strcmp(error_mode_segment, "REL") == 0) { for( restart_nr = start; restart_nr <= stop; restart_nr++) double_vector_iset( std , restart_nr , error_segment * abs(double_vector_iget( value , restart_nr))); } else if(strcmp(error_mode_segment, "RELMIN") == 0) { for(restart_nr = start; restart_nr <= stop ; restart_nr++) { double tmp_std = util_double_max( error_min_segment , error_segment * abs( double_vector_iget( value , restart_nr ))); double_vector_iset( std , restart_nr , tmp_std); } } else util_abort("%s: Internal error. Unknown error mode \"%s\"\n", __func__, error_mode); } stringlist_free(segment_keys); } /* This is where the summary observations are finally added. */ for (restart_nr = 0; restart_nr < size; restart_nr++) { if (bool_vector_safe_iget( valid , restart_nr)) { if (double_vector_iget( std , restart_nr) > std_cutoff) { obs_vector_add_summary_obs( obs_vector , restart_nr , sum_key , sum_key , double_vector_iget( value ,restart_nr) , double_vector_iget( std , restart_nr ) , auto_corrf_name , auto_corrf_param); } else fprintf(stderr,"** Warning: to small observation error in observation %s:%d - ignored. \n", sum_key , restart_nr); } } initOK = true; } double_vector_free(std); double_vector_free(value); bool_vector_free(valid); return initOK; } }
void sum_case_free( sum_case_type * sum_case) { ecl_sum_free( sum_case->ecl_sum ); double_vector_free( sum_case->interp_data ); free( sum_case ); }
void geo_polygon_free( geo_polygon_type * polygon ) { double_vector_free( polygon->xcoord ); double_vector_free( polygon->ycoord ); free( polygon ); }
void geo_polygon_free( geo_polygon_type * polygon ) { double_vector_free( polygon->xcoord ); double_vector_free( polygon->ycoord ); util_safe_free( polygon->name ); free( polygon ); }
void misfit_ranking_free( misfit_ranking_type * misfit_ranking ) { vector_free( misfit_ranking->ensemble ); double_vector_free( misfit_ranking->total ); util_safe_free( misfit_ranking->sort_permutation ); free( misfit_ranking ); }
void summary_free(summary_type *summary) { double_vector_free( summary->forecast_vector ); double_vector_free( summary->analyzed_vector ); free(summary->data); free(summary); }