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