自学教程：C++ vector_iget函数代码示例

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

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