void ecl_sum_data_report2internal_range(const ecl_sum_data_type * data , int report_step , int * index1 , int * index2 ){ if (index1 != NULL) *index1 = int_vector_safe_iget( data->report_first_index , report_step ); if (index2 != NULL) *index2 = int_vector_safe_iget( data->report_last_index , report_step ); }
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; }
int gen_data_config_get_initial_size( const gen_data_config_type * config ) { int initial_size = int_vector_safe_iget( config->data_size_vector , 0); if (initial_size < 0) initial_size = 0; return initial_size; }
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 ); }
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 ); }
bool well_segment_collection_has_segment( const well_segment_collection_type * segment_collection , int segment_id) { int internal_index = int_vector_safe_iget( segment_collection->segment_index_map , segment_id ); if (internal_index >= 0) return true; else return false; }
well_segment_type * well_segment_collection_get( const well_segment_collection_type * segment_collection , int segment_id) { int internal_index = int_vector_safe_iget( segment_collection->segment_index_map , segment_id ); if (internal_index >= 0) return well_segment_collection_iget( segment_collection , internal_index ); else return NULL; }
static void state_map_iset__( state_map_type * map , int index , realisation_state_enum new_state) { realisation_state_enum current_state = int_vector_safe_iget( map->state , index ); if (state_map_legal_transition( current_state , new_state )) int_vector_iset( map->state , index , new_state); else util_abort("%s: illegal state transition for realisation:%d %d -> %d \n" , __func__ , index , current_state , new_state ); }
realisation_state_enum state_map_iget( state_map_type * map , int index) { realisation_state_enum state; pthread_rwlock_rdlock( &map->rw_lock ); { state = int_vector_safe_iget( map->state , index ); } pthread_rwlock_unlock( &map->rw_lock ); return state; }
void config_schema_item_assure_type(const config_schema_item_type * item , int index , int type_mask) { bool OK = false; if (int_vector_safe_iget( item->validate->type_map , index) & type_mask) OK = true; if (!OK) util_abort("%s: failed - wrong installed type \n" , __func__); }
void well_segment_collection_add( well_segment_collection_type * segment_collection , well_segment_type * segment) { int segment_id = well_segment_get_id( segment ); int current_index = int_vector_safe_iget( segment_collection->segment_index_map , segment_id ); if (current_index >= 0) vector_iset_owned_ref( segment_collection->__segment_storage , current_index , segment , well_segment_free__); else { int new_index = vector_get_size(segment_collection->__segment_storage); vector_append_owned_ref( segment_collection->__segment_storage , segment , well_segment_free__); int_vector_iset( segment_collection->segment_index_map , segment_id , new_index); } }
fault_block_type * fault_block_layer_add_block( fault_block_layer_type * layer , int block_id) { if (int_vector_safe_iget( layer->block_map , block_id) < 0) { fault_block_type * block = fault_block_alloc( layer , block_id ); int storage_index = vector_get_size( layer->blocks ); int_vector_iset( layer->block_map , block_id , storage_index ); vector_append_owned_ref( layer->blocks , block , fault_block_free__ ); return block; } else return NULL; }
void fault_block_layer_del_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) { int_vector_iset( layer->block_map , block_id , -1 ); vector_idel( layer->blocks , storage_index ); { int index; for (index = 0; index < int_vector_size( layer->block_map ); index++) { int current_storage_index = int_vector_iget( layer->block_map , index ); if (current_storage_index > storage_index) int_vector_iset( layer->block_map ,index , current_storage_index - 1); } } } }
/** This function will load an active map from the enkf_fs filesystem. */ void gen_data_config_load_active( gen_data_config_type * config , enkf_fs_type * fs, int report_step , bool force_load) { bool fs_changed = false; if (fs != config->read_fs) { config->read_fs = fs; fs_changed = true; } if (!config->dynamic) return; /* This is used as a GEN_PARAM instance - and the loading of mask is not an option. */ pthread_mutex_lock( &config->update_lock ); { if ( force_load || (int_vector_iget( config->data_size_vector , report_step ) > 0)) { if (config->active_report_step != report_step || fs_changed) { char * filename = util_alloc_sprintf("%s_active" , config->key ); FILE * stream = enkf_fs_open_excase_tstep_file( fs , filename , report_step); if (stream != NULL) { bool_vector_fread( config->active_mask , stream ); fclose( stream ); } else { int gen_data_size = int_vector_safe_iget( config->data_size_vector, report_step ); if (gen_data_size < 0) { fprintf(stderr,"** Fatal internal error in function:%s \n",__func__); fprintf(stderr,"\n"); fprintf(stderr," 1: The active mask file:%s was not found \n",filename); fprintf(stderr," 2: The size of the gen_data vectors has not been set\n"); fprintf(stderr,"\n"); fprintf(stderr,"We can not create a suitable active_mask. Code should call gen_data_config_has_active_mask()\n\n"); util_abort("%s: fatal internal error - could not create a suitable active_mask \n",__func__); } else { fprintf(stdout,"** Info: could not locate active data elements file %s, filling active vector with true all elements active \n",filename); bool_vector_reset( config->active_mask ); bool_vector_iset( config->active_mask, gen_data_size - 1, true); } } free( filename ); } } config->active_report_step = report_step; } pthread_mutex_unlock( &config->update_lock ); }
void gen_data_config_assert_size(gen_data_config_type * config , int data_size, int report_step) { pthread_mutex_lock( &config->update_lock ); { int current_size = int_vector_safe_iget( config->data_size_vector , report_step ); if (current_size < 0) { int_vector_iset( config->data_size_vector , report_step , data_size ); current_size = data_size; } if (current_size != data_size) { util_abort("%s: Size mismatch when loading:%s from file - got %d elements - expected:%d [report_step:%d] \n", __func__ , gen_data_config_get_key( config ), data_size , current_size , report_step); } } pthread_mutex_unlock( &config->update_lock ); }
static void state_map_iset__( state_map_type * map , int index , realisation_state_enum new_state) { realisation_state_enum current_state = int_vector_safe_iget( map->state , index ); int target_mask = 0; if (current_state == STATE_UNDEFINED) target_mask = STATE_INITIALIZED | STATE_PARENT_FAILURE; else if (current_state == STATE_INITIALIZED) target_mask = STATE_LOAD_FAILURE | STATE_HAS_DATA | STATE_INITIALIZED | STATE_PARENT_FAILURE; else if (current_state == STATE_HAS_DATA) target_mask = STATE_LOAD_FAILURE | STATE_HAS_DATA | STATE_PARENT_FAILURE; else if (current_state == STATE_LOAD_FAILURE) target_mask = STATE_HAS_DATA | STATE_INITIALIZED; else if (current_state == STATE_PARENT_FAILURE) target_mask = STATE_INITIALIZED; if (new_state & target_mask) int_vector_iset( map->state , index , new_state); else util_abort("%s: illegal state transition for realisation:%d %d -> %d \n" , __func__ , index , current_state , new_state ); }
static config_item_types validate_iget_type( const validate_type * validate , int index) { return int_vector_safe_iget( validate->type_map , index ); }
bool ecl_sum_data_has_report_step(const ecl_sum_data_type * data , int report_step ) { if (int_vector_safe_iget( data->report_first_index , report_step) >= 0) return true; else return false; }
int ecl_sum_data_iget_report_start( const ecl_sum_data_type * data , int report_step ) { return int_vector_safe_iget( data->report_first_index , report_step ); }
int int_vector_iadd( int_vector_type * vector , int index , int delta) { int new_value = int_vector_safe_iget(vector , index ) + delta; int_vector_iset( vector , index , new_value ); return new_value; }
bool fault_block_layer_has_block( const fault_block_layer_type * layer , int block_id) { if (int_vector_safe_iget( layer->block_map , block_id) >= 0) return true; else return false; }
int gen_data_config_get_data_size( const gen_data_config_type * config , int report_step) { int current_size = int_vector_safe_iget( config->data_size_vector , report_step ); if (current_size < 0) util_abort("%s: Size not set for object:%s report_step:%d - internal error: \n",__func__ , config->key , report_step); return current_size; }