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