Пример #1
0
void test_deselect_matching( ) {
  state_map_type * map = state_map_alloc( );
  bool_vector_type * mask1 = bool_vector_alloc(0 , false);
  bool_vector_type * mask2 = bool_vector_alloc(1000 , true);

  state_map_iset( map , 10 , STATE_INITIALIZED );
  state_map_iset( map , 10 , STATE_HAS_DATA );
  state_map_iset( map , 20 , STATE_INITIALIZED );
  state_map_deselect_matching( map , mask1 , STATE_HAS_DATA | STATE_INITIALIZED );
  state_map_deselect_matching( map , mask2 , STATE_HAS_DATA | STATE_INITIALIZED );
  
  test_assert_int_equal( state_map_get_size( map ) , bool_vector_size( mask1 ));
  
  for (int i=0; i < bool_vector_size( mask1 ); i++) {
    if (i==10)
      test_assert_false( bool_vector_iget( mask1 , i ));
    else if (i== 20)
      test_assert_false( bool_vector_iget( mask2 , i ));
    else {
      test_assert_false( bool_vector_iget( mask1 , i ));
      test_assert_true( bool_vector_iget( mask2 , i ));
    }
  }
    
  bool_vector_free( mask1 );
  bool_vector_free( mask2 );
  state_map_free( map );
}
Пример #2
0
static bool_vector_type * alloc_iactive_vector_from_range(const stringlist_type * range, int startindex, int ens_size) {
  bool_vector_type * iactive;
  if (stringlist_get_size(range) > startindex) {
    char * arg_string = stringlist_alloc_joined_substring( range, startindex, stringlist_get_size(range), "");
    iactive = bool_vector_alloc(ens_size, false);
    string_util_update_active_mask( arg_string, iactive );
    free ( arg_string );
  } else {
    iactive = bool_vector_alloc(ens_size, true);
  }
  return iactive;
}
Пример #3
0
void enkf_tui_run_exp(void * enkf_main) {
  const int ens_size          = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive  = bool_vector_alloc(0,false);

  state_enum init_state    = ANALYZED; 
  int start_report         = 0;
  int init_step_parameters = 0;
  
  {

    char * prompt = util_alloc_sprintf("Which realizations to simulate (Ex: 1,3-5) <Enter for all> [M to return to menu] : " , ens_size);
    char * select_string;
      
    util_printf_prompt(prompt , PROMPT_LEN , '=' , "=> ");
    select_string = util_alloc_stdin_line();
    enkf_tui_util_sscanf_active_list( iactive , select_string , ens_size);

    util_safe_free( select_string );
    free( prompt );
  }
  if (bool_vector_count_equal(iactive , true))
    enkf_main_run_exp(enkf_main , iactive , true , init_step_parameters , start_report , init_state, true);
  
  bool_vector_free(iactive);
}
Пример #4
0
static void * enkf_main_smoother_JOB__( void * self , int iter , const stringlist_type * args ) {
  enkf_main_type   * enkf_main = enkf_main_safe_cast( self );
  int ens_size                 = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive   = bool_vector_alloc( ens_size , true );
  bool valid                   = true;
  const char * target_case;
  enkf_fs_type * target_fs     = enkf_main_get_fs( enkf_main );


  // Argument 0: Which case to write to. Default current case.
  if (stringlist_get_size(args)) {
    target_case = stringlist_iget( args , 0 );
    if (strcmp( target_case , CURRENT_CASE_STRING) == 0)
      target_case = enkf_fs_get_case_name(target_fs);
  } else
    target_case = enkf_fs_get_case_name(target_fs);

  //Argument 1: Rerun. Default false.
  bool rerun = (stringlist_get_size(args) >= 2) ? stringlist_iget_as_bool(args, 1, &valid) : false;

  if (!valid) {
      fprintf(stderr, "** Warning: Function %s : Second argument must be a bool value. Exiting job\n", __func__);
      return NULL;
  }
  enkf_main_run_smoother( enkf_main , target_case , iactive , iter , rerun);
  bool_vector_free( iactive );
  return NULL;
}
Пример #5
0
void enkf_plot_gen_kw_load( enkf_plot_gen_kw_type  * plot_gen_kw,
                            enkf_fs_type           * fs,
                            bool                     transform_data , 
                            int                      report_step,
                            const bool_vector_type * input_mask ) {

  state_map_type * state_map = enkf_fs_get_state_map( fs );
  int ens_size = state_map_get_size( state_map );
  bool_vector_type * mask;

  if (input_mask)
    mask = bool_vector_alloc_copy( input_mask );
  else
    mask = bool_vector_alloc( ens_size , true );

  enkf_plot_gen_kw_resize( plot_gen_kw , ens_size );
  {
    int iens;
    for (iens = 0; iens < ens_size; ++iens) {
      if (bool_vector_iget( mask , iens)) {
        enkf_plot_gen_kw_vector_type * vector = enkf_plot_gen_kw_iget( plot_gen_kw , iens );
        enkf_plot_gen_kw_vector_load( vector , fs , transform_data , report_step );
      }
    }
  }
}
Пример #6
0
void enkf_tui_run_smoother(void * arg) {
  enkf_main_type * enkf_main  = enkf_main_safe_cast( arg );
  int ens_size = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive = bool_vector_alloc( ens_size , true );
  enkf_main_run_smoother(enkf_main , "AUTO-SMOOTHER" , iactive , 0 , true );
  bool_vector_free( iactive );
}
Пример #7
0
void enkf_tui_fs_initialize_case_from_copy(void * arg) 
{
  int prompt_len =50;
  char * source_case;
  int ens_size;
  int last_report;
  int src_step;
  state_enum src_state;
  enkf_main_type   * enkf_main = enkf_main_safe_cast( arg );

  ens_size = enkf_main_get_ensemble_size( enkf_main );

  
  last_report  = enkf_main_get_history_length( enkf_main );

  source_case = enkf_tui_fs_alloc_existing_case( enkf_main , "Initialize from case" , prompt_len);
  if (source_case != NULL) {                                              
    char * ranking_key  = NULL;
    bool_vector_type * iens_mask = bool_vector_alloc( 0 , true ); 
    src_step         = util_scanf_int_with_limits("Source report step",prompt_len , 0 , last_report);
    src_state        = enkf_tui_util_scanf_state("Source analyzed/forecast [A|F]" , prompt_len , false);
    enkf_main_initialize_from_existing( enkf_main , source_case , src_step , src_state , iens_mask , ranking_key );
    bool_vector_free( iens_mask );
  }
  util_safe_free( source_case );
}
Пример #8
0
int main(int argc , char ** argv) {
    enkf_main_install_SIGNALS();

    const char * config_file             = argv[1];
    ert_test_context_type * test_context = ert_test_context_alloc("VerifyJobsFileTest" , config_file);
    enkf_main_type * enkf_main           = ert_test_context_get_main(test_context);

    {
        const int ens_size         = enkf_main_get_ensemble_size( enkf_main );
        bool_vector_type * iactive = bool_vector_alloc(0, false);
        bool_vector_iset( iactive , ens_size - 1 , true );

        enkf_main_create_run_path(enkf_main , iactive , 0);
        bool_vector_free(iactive);
    }

    const char * filename = util_alloc_filename(ert_test_context_get_cwd(test_context),
                            "simulations/run0/jobs.py", NULL);
    const char * jobs_file_content = util_fread_alloc_file_content(filename, NULL);

    test_assert_true  (strstr(jobs_file_content, "umask = 0022") != NULL);
    test_assert_false (strstr(jobs_file_content, "umask = 0023") != NULL);
    test_assert_false (strstr(jobs_file_content, "umask = 0032") != NULL);
    test_assert_false (strstr(jobs_file_content, "umask = 0122") != NULL);
    test_assert_false (strstr(jobs_file_content, "umask = 1022") != NULL);

    ert_test_context_free(test_context);
    exit(0);
}
Пример #9
0
void enkf_tui_run_restart__(void * enkf_main) {
  const int ens_size    = enkf_main_get_ensemble_size( enkf_main );
  const int last_report = enkf_main_get_history_length( enkf_main );
  int start_report;
  char * start_report_as_char;
  bool wronginput = false;
  state_enum state;
  bool_vector_type * iactive = bool_vector_alloc(0,true);
  bool_vector_iset( iactive , ens_size - 1 , true );
  
  start_report_as_char = util_scanf_int_with_limits_return_char("Report step",PROMPT_LEN , 0 , last_report);
  if(strlen(start_report_as_char) != 0){
    util_sscanf_int(start_report_as_char , &start_report);
  }
  else
    wronginput = true;
  
  if(!wronginput){
    state        = enkf_tui_util_scanf_state("Analyzed/forecast" , PROMPT_LEN , false);
    if(state == UNDEFINED)
      wronginput = true;
  }
  
  if(!wronginput)
    enkf_main_run_assimilation(enkf_main ,  iactive , start_report , start_report  , state);
  
  bool_vector_free(iactive);
  free(start_report_as_char);
}
Пример #10
0
static gen_data_config_type * gen_data_config_alloc( const char * key , bool dynamic ) {
  gen_data_config_type * config = util_malloc(sizeof * config );
  UTIL_TYPE_ID_INIT( config , GEN_DATA_CONFIG_ID);

  config->key               = util_alloc_string_copy( key );

  config->template_file        = NULL;
  config->template_key         = NULL;
  config->template_buffer      = NULL;
  gen_data_config_reset_template( config );

  config->data_size          = 0;
  config->internal_type      = ECL_DOUBLE_TYPE;
  config->input_format       = GEN_DATA_UNDEFINED;
  config->output_format      = GEN_DATA_UNDEFINED;
  config->data_size_vector   = int_vector_alloc( 0 , -1 );   /* The default value: -1 - indicates "NOT SET" */
  config->active_report_steps= int_vector_alloc( 0 , 0 );
  config->active_mask        = bool_vector_alloc(0 , true ); /* Elements are explicitly set to FALSE - this MUST default to true. */ 
  config->active_report_step = -1;
  config->ens_size           = -1;
  config->read_fs            = NULL;
  config->write_fs           = NULL;
  config->dynamic            = dynamic;
  pthread_mutex_init( &config->update_lock , NULL );


  return config;
}
Пример #11
0
void test_active_index_list() {
  int default_value = -1;
  bool_vector_type * mask = bool_vector_alloc(0 , false);

  bool_vector_iset(mask , 10, true);
  bool_vector_iset(mask , 15, true);
  bool_vector_iset(mask , 20, true);

  {
    int_vector_type * active_index_list = bool_vector_alloc_active_index_list(mask , default_value);

    test_assert_int_equal( default_value , int_vector_get_default(active_index_list));
    test_assert_int_equal( 21 , int_vector_size( active_index_list ));

    test_assert_int_equal( default_value , int_vector_iget( active_index_list , 0));
    test_assert_int_equal( default_value , int_vector_iget( active_index_list , 1));
    test_assert_int_equal( default_value , int_vector_iget( active_index_list , 12));
    test_assert_int_equal( default_value , int_vector_iget( active_index_list , 19));

    test_assert_int_equal( 0 , int_vector_iget( active_index_list , 10));
    test_assert_int_equal( 1 , int_vector_iget( active_index_list , 15));
    test_assert_int_equal( 2 , int_vector_iget( active_index_list , 20));


    int_vector_free( active_index_list);
  }
  bool_vector_free(mask);
}
Пример #12
0
void test_set_from_mask() {
  int i;
  state_map_type * map1 = state_map_alloc();
  state_map_type * map2 = state_map_alloc();
  bool_vector_type * mask = bool_vector_alloc(0, false);
  bool_vector_iset(mask , 10 , true);
  bool_vector_iset(mask , 20 , true);

  state_map_set_from_mask(map1 , mask , STATE_INITIALIZED);
  state_map_set_from_inverted_mask(map2 , mask , STATE_INITIALIZED);
  test_assert_int_equal(21 , state_map_get_size(map1));
  test_assert_int_equal(21 , state_map_get_size(map2));
  for (i = 0; i < state_map_get_size(map1); i++) {
    if (i == 10 || i== 20) {
      test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map1 , i) );
      test_assert_int_equal( STATE_UNDEFINED , state_map_iget(map2 , i));
    }
    else {
      test_assert_int_equal(STATE_UNDEFINED , state_map_iget(map1 , i ));
      test_assert_int_equal( STATE_INITIALIZED , state_map_iget(map2 , i));
    }


  }
}
Пример #13
0
void enkf_main_init_case_from_existing(const enkf_main_type * enkf_main,
                                       enkf_fs_type * source_case_fs,
                                       int source_report_step,
                                       state_enum source_state,
                                       enkf_fs_type * target_case_fs ) {

    stringlist_type * param_list = ensemble_config_alloc_keylist_from_var_type( enkf_main_get_ensemble_config(enkf_main) , PARAMETER ); /* Select only paramters - will fail for GEN_DATA of type DYNAMIC_STATE. */
    int target_report_step  = 0;
    state_enum target_state = ANALYZED;
    bool_vector_type * iactive = bool_vector_alloc( 0 , true );

    enkf_main_copy_ensemble(enkf_main,
                            source_case_fs,
                            source_report_step,
                            source_state,
                            target_case_fs,
                            target_report_step,
                            target_state ,
                            iactive,
                            NULL,
                            param_list);


    enkf_fs_fsync(target_case_fs);

    bool_vector_free(iactive);
    stringlist_free(param_list);
}
Пример #14
0
static bool_vector_type * alloc_mask( const int_vector_type * active_list ) {
  bool_vector_type * mask = bool_vector_alloc( 0 , false );
  int i;
  for (i=0; i < int_vector_size( active_list ); i++) 
    bool_vector_iset( mask , int_vector_iget( active_list , i) , true );

  return mask;
}
Пример #15
0
void enkf_tui_run_start(void * enkf_main) {
  const int ens_size = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive = bool_vector_alloc(ens_size , true);

  enkf_main_run_assimilation(enkf_main , iactive , 0 , 0 , ANALYZED);
  
  bool_vector_free(iactive);
}
Пример #16
0
ecl_sum_vector_type * ecl_sum_vector_alloc(const ecl_sum_type * ecl_sum){
    ecl_sum_vector_type * ecl_sum_vector = util_malloc( sizeof * ecl_sum_vector );
    UTIL_TYPE_ID_INIT( ecl_sum_vector , ECL_SUM_VECTOR_TYPE_ID);
    ecl_sum_vector->ecl_sum  = ecl_sum;
    ecl_sum_vector->node_index_list = int_vector_alloc(0,0);
    ecl_sum_vector->is_rate_list  = bool_vector_alloc(0,false);
    return ecl_sum_vector;
}
Пример #17
0
void create_runpath(enkf_main_type * enkf_main ) {
  const int ens_size         = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive = bool_vector_alloc(0,false);

  bool_vector_iset( iactive , ens_size - 1 , true );
  enkf_main_run_exp(enkf_main , iactive , false );
  bool_vector_free(iactive);
}
Пример #18
0
gen_data_type * gen_data_alloc(const gen_data_config_type * config) {
  gen_data_type * gen_data = util_malloc(sizeof * gen_data);
  gen_data->config              = (gen_data_config_type *) config;
  gen_data->data                = NULL;
  gen_data->__type_id           = GEN_DATA;
  gen_data->active_mask         = bool_vector_alloc( 0 , true );
  gen_data->current_report_step = -1;  /* God - if you ever read this .... */
  return gen_data;
}
Пример #19
0
void test_invalid_obs_vector( enkf_main_type * enkf_main , const char * obs_key) {
  enkf_fs_type * fs = enkf_main_get_fs(enkf_main);
  enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main );
  obs_vector_type * obs_vector = enkf_obs_get_vector( enkf_obs , obs_key );
  bool_vector_type * active_mask = bool_vector_alloc( enkf_main_get_ensemble_size( enkf_main ) , true);

  test_assert_false( obs_vector_has_data( obs_vector , active_mask , fs ));
  bool_vector_free( active_mask );
}
Пример #20
0
void * enkf_main_assimilation_JOB( void * self , const stringlist_type * args ) {
  enkf_main_type   * enkf_main = enkf_main_safe_cast( self );
  int ens_size                 = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive   = bool_vector_alloc( 0 , true );

  bool_vector_iset( iactive , ens_size - 1 , true );
  enkf_main_run_assimilation( enkf_main , iactive , 0 , 0 ,  ANALYZED );
  return NULL;
}
Пример #21
0
void misfit_ensemble_initialize( misfit_ensemble_type * misfit_ensemble ,
                                 const ensemble_config_type * ensemble_config ,
                                 const enkf_obs_type * enkf_obs ,
                                 enkf_fs_type * fs ,
                                 int ens_size ,
                                 int history_length,
                                 bool force_init) {

    if (force_init || !misfit_ensemble->initialized) {
        misfit_ensemble_clear( misfit_ensemble );

        msg_type * msg                 = msg_alloc("Evaluating misfit for observation: " , false);
        double ** chi2_work            = __2d_malloc( history_length + 1 , ens_size );
        bool_vector_type * iens_valid  = bool_vector_alloc( ens_size , true );

        hash_iter_type * obs_iter = enkf_obs_alloc_iter( enkf_obs );
        const char * obs_key      = hash_iter_get_next_key( obs_iter );

        misfit_ensemble->history_length = history_length;
        misfit_ensemble_set_ens_size( misfit_ensemble , ens_size );

        msg_show( msg );
        while (obs_key != NULL) {
            obs_vector_type * obs_vector = enkf_obs_get_vector( enkf_obs , obs_key );
            msg_update( msg , obs_key );

            bool_vector_reset( iens_valid );
            bool_vector_iset( iens_valid , ens_size - 1 , true );
            obs_vector_ensemble_chi2( obs_vector ,
                                      fs ,
                                      iens_valid ,
                                      0 ,
                                      misfit_ensemble->history_length,
                                      0 ,
                                      ens_size ,
                                      chi2_work);

            /**
                Internalizing the results from the chi2_work table into the misfit structure.
            */
            for (int iens = 0; iens < ens_size; iens++) {
                misfit_member_type * node = misfit_ensemble_iget_member( misfit_ensemble , iens );
                if (bool_vector_iget( iens_valid , iens))
                    misfit_member_update( node , obs_key , misfit_ensemble->history_length , iens , (const double **) chi2_work);
            }
            obs_key = hash_iter_get_next_key( obs_iter );
        }

        bool_vector_free( iens_valid );
        msg_free(msg , true );
        hash_iter_free( obs_iter );

        __2d_free( chi2_work , misfit_ensemble->history_length + 1);
        misfit_ensemble->initialized = true;
    }
}
Пример #22
0
void test_container( ert_test_context_type * test_context ) {
  enkf_main_type * enkf_main = ert_test_context_get_main( test_context );
  enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main );
  obs_vector_type * rft_obs = enkf_obs_get_vector( enkf_obs , "RFT_TEST");
  enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
  bool_vector_type * active_mask = bool_vector_alloc( enkf_main_get_ensemble_size( enkf_main ) , true );

  test_assert_true( obs_vector_has_data( rft_obs , active_mask , fs ));
  bool_vector_free( active_mask );
}
Пример #23
0
void create_runpath(enkf_main_type * enkf_main ) {
  const int ens_size         = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive = bool_vector_alloc(0,false);

  state_enum init_state    = ANALYZED; 
  int start_report         = 0;
  int init_step_parameters = 0;
  bool_vector_iset( iactive , ens_size - 1 , true );
  enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state);
  bool_vector_free(iactive);
}
Пример #24
0
void * enkf_main_smoother_JOB( void * self , const stringlist_type * args ) {
  enkf_main_type   * enkf_main = enkf_main_safe_cast( self );
  int ens_size                 = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive   = bool_vector_alloc( 0 , true );
  bool rerun                   = true;
  const char * target_case     = stringlist_iget( args , 0 );
  
  bool_vector_iset( iactive , ens_size - 1 , true );
  enkf_main_run_smoother( enkf_main , target_case , rerun);
  return NULL;
}
Пример #25
0
void enkf_main_initialize_from_scratch(enkf_main_type * enkf_main , const stringlist_type * param_list , int iens1 , int iens2, init_mode_type init_mode) {
    int iens;
    int ens_size = enkf_main_get_ensemble_size( enkf_main );
    bool_vector_type * iens_mask = bool_vector_alloc(ens_size,false);

    for (iens = iens1; iens <= iens2; iens++) {
        bool_vector_iset( iens_mask , iens , true );
    }
    enkf_main_initialize_from_scratch_with_bool_vector(enkf_main, param_list, iens_mask, init_mode);
    bool_vector_free(iens_mask);
}
Пример #26
0
void * enkf_main_ensemble_run_JOB( void * self , const stringlist_type * args ) {
  enkf_main_type   * enkf_main = enkf_main_safe_cast( self );
  int ens_size                 = enkf_main_get_ensemble_size( enkf_main );
  bool_vector_type * iactive   = bool_vector_alloc( 0 , true );

  // Ignore args until string_utils is in place ..... 
  // if (stringlist_get_size( args ) 

  bool_vector_iset( iactive , ens_size - 1 , true );
  enkf_main_run_exp( enkf_main , iactive , true , 0 , 0 , ANALYZED );
  return NULL;
}
Пример #27
0
model_config_type * model_config_alloc() {
  model_config_type * model_config  = util_malloc(sizeof * model_config );
  /**
     There are essentially three levels of initialisation:

     1. Initialize to NULL / invalid.
     2. Initialize with default values.
     3. Initialize with user supplied values.

  */
  UTIL_TYPE_ID_INIT(model_config , MODEL_CONFIG_TYPE_ID);
  model_config->case_names                = NULL;
  model_config->enspath                   = NULL;
  model_config->rftpath                   = NULL;
  model_config->dbase_type                = INVALID_DRIVER_ID;
  model_config->current_runpath           = NULL;
  model_config->current_path_key          = NULL;
  model_config->enkf_sched                = NULL;
  model_config->enkf_sched_file           = NULL;   
  model_config->case_table_file           = NULL;
  model_config->select_case               = NULL;    
  model_config->history                   = NULL;
  model_config->jobname_fmt               = NULL;
  model_config->forward_model             = NULL;
  model_config->internalize_state         = bool_vector_alloc( 0 , false );
  model_config->__load_state              = bool_vector_alloc( 0 , false ); 
  model_config->history_source            = HISTORY_SOURCE_INVALID;
  model_config->runpath_map               = hash_alloc(); 
  model_config->gen_kw_export_file_name   = NULL;

  model_config_set_enspath( model_config        , DEFAULT_ENSPATH );
  model_config_set_rftpath( model_config        , DEFAULT_RFTPATH );
  model_config_set_dbase_type( model_config     , DEFAULT_DBASE_TYPE );
  model_config_set_max_internal_submit( model_config   , DEFAULT_MAX_INTERNAL_SUBMIT);
  model_config_add_runpath( model_config , DEFAULT_RUNPATH_KEY , DEFAULT_RUNPATH);
  model_config_select_runpath( model_config , DEFAULT_RUNPATH_KEY );
  model_config_set_gen_kw_export_file(model_config, DEFAULT_GEN_KW_EXPORT_FILE);
  
  return model_config;
}
Пример #28
0
void ecl_sum_fprintf(const ecl_sum_type * ecl_sum , FILE * stream , const stringlist_type * var_list , bool report_only , const ecl_sum_fmt_type * fmt) {
  bool_vector_type  * has_var   = bool_vector_alloc( stringlist_get_size( var_list ), false );
  int_vector_type   * var_index = int_vector_alloc( stringlist_get_size( var_list ), -1 );
  char * date_string            = util_malloc( DATE_STRING_LENGTH * sizeof * date_string);

  char * current_locale = NULL;
  if (fmt->locale != NULL)
    current_locale = setlocale(LC_NUMERIC , fmt->locale);

  {
    int ivar;
    for (ivar = 0; ivar < stringlist_get_size( var_list ); ivar++) {
      if (ecl_sum_has_general_var( ecl_sum , stringlist_iget( var_list , ivar) )) {
        bool_vector_iset( has_var , ivar , true );
        int_vector_iset( var_index , ivar , ecl_sum_get_general_var_params_index( ecl_sum , stringlist_iget( var_list , ivar) ));
      } else {
        fprintf(stderr,"** Warning: could not find variable: \'%s\' in summary file \n", stringlist_iget( var_list , ivar));
        bool_vector_iset( has_var , ivar , false );
      }
    }
  }

  if (fmt->print_header)
    ecl_sum_fprintf_header( ecl_sum , var_list , has_var , stream , fmt);

  if (report_only) {
    int first_report = ecl_sum_get_first_report_step( ecl_sum );
    int last_report  = ecl_sum_get_last_report_step( ecl_sum );
    int report;

    for (report = first_report; report <= last_report; report++) {
      if (ecl_sum_data_has_report_step(ecl_sum->data , report)) {
        int time_index;
        time_index = ecl_sum_data_iget_report_end( ecl_sum->data , report );
        __ecl_sum_fprintf_line( ecl_sum , stream , time_index , has_var , var_index , date_string , fmt);
      }
    }
  } else {
    int time_index;
    for (time_index = 0; time_index < ecl_sum_get_data_length( ecl_sum ); time_index++)
      __ecl_sum_fprintf_line( ecl_sum , stream , time_index , has_var , var_index , date_string , fmt);
  }

  int_vector_free( var_index );
  bool_vector_free( has_var );
  if (current_locale != NULL)
    setlocale( LC_NUMERIC , current_locale);
  free( date_string );
}
Пример #29
0
/*
(defun insert-curly ()
 (interactive)
 (insert "{}"))
*/
void enkf_config_node_set_internalize(enkf_config_node_type * node, int report_step) {
  ert_impl_type impl_type = enkf_config_node_get_impl_type( node );
  if (impl_type == CONTAINER) {
    int inode;
    int container_size = enkf_config_node_container_size( node );
    for (inode == 0; inode < container_size; inode++) {
      enkf_config_node_type * child_node = enkf_config_node_container_iget( node , inode );
      enkf_config_node_set_internalize( child_node , report_step );
    }
  } else {
    if (node->internalize == NULL)
      node->internalize = bool_vector_alloc( 0 , false );
    bool_vector_iset( node->internalize , report_step , true);
  }
}
Пример #30
0
static stepwise_type * stepwise_alloc__( int nsample , int nvar , rng_type * rng) {
    stepwise_type * stepwise = util_malloc( sizeof * stepwise );

    stepwise->X_mean      = NULL;
    stepwise->X_norm      = NULL;
    stepwise->Y_mean      = 0.0;
    stepwise->rng         = rng;
    stepwise->X0          = NULL;
    stepwise->E0          = NULL;
    stepwise->Y0          = NULL;
    stepwise->active_set  = bool_vector_alloc( nvar , true );
    stepwise->beta        = matrix_alloc( nvar , 1 );

    return stepwise;
}