plot_dataset_type * plot_alloc_new_dataset(plot_type * plot , const char * __label , plot_data_type data_type) { if (data_type == PLOT_HIST) { if (vector_get_size( plot->dataset) > 0) util_abort("%s: sorry - when using histograms you can *only* have one dataset\n",__func__); plot->is_histogram = true; } else if (plot->is_histogram) util_abort("%s: sorry - when using histograms you can *only* have one dataset\n",__func__); { char * label; if (__label == NULL) label = util_alloc_sprintf("data_%d" , vector_get_size( plot->dataset )); else label = (char *) __label; if (hash_has_key( plot->dataset_hash , label)) util_abort("%s: sorry - the label %s is already in use - must be unique \n",__func__ , label); { plot_dataset_type * dataset = plot_dataset_alloc(data_type, label , plot->logx , plot->logy); vector_append_owned_ref(plot->dataset , dataset , plot_dataset_free__); hash_insert_ref( plot->dataset_hash , label , dataset); if (__label == NULL) free(label); return dataset; } } }
int main() { struct vector_t myVector, secondVector; vector_init(&myVector); vector_push_back(&myVector,3); vector_push_back(&myVector,1); vector_push_back(&myVector,4); vector_push_back(&myVector,1); vector_push_back(&myVector,5); vector_push_back(&myVector,9); vector_push_back(&myVector,2); vector_push_back(&myVector,6); vector_copy(&myVector, &secondVector); printf("Size of copied vector: %d\n", vector_get_size(secondVector)); printf("Size: %d\n", vector_get_size(myVector)); printf("Pop: %d\n", vector_pop_back(&myVector)); printf("Pop: %d\n", vector_pop_back(&myVector)); printf("Pop: %d\n", vector_pop_back(&myVector)); printf("Pop: %d\n", vector_pop_back(&myVector)); printf("Pop: %d\n", vector_pop_back(&myVector)); printf("Size: %d\n", vector_get_size(myVector)); printf("Pop: %d\n", vector_pop_back(&myVector)); printf("Pop: %d\n", vector_pop_back(&myVector)); printf("Pop: %d\n", vector_pop_back(&myVector)); printf("Size: %d\n", vector_get_size(myVector)); vector_destroy(&myVector); return 0; }
void test_reverse() { const char * val1 = "value1"; const char * val2 = "value2"; const char * val3 = "value3"; const char * val4 = "value4"; vector_type * vector1 = vector_alloc_new( ); vector_type * vector2 = vector_alloc_new( ); vector_append_ref( vector1 , val1 ); vector_append_ref( vector1 , val2 ); vector_append_ref( vector1 , val3 ); vector_append_ref( vector1 , val4 ); vector_append_ref( vector2 , val1 ); vector_append_ref( vector2 , val2 ); vector_append_ref( vector2 , val3 ); vector_append_ref( vector2 , val4 ); vector_inplace_reverse( vector1 ); { int i; int size = vector_get_size( vector1 ); for (i=0; i < vector_get_size( vector1 ); i++) test_assert_ptr_equal( vector_iget_const( vector2 , i ) , vector_iget_const( vector1 , size - 1 - i )); } vector_free( vector1 ); vector_free( vector2 ); }
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 ); } }
int obs_vector_get_next_active_step(const obs_vector_type * obs_vector , int prev_step) { if (prev_step >= (vector_get_size(obs_vector->nodes) - 1)) return -1; else { int size = vector_get_size( obs_vector->nodes ); int next_step = prev_step + 1; while (( next_step < size) && (obs_vector_iget_node(obs_vector , next_step) == NULL)) next_step++; if (next_step == size) return -1; /* No more active steps. */ else return next_step; } }
void ensemble_init( ensemble_type * ensemble , config_type * config) { /*1 : Loading ensembles and settings from the config instance */ /*1a: Loading the eclipse summary cases. */ { thread_pool_type * tp = thread_pool_alloc( LOAD_THREADS , true ); { int i,j; for (i=0; i < config_get_occurences( config , "CASE_LIST"); i++) { const stringlist_type * case_list = config_iget_stringlist_ref( config , "CASE_LIST" , i ); for (j=0; j < stringlist_get_size( case_list ); j++) ensemble_load_from_glob( ensemble , stringlist_iget( case_list , j ) , tp); } } thread_pool_join( tp ); thread_pool_free( tp ); } { const sum_case_type * tmp = vector_iget_const( ensemble->data , 0 ); ensemble->refcase = tmp->ecl_sum; } /*1b: Other config settings */ if (config_item_set( config , "NUM_INTERP" )) ensemble->num_interp = config_iget_as_int( config , "NUM_INTERP" , 0 , 0 ); /*2: Remaining initialization */ ensemble_init_time_interp( ensemble ); if (vector_get_size( ensemble->data ) < MIN_SIZE ) util_exit("Sorry - quantiles make no sense with with < %d realizations; should have ~> 100.\n" , MIN_SIZE); }
static void assert_type_and_index( const ecl_rft_node_type * rft_node , ecl_rft_enum target_type , int index) { if (rft_node->data_type != target_type) util_abort("%s: wrong type \n",__func__); if ((index < 0) || (index >= vector_get_size( rft_node->cells ))) util_abort("%s: invalid index:%d \n",__func__ , index); }
config_path_elm_type * config_content_add_path_elm( config_content_type * content , const char * path ) { const config_path_elm_type * current_path_elm; if (vector_get_size( content->path_elm_stack ) == 0) current_path_elm = NULL; else current_path_elm = vector_get_last_const(content->path_elm_stack); { config_path_elm_type * new_path_elm; { char * rel_path = NULL; config_root_path_type * invoke_path = config_content_get_invoke_path( content ); if (path != NULL) { if (current_path_elm == NULL) rel_path = util_alloc_rel_path( config_root_path_get_abs_path(invoke_path) , path); else rel_path = config_path_elm_alloc_relpath( current_path_elm , path ); } new_path_elm = config_path_elm_alloc( invoke_path , rel_path ); util_safe_free( rel_path ); } vector_append_owned_ref( content->path_elm_storage , new_path_elm , config_path_elm_free__); vector_append_ref( content->path_elm_stack , new_path_elm ); return new_path_elm; } }
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; }
/** 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; }
vector_type * load_expected( const ecl_grid_type * grid, const char * filename ) { FILE * stream = util_fopen( filename , "r"); vector_type * expected = vector_alloc_new(); while (true) { double x,y,z; int i,j,k,skip; if (fscanf( stream , "%lg %lg %lg %d %d %d %d" , &x,&y,&z,&i,&j,&k,&skip) == 7) { point_type * p = util_malloc( sizeof * p ); p->x = x; p->y = y; p->z = z; p->i = i-1; p->j = j-1; p->k = k-1; p->skip = skip; p->g = ecl_grid_get_global_index3(grid, p->i, p->j, p->k); vector_append_owned_ref( expected, p , free ); } else break; } fclose( stream ); test_assert_int_equal( 10 , vector_get_size( expected )); return expected; }
static void file_map_fwrite( const file_map_type * file_map , fortio_type * target , int offset) { int index; for (index = offset; index < vector_get_size( file_map->kw_list ); index++) { ecl_kw_type * ecl_kw = file_map_iget_kw( file_map , index ); ecl_kw_fwrite( ecl_kw , target ); } }
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 subst_list_fprintf(const subst_list_type * subst_list , FILE * stream) { int index; for (index=0; index < vector_get_size( subst_list->string_data ); index++) { const subst_list_string_type * node = vector_iget_const( subst_list->string_data , index ); fprintf(stream , "%s = %s\n" , node->key , node->value); } }
int main(int argc , char ** argv) { util_install_signals(); { ecl_grid_type * grid = ecl_grid_alloc( argv[1] ); vector_type * expected = load_expected( grid, argv[2] ); for (int c=0; c < vector_get_size( expected ); c++) { const point_type * p = vector_iget_const( expected , c ); int g = ecl_grid_get_global_index_from_xyz(grid , p->x, p->y , p->z , 0 ); if (g != ecl_grid_get_global_index3(grid, p->i,p->j, p->k)) { int i,j,k; ecl_grid_get_ijk1(grid, g, &i, &j, &k); fprintf(stderr,"point:%d (%g,%g,%g), Simulated: %d:(%d,%d,%d) Expected: %d:(%d,%d,%d) contains:%d\n", c , p->x, p->y, p->z, g, i,j,k, p->g, p->i, p->j, p->k, ecl_grid_cell_contains_xyz1( grid, p->g , p->x , p->y, p->z)); } if (!p->skip) test_assert_int_equal( g , ecl_grid_get_global_index3(grid, p->i,p->j, p->k)); else { if ( g != ecl_grid_get_global_index3(grid, p->i,p->j, p->k)) fprintf(stderr," ** Skipping failed test for point:%d \n",c); } } ecl_grid_free( grid ); vector_free( expected ); } exit(0); }
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 ); } }
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); } }
void comms_load_player_choices() { while (vector_get_size(&comms_player_choices) > 0) { Comms_PlayerChoice *pc = (Comms_PlayerChoice *)vector_get(&comms_player_choices, 0); vector_remove(&comms_player_choices, 0); free(pc); } vector_init(&comms_player_choices, COMMS_PLAYER_CHOICE_COUNT); vector_fill(&comms_player_choices, NULL); Comms_PlayerChoice *pc; pc = malloc(sizeof(Comms_PlayerChoice)); pc->text0 = "attack"; pc->choice0 = COMMS_NPC_DEFEND; pc->text1 = "trade"; pc->choice1 = COMMS_NPC_TRADE; pc->text2 = "talk"; pc->choice2 = COMMS_NPC_INFO; pc->text3 = "disengage"; pc->choice3 = COMMS_NPC_FAREWELL; vector_set(&comms_player_choices, COMMS_PLAYER_CHOICE_MAIN, pc); pc = malloc(sizeof(Comms_PlayerChoice)); pc->text0 = "aggree"; pc->choice0 = COMMS_NPC_TRADE_ACCEPT_BUY; //TODO: This doesn't account for buy/sell separation pc->text1 = "decline"; pc->choice1 = COMMS_NPC_TRADE_DECLINE; pc->text2 = NULL; pc->choice2 = -1; pc->text3 = NULL; pc->choice3 = -1; vector_set(&comms_player_choices, COMMS_PLAYER_CHOICE_TRADE_INVITE, pc); pc = malloc(sizeof(Comms_PlayerChoice)); pc->text0 = "buy"; pc->choice0 = COMMS_NPC_TRADE_ACCEPT_BUY; pc->text1 = "sell"; pc->choice1 = COMMS_NPC_TRADE_ACCEPT_SELL; pc->text2 = "back"; pc->choice2 = COMMS_PLAYER_CHOICE_MAIN; pc->text3 = NULL; pc->choice3 = -1; vector_set(&comms_player_choices, COMMS_PLAYER_CHOICE_TRADE, pc); pc = malloc(sizeof(Comms_PlayerChoice)); pc->text0 = "attack"; pc->choice0 = COMMS_NPC_ATTACK_ACCEPT; pc->text1 = "flee"; pc->choice1 = COMMS_NPC_ATTACK_FLEE; pc->text2 = "plead"; pc->choice2 = COMMS_NPC_ATTACK_PLEAD; pc->text3 = NULL; pc->choice3 = -1; vector_set(&comms_player_choices, COMMS_PLAYER_CHOICE_DEFEND, pc); }
static void ecl_sum_data_build_index( ecl_sum_data_type * sum_data ) { /* Clear the existing index (if any): */ ecl_sum_data_clear_index( sum_data ); /* Sort the internal storage vector after sim_time. */ vector_sort( sum_data->data , cmp_ministep ); /* Identify various global first and last values. */ { const ecl_sum_tstep_type * first_ministep = ecl_sum_data_iget_ministep( sum_data , 0 ); sum_data->first_ministep = ecl_sum_tstep_get_ministep( first_ministep ); /* In most cases the days_start and data_start_time will agree with the global simulation start; however in the case where we have loaded a summary case from a restarted simulation where the case we have restarted from is not available - then there will be a difference. */ sum_data->days_start = ecl_sum_tstep_get_sim_days( first_ministep ); sum_data->data_start_time = ecl_sum_tstep_get_sim_time( first_ministep ); } ecl_sum_data_update_end_info( sum_data ); /* Build up the report -> ministep mapping. */ { int internal_index; for (internal_index = 0; internal_index < vector_get_size( sum_data->data ); internal_index++) { const ecl_sum_tstep_type * ministep = ecl_sum_data_iget_ministep( sum_data , internal_index ); int report_step = ecl_sum_tstep_get_report(ministep); /* Indexing internal_index - report_step */ { int current_first_index = int_vector_safe_iget( sum_data->report_first_index , report_step ); if (current_first_index < 0) /* i.e. currently not set. */ int_vector_iset( sum_data->report_first_index , report_step , internal_index); else if (internal_index < current_first_index) int_vector_iset( sum_data->report_first_index , report_step , internal_index); } { int current_last_index = int_vector_safe_iget( sum_data->report_last_index , report_step ); if (current_last_index < 0) int_vector_iset( sum_data->report_last_index , report_step , internal_index); else if (internal_index > current_last_index) int_vector_iset( sum_data->report_last_index , report_step , internal_index); } sum_data->first_report_step = util_int_min( sum_data->first_report_step , report_step ); sum_data->last_report_step = util_int_max( sum_data->last_report_step , report_step ); } } sum_data->index_valid = true; }
static void obs_vector_resize(obs_vector_type * vector , int new_size) { int current_size = vector_get_size( vector->nodes ); int i; for (i=current_size; i < new_size; i++) vector_append_ref( vector->nodes , NULL); }
static void sched_block_fprintf(const sched_block_type * block, FILE * stream) { int i; for (i=0; i < vector_get_size(block->kw_list); i++) { const sched_kw_type * sched_kw = vector_iget_const( block->kw_list , i); sched_kw_fprintf(sched_kw, stream); } }
int main() { struct vector_t vec; struct vector_t vec2; int i; printf("Original vector test\n"); vector_init(&vec); printf("Pushing into vector\n"); for(i=0; i<10; i++) { vector_push_back(&vec, i); printf("Index: %d\n", vector_get_size(vec)); } printf("Popping out of vector\n"); for(i=0; i<10; i++) { vector_pop_back(&vec); printf("Index: %d\n", vector_get_size(vec)); } vector_copy(&vec, &vec2); vector_destroy(&vec); printf("Copied vector test\n"); printf("Pushing in vector\n"); for(i=0; i<10; i++) { vector_push_back(&vec2, i); printf("Index: %d\n", vector_get_size(vec2)); } printf("Popping out of vector\n"); for(i=0; i<10; i++) { vector_pop_back(&vec2); printf("Index: %d\n", vector_get_size(vec2)); } vector_destroy(&vec2); return 0; }
static bool file_map_has_kw_ptr( const file_map_type * file_map, const ecl_kw_type * ecl_kw) { int index; for (index = 0; index < vector_get_size( file_map->kw_list ); index++) { const ecl_file_kw_type * file_kw = vector_iget_const( file_map->kw_list , index ); if (ecl_file_kw_ptr_eq( file_kw , ecl_kw )) return true; } return false; }
bool local_updatestep_has_data_key( const local_updatestep_type * update_step , const char * key) { bool has_key = false; for (int i = 0; i < vector_get_size( update_step->ministep ); i++) { const local_ministep_type * ministep = vector_iget_const( update_step->ministep , i ); if (local_ministep_has_data_key(ministep, key)) has_key = true; } return has_key; }
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 int ecl_sum_data_get_index_from_sim_time( const ecl_sum_data_type * data , time_t sim_time) { time_t data_start_time = data->data_start_time; if ((sim_time < data_start_time) || (sim_time > data->sim_end)) { fprintf(stderr , "Simulation start: "); util_fprintf_date( ecl_smspec_get_start_time( data->smspec ) , stderr ); fprintf(stderr , "Data start......: "); util_fprintf_date( data_start_time , stderr ); fprintf(stderr , "Simulation end .: "); util_fprintf_date( data->sim_end , stderr ); fprintf(stderr , "Requested date .: "); util_fprintf_date( sim_time , stderr ); util_abort("%s: invalid time_t instance:%d interval: [%d,%d]\n",__func__, sim_time , data_start_time , data->sim_end); } /* The moment we have passed the intial test we MUST find a valid ministep index, however care should be taken that there can perfectly well be 'holes' in the time domain, because of e.g. the RPTONLY keyword. */ { int low_index = 0; int high_index = vector_get_size( data->data ); int internal_index = -1; while (internal_index < 0) { if (low_index == high_index) internal_index = low_index; else { int center_index = 0.5*( low_index + high_index ); const ecl_sum_tstep_type * ministep = ecl_sum_data_iget_ministep( data , center_index ); if ((high_index - low_index) == 1) { /* Degenerate special case. */ if (sim_time < ecl_sum_tstep_get_sim_time( ministep )) internal_index = low_index; else internal_index = high_index; } else { if (sim_time > ecl_sum_tstep_get_sim_time( ministep )) /* Low-----Center---X---High */ low_index = center_index; else { time_t prev_time = data_start_time; if (center_index > 0) { const ecl_sum_tstep_type * prev_step = ecl_sum_data_iget_ministep( data , center_index - 1 ); prev_time = ecl_sum_tstep_get_sim_time( prev_step ); } if (prev_time < sim_time) internal_index = center_index; /* Found it */ else high_index = center_index; } } } } return internal_index; } }
const char * subst_list_iget_doc_string( const subst_list_type * subst_list , int index) { if (index < vector_get_size(subst_list->string_data)) { const subst_list_string_type * node = vector_iget_const( subst_list->string_data , index ); return node->doc_string; } else { util_abort("%s: index:%d to large \n",__func__ , index); return NULL; } }
void output_save_plain__( const output_type * output , ensemble_type * ensemble , const double ** data , bool add_header) { FILE * stream = util_mkdir_fopen( output->file , "w"); const char * key_fmt = " %18s:%4.2f "; const char * time_header = "-- DAYS DATE "; const char * time_dash = "------------------------"; const char * key_dash = "-------------------------"; const char * float_fmt = "%24.5f "; const char * days_fmt = "%10.2f "; const char * date_fmt = " %02d/%02d/%04d "; const int data_columns = vector_get_size( output->keys ); const int data_rows = time_t_vector_size( ensemble->interp_time ); int row_nr,column_nr; if (add_header) { fprintf( stream ,time_header); for (int i=0; i < vector_get_size( output->keys ); i++) { const quant_key_type * qkey = vector_iget( output->keys , i ); fprintf( stream , key_fmt , qkey->sum_key , qkey->quantile ); } fprintf(stream , "\n"); fprintf( stream , time_dash ); for (int i=0; i < vector_get_size( output->keys ); i++) fprintf(stream , key_dash ); fprintf(stream , "\n"); } /*4: Writing the actual data. */ for (row_nr = 0; row_nr < data_rows; row_nr++) { time_t interp_time = time_t_vector_iget( ensemble->interp_time , row_nr); fprintf(stream , days_fmt , 1.0*(interp_time - ensemble->start_time) / 86400); { int mday,month,year; util_set_datetime_values(interp_time , NULL , NULL , NULL , &mday , &month , &year); fprintf(stream , date_fmt , mday , month , year); } for (column_nr = 0; column_nr < data_columns; column_nr++) { fprintf(stream , float_fmt , data[row_nr][column_nr]); } fprintf( stream , "\n"); } }
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); } }
static void file_map_fprintf_kw_list(const file_map_type * file_map , FILE * stream) { int i; for (i=0; i < vector_get_size( file_map->kw_list ); i++) { const ecl_file_kw_type * file_kw = vector_iget_const( file_map->kw_list , i ); fprintf(stream , "%-8s %7d:%s\n", ecl_file_kw_get_header( file_kw ) , ecl_file_kw_get_size( file_kw ) , ecl_util_get_type_name( ecl_file_kw_get_type( file_kw ))); } }