/** Will return NULL if the block which is asked for is not present. */ static file_map_type * file_map_alloc_blockmap(const file_map_type * file_map , const char * header, int occurence) { if (file_map_get_num_named_kw( file_map , header ) > occurence) { file_map_type * block_map = file_map_alloc( file_map->fortio , file_map->flags , file_map->inv_map , false); if (file_map_has_kw( file_map , header )) { int kw_index = file_map_get_global_index( file_map , header , occurence ); ecl_file_kw_type * file_kw = vector_iget( file_map->kw_list , kw_index ); while (true) { file_map_add_kw( block_map , file_kw ); kw_index++; if (kw_index == vector_get_size( file_map->kw_list )) break; else { file_kw = vector_iget(file_map->kw_list , kw_index); if (strcmp( header , ecl_file_kw_get_header( file_kw )) == 0) break; } } } file_map_make_index( block_map ); return block_map; } else return NULL; }
void misfit_ranking_fprintf( const misfit_ranking_type * misfit_ranking , const char * filename) { FILE * stream = util_mkdir_fopen( filename , "w"); const int ens_size = misfit_ranking->ens_size; const int * permutations = misfit_ranking->sort_permutation; double summed_up = 0.0; { // All this whitespace is finely tuned and highly significant .... const char * key_fmt = " %18s "; const char * value_fmt = " %10.3f %8.3f"; const char * start_fmt = " %2d %3d %7.3f %8.3f"; hash_type * obs_hash = vector_iget( misfit_ranking->ensemble , 0); stringlist_type * obs_keys = hash_alloc_stringlist( obs_hash ); int num_obs = stringlist_get_size( obs_keys ); int iobs; int num_obs_total = num_obs * ens_size; stringlist_sort( obs_keys , enkf_util_compare_keys__ ); fprintf(stream , " Overall "); for (iobs =0; iobs < num_obs; iobs++) fprintf(stream , key_fmt , stringlist_iget( obs_keys , iobs )); fprintf(stream , "\n"); fprintf(stream , " # Realization Norm Total"); for (iobs =0; iobs < num_obs; iobs++) fprintf(stream , " Norm Total"); fprintf(stream , "\n"); for (int i = 0; i < ens_size; i++) { int iens = permutations[i]; hash_type * obs_hash = vector_iget( misfit_ranking->ensemble , iens ); double total_value = double_vector_iget( misfit_ranking->total , iens ); double normalized_misfit = sqrt(total_value / num_obs_total); summed_up = summed_up+total_value; fprintf(stream , start_fmt , i , iens , normalized_misfit , total_value); for (iobs =0; iobs < num_obs; iobs++){ double single_value = hash_get_double( obs_hash , stringlist_iget( obs_keys , iobs )); double single_value_normalized = sqrt(single_value / (num_obs_total)); fprintf(stream , value_fmt , single_value_normalized , single_value); } fprintf(stream , "\n"); } double summed_up_normalized = sqrt(summed_up / (num_obs_total * ens_size)); fprintf(stream , " All %7.3f %8.3f" , summed_up_normalized , summed_up); for (iobs = 0; iobs < num_obs; iobs++){ double single_value_summed_up = 0.0; for (int i = 0; i < ens_size; i++) { single_value_summed_up = single_value_summed_up + hash_get_double( obs_hash , stringlist_iget( obs_keys , iobs )); } double single_value_summed_up_normalized=sqrt(single_value_summed_up / (num_obs_total * ens_size)); fprintf(stream , value_fmt , single_value_summed_up_normalized , single_value_summed_up); } fprintf(stream , "\n"); } fclose( stream ); }
void plot_update_range(plot_type * plot, plot_range_type * range) { if (plot->is_histogram) plot_dataset_update_range_histogram( vector_iget(plot->dataset , 0) , range); else { bool first_pass = true; int iplot; for (iplot = 0; iplot < vector_get_size( plot->dataset ); iplot++) plot_dataset_update_range(vector_iget(plot->dataset , iplot) , &first_pass , range); } }
int test_iset( ) { vector_type * vector = vector_alloc_new( ); vector_iset_ref( vector , 2 , vector ); test_assert_true( vector_get_size( vector ) == 3 ); test_assert_true( vector_iget( vector , 0 ) == NULL ); test_assert_true( vector_iget( vector , 1 ) == NULL ); test_assert_true( vector_iget( vector , 2 ) == vector ); vector_free( vector ); return 0; }
void group_rate_sample( group_rate_type * group_rate ) { int length = time_t_vector_size( group_rate->time_vector ); double * group_shift = util_malloc( length * sizeof * group_shift , __func__); int * well_count = util_malloc( length * sizeof * well_count , __func__); int num_wells = vector_get_size( group_rate->well_rates ); int i,well_nr; for (i = 0; i < length; i++) { group_shift[i] = 0; well_count[i] = 0; } for (well_nr=0; well_nr < num_wells; well_nr++) { well_rate_type * well_rate = vector_iget( group_rate->well_rates , well_nr ); well_rate_sample_shift( well_rate ); { const double * well_shift = double_vector_get_ptr( well_rate_get_shift( well_rate )); for (i = 0; i < length; i++) { group_shift[i] += well_shift[i]; if (well_rate_well_open( well_rate , i )) well_count[i] += 1; } } } { for (i = 0; i < length; i++) { if (group_shift[i] > double_vector_iget( group_rate->max_shift , i)) { double adjustment = -(group_shift[i] - double_vector_iget(group_rate->max_shift , i)) / well_count[i]; for (well_nr = 0; well_nr < num_wells; well_nr++) { well_rate_type * well_rate = vector_iget( group_rate->well_rates , well_nr ); well_rate_ishift( well_rate , i , adjustment ); } } else if (group_shift[i] < double_vector_iget( group_rate->min_shift , i )) { double adjustment = -(group_shift[i] - double_vector_iget(group_rate->min_shift , i)) / well_count[i]; for (well_nr = 0; well_nr < num_wells; well_nr++) { well_rate_type * well_rate = vector_iget( group_rate->well_rates , well_nr ); well_rate_ishift( well_rate , i , adjustment ); } } } } free( well_count ); free( group_shift ); }
run_arg_type * ert_run_context_iens_get_arg( const ert_run_context_type * context , int iens) { int index = int_vector_iget( context->iens_map , iens ); if (index >= 0) return vector_iget( context->run_args , index ); else return NULL; }
fault_block_type * fault_block_layer_safe_get_block( fault_block_layer_type * layer , int block_id) { int storage_index = int_vector_safe_iget( layer->block_map , block_id); if (storage_index < 0) return fault_block_layer_add_block( layer , block_id ); else return (fault_block_type*)vector_iget( layer->blocks , storage_index ); }
static void file_map_load_all( file_map_type * file_map ) { int index; for (index = 0; index < vector_get_size( file_map->kw_list); index++) { ecl_file_kw_type * ikw = vector_iget( file_map->kw_list , index ); ecl_file_kw_get_kw( ikw , file_map->fortio , file_map->inv_map); } }
static void * gravity_response_mt( void * arg ) { arg_pack_type * arg_pack = arg_pack_safe_cast( arg ); vector_type * grav_stations = arg_pack_iget_ptr( arg_pack , 0 ); const ecl_grid_type * ecl_grid = arg_pack_iget_ptr( arg_pack , 1 ); const ecl_file_type * init_file = arg_pack_iget_ptr( arg_pack , 2 ); ecl_file_type ** restart_files = arg_pack_iget_ptr( arg_pack , 3 ); int station1 = arg_pack_iget_int( arg_pack , 4 ); int station2 = arg_pack_iget_int( arg_pack , 5 ); int model_phases = arg_pack_iget_int( arg_pack , 6 ); int file_phases = arg_pack_iget_int( arg_pack , 7 ); int station_nr; for (station_nr = station1; station_nr < station2; station_nr++) { grav_station_type * gs = vector_iget( grav_stations , station_nr ); gs->grav_diff = gravity_response( ecl_grid , init_file , restart_files[0] , restart_files[1] , gs , model_phases , file_phases); } return NULL; }
void obs_vector_measure(const obs_vector_type * obs_vector , enkf_fs_type * fs , state_enum state , int report_step , const int_vector_type * ens_active_list , meas_data_type * meas_data , const active_list_type * active_list) { void * obs_node = vector_iget( obs_vector->nodes , report_step ); if ( obs_node != NULL ) { enkf_node_type * enkf_node = enkf_node_deep_alloc( obs_vector->config_node ); node_id_type node_id = { .report_step = report_step , .state = state , .iens = 0 }; for (int active_iens_index =0; active_iens_index < int_vector_size( ens_active_list ); active_iens_index++) { node_id.iens = int_vector_iget( ens_active_list , active_iens_index ); enkf_node_load(enkf_node , fs , node_id); node_id.iens = active_iens_index; obs_vector->measure(obs_node , enkf_node_value_ptr(enkf_node) , node_id , meas_data , active_list); } enkf_node_free( enkf_node ); } }
void gen_kw_config_update_tag_format(gen_kw_config_type * config , const char * tag_format) { int i; config->tag_fmt = tag_format; for (i=0; i < vector_get_size( config->parameters ); i++) gen_kw_parameter_update_tagged_name( vector_iget( config->parameters , i ) , config->tag_fmt); }
void group_rate_update_wconinje( group_rate_type * group_rate , sched_kw_wconinje_type * kw, int restart_nr ) { int well_nr; for (well_nr = 0; well_nr < vector_get_size( group_rate->well_rates ); well_nr++) { well_rate_type * well_rate = vector_iget( group_rate->well_rates , well_nr ); well_rate_update_wconinje( well_rate ,kw , restart_nr ); } }
fault_block_type * fault_block_layer_get_block( const fault_block_layer_type * layer , int block_id) { int storage_index = int_vector_safe_iget( layer->block_map , block_id); if (storage_index < 0) return NULL; else return vector_iget( layer->blocks , storage_index ); }
nnc_vector_type * nnc_info_get_vector( const nnc_info_type * nnc_info , int lgr_nr) { int lgr_index = int_vector_safe_iget( nnc_info->lgr_index_map , lgr_nr ); if (-1 == lgr_index) return NULL; else return vector_iget( nnc_info->lgr_list , lgr_index ); }
double sched_file_well_wconinje_rate( const sched_file_type * sched_file , int restart_nr , const char * well_name) { double rate = -1; bool well_found = false; int block_nr = restart_nr; while (!well_found && (block_nr >= 0)) { sched_block_type * block = sched_file_iget_block( sched_file , block_nr ); if (hash_has_key( block->kw_hash , "WCONINJE")) { const vector_type * wconhist_vector = hash_get( block->kw_hash , "WCONINJE"); int i; for (i=0; i < vector_get_size( wconhist_vector ); i++) { sched_kw_type * kw = vector_iget( wconhist_vector , i ); if (sched_kw_has_well( kw , well_name )) { well_found = true; rate = sched_kw_wconinje_get_surface_flow( sched_kw_get_data( kw ) , well_name ); } } } block_nr--; } return rate; }
int nnc_info_get_total_size( const nnc_info_type * nnc_info ) { int num_nnc = 0; int ivec; for (ivec = 0; ivec < vector_get_size( nnc_info->lgr_list ); ivec++) { const nnc_vector_type * nnc_vector = vector_iget( nnc_info->lgr_list , ivec ); num_nnc += nnc_vector_get_size( nnc_vector ); } return num_nnc; }
static double obs_vector_chi2__(const obs_vector_type * obs_vector , int report_step , const enkf_node_type * node, node_id_type node_id) { void * obs_node = vector_iget( obs_vector->nodes , report_step ); if ( obs_node != NULL) return obs_vector->chi2( obs_node , enkf_node_value_ptr( node ), node_id); else return 0.0; /* Observation not active for this report step. */ }
const int_vector_type * nnc_info_get_index_list(const nnc_info_type * nnc_info, int lgr_nr) { int_vector_type * ret = NULL; if (int_vector_size(nnc_info->lgr_index_map) > lgr_nr) { int lgr_index = int_vector_iget(nnc_info->lgr_index_map, lgr_nr); if (-1 != lgr_index) { ret = vector_iget(nnc_info->lgr_list, lgr_index); } } return ret; }
static bool enkf_config_node_has_container(const enkf_config_node_type * node , enkf_fs_type * fs , node_id_type node_id) { bool has_container = true; for (int inode=0; inode < vector_get_size( node->container_nodes ); inode++) { enkf_config_node_type * child_node = vector_iget( node->container_nodes , inode ); if (!enkf_config_node_has_node( child_node , fs , node_id )) { has_container = false; break; } } return has_container; }
void obs_vector_measure(const obs_vector_type * obs_vector , enkf_fs_type * fs , state_enum state , int report_step , const enkf_state_type * enkf_state , meas_data_type * meas_data , const active_list_type * active_list) { void * obs_node = vector_iget( obs_vector->nodes , report_step ); if ( obs_node != NULL ) { enkf_node_type * enkf_node = enkf_state_get_node( enkf_state , obs_vector_get_state_kw( obs_vector )); node_id_type node_id = { .report_step = report_step , .state = state , .iens = enkf_state_get_iens( enkf_state ) }; enkf_node_load(enkf_node , fs , node_id); obs_vector->measure(obs_node , enkf_node_value_ptr(enkf_node) , node_id , meas_data , active_list); }
void misfit_ensemble_fwrite( const misfit_ensemble_type * misfit_ensemble , FILE * stream ) { int ens_size = vector_get_size( misfit_ensemble->ensemble); util_fwrite_int( misfit_ensemble->history_length , stream ); util_fwrite_int( vector_get_size( misfit_ensemble->ensemble ) , stream); /* Writing the nodes - one for each ensemble member */ { int iens; for (iens = 0; iens < ens_size; iens++) misfit_member_fwrite( vector_iget( misfit_ensemble->ensemble , iens ) , stream ); } }
bool obs_vector_iget_active(const obs_vector_type * vector, int index) { /* We accept this ... */ if (index >= vector_get_size( vector->nodes )) return false; { void * obs_data = vector_iget( vector->nodes , index ); if (obs_data != NULL) return true; else return false; } }
void group_rate_init( group_rate_type * group_rate ) { for (int iw = 0; iw < vector_get_size( group_rate->well_rates ); iw++) { const well_rate_type * well_rate = vector_iget( group_rate->well_rates , iw ); for (int tstep = 0; tstep < well_rate_get_length( well_rate ); tstep++) double_vector_iadd( group_rate->base_rate , tstep , well_rate_iget_rate( well_rate , tstep )); } for (int i = 0; i < stringlist_get_size( group_rate->min_shift_string ); i++) { double_vector_iset( group_rate->min_shift , i , sscanfp( double_vector_safe_iget( group_rate->base_rate , i ) , stringlist_iget( group_rate->min_shift_string , i))); double_vector_iset( group_rate->max_shift , i , sscanfp( double_vector_safe_iget( group_rate->base_rate , i ) , stringlist_iget( group_rate->max_shift_string , i))); } }
/** This were the plot is finally made. */ void plot_data(plot_type * plot) { int iplot; plot_driver_type * driver = plot->driver; plot_set_range__(plot); plot_driver_set_window_size( driver , plot->width , plot->height ); plot_driver_set_labels( driver , plot->title , plot->xlabel , plot->ylabel , plot->label_color , plot->label_font_size); plot_driver_set_axis( driver , plot->range , plot->timefmt , plot->box_color , plot->axis_font_size ); for (iplot = 0; iplot < vector_get_size( plot->dataset ); iplot++) plot_dataset_draw(vector_iget(plot->dataset , iplot) , driver , plot->range); }
static subst_list_string_type * subst_list_get_string_node(const subst_list_type * subst_list , const char * key) { subst_list_string_type * node = NULL; int index = 0; /* Linear search ... */ while ((index < vector_get_size(subst_list->string_data)) && (node == NULL)) { subst_list_string_type * inode = vector_iget( subst_list->string_data , index); if (strcmp(inode->key , key) == 0) /* Found it */ node = inode; else index++; } return node; }
static int well_ts_get_index( const well_ts_type * well_ts , int report_step , time_t sim_time , bool use_report) { int index = well_ts_get_index__( well_ts , report_step , sim_time , use_report ); // Inline check that the index is correct { bool OK = true; const well_node_type * node = vector_iget_const( well_ts->ts , index ); well_node_type * next_node = NULL; if (index < (vector_get_size( well_ts->ts ) - 1)) next_node = vector_iget( well_ts->ts , index + 1); if (use_report) { if (index < 0) { if (report_step >= node->report_nr) OK = false; } else { if (report_step < node->report_nr) OK = false; else { if (next_node != NULL) if (next_node->report_nr <= report_step) OK = false; } } } else { if (index < 0) { if (sim_time >= node->sim_time) OK = false; } else { if (sim_time < node->sim_time) OK = false; else { if (next_node != NULL) if (next_node->sim_time <= sim_time) OK = false; } } if (!OK) util_abort("%s: holy rider - internal error \n",__func__); } } return index; }
static bool file_map_load_all( file_map_type * file_map ) { bool loadOK = false; if (fortio_assert_stream_open( file_map->fortio )) { int index; for (index = 0; index < vector_get_size( file_map->kw_list); index++) { ecl_file_kw_type * ikw = vector_iget( file_map->kw_list , index ); ecl_file_kw_get_kw( ikw , file_map->fortio , file_map->inv_map); } loadOK = true; } if (FILE_FLAGS_SET( file_map->flags , ECL_FILE_CLOSE_STREAM)) fortio_fclose_stream( file_map->fortio ); return loadOK; }
menu_item_type * menu_get_item(const menu_type * menu, char cmd) { int item_index = 0; menu_item_type * item = NULL; while (item_index < vector_get_size(menu->items)) { menu_item_type * current_item = vector_iget(menu->items , item_index); if (!current_item->separator || !current_item->helptext) { if (strchr(current_item->key_set , cmd) != NULL) { item = current_item; break; } item_index++; } } if (item == NULL) util_abort("%s: could not locate item with key: %c \n",__func__ , cmd); return item; }
int vector_find( const vector_type * vector , const void * ptr) { int location_index = -1; int index = 0; while (true) { if (index < vector_get_size( vector )) { const void * element = vector_iget( vector , index ); if (element == ptr) { location_index = index; break; } else index++; } else break; } return location_index; }
static double ecl_grav_survey_eval( const ecl_grav_survey_type * base_survey, const ecl_grav_survey_type * monitor_survey , ecl_region_type * region , double utm_x , double utm_y , double depth, int phase_mask) { int phase_nr; double deltag = 0; for (phase_nr = 0; phase_nr < vector_get_size( base_survey->phase_list ); phase_nr++) { ecl_grav_phase_type * base_phase = vector_iget( base_survey->phase_list , phase_nr ); if (base_phase->phase & phase_mask) { if (monitor_survey != NULL) { const ecl_grav_phase_type * monitor_phase = vector_iget_const( monitor_survey->phase_list , phase_nr ); deltag += ecl_grav_phase_eval( base_phase , monitor_phase , region , utm_x , utm_y , depth ); } else deltag += ecl_grav_phase_eval( base_phase , NULL , region , utm_x , utm_y , depth ); } } return deltag; }