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