void * enkf_main_std_scale_correlated_obs_JOB(void * self, const stringlist_type * args) { if (stringlist_get_size(args) > 0) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); int ensemble_size = enkf_main_get_ensemble_size(enkf_main); enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); enkf_obs_type * obs = enkf_main_get_obs( enkf_main ); int_vector_type * realizations = int_vector_alloc(1, 0); local_obsdata_type * obsdata = local_obsdata_alloc( "OBS-JOB" ); int_vector_init_range(realizations, 0, ensemble_size, 1); for (int iarg = 0; iarg < stringlist_get_size(args); iarg++) { const char * arg_key = stringlist_iget( args , iarg ); stringlist_type * key_list = enkf_obs_alloc_matching_keylist(obs, arg_key); for (int iobs=0; iobs < stringlist_get_size( key_list ); iobs++) { const char * obs_key = stringlist_iget( key_list , iobs); const obs_vector_type * obs_vector = enkf_obs_get_vector(obs, obs_key); local_obsdata_add_node( obsdata , obs_vector_alloc_local_node(obs_vector) ); } stringlist_free( key_list ); } if (local_obsdata_get_size(obsdata) > 0) enkf_obs_scale_correlated_std(obs, fs, realizations, obsdata ); local_obsdata_free( obsdata ); } return NULL; }
void test_measure( ert_test_context_type * test_context ) { enkf_main_type * enkf_main = ert_test_context_get_main( test_context ); enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main ); obs_vector_type * rft_obs = enkf_obs_get_vector( enkf_obs , "RFT_TEST"); int_vector_type * ens_active_list = int_vector_alloc(0,0); active_list_type * active_list = active_list_alloc( ); meas_data_type * meas_data_RFT; for (int i=0; i < enkf_main_get_ensemble_size( enkf_main ); i++) int_vector_append( ens_active_list , i ); { bool_vector_type * ens_mask; ens_mask = int_vector_alloc_mask( ens_active_list ); meas_data_RFT = meas_data_alloc( ens_mask ); bool_vector_free( ens_mask ); } obs_vector_measure( rft_obs , fs , 20 , ens_active_list , meas_data_RFT , active_list ); int_vector_free( ens_active_list ); active_list_free( active_list ); meas_data_free( meas_data_RFT ); }
void * enkf_main_rank_on_observations_JOB(void * self, const stringlist_type * args) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); const char * ranking_name = stringlist_iget(args, 0); bool step_arguments = false; bool obs_arguments = false; int delimiter = 0; { delimiter = stringlist_find_first(args, "|"); if (delimiter > -1) { step_arguments = (delimiter > 1) ? true : false; obs_arguments = (stringlist_get_size(args) > delimiter + 1) ? true : false; } else if (stringlist_get_size(args) > 1) { step_arguments = true; delimiter = stringlist_get_size(args); } } int_vector_type * steps_vector = NULL; { char * report_steps = NULL; if (step_arguments) report_steps = stringlist_alloc_joined_substring(args, 1, delimiter, ","); else report_steps = util_alloc_sprintf("0-%d", enkf_main_get_history_length(enkf_main)); steps_vector = string_util_alloc_value_list(report_steps); free(report_steps); } stringlist_type * obs_ranking_keys = NULL; { char * obs_key_char = NULL; if (obs_arguments) obs_key_char = stringlist_alloc_joined_substring( args , delimiter+1 , stringlist_get_size(args) , " "); enkf_obs_type * enkf_obs = enkf_main_get_obs(enkf_main); obs_ranking_keys = enkf_obs_alloc_matching_keylist( enkf_obs , obs_key_char ); if ((obs_arguments) && (stringlist_get_size(obs_ranking_keys) == 0)) { fprintf(stderr,"The input string : \"%s\" did not resolve to any valid observation keys. Job not started\n", obs_key_char); return NULL; } if (obs_arguments) free(obs_key_char); } enkf_main_rank_on_observations(enkf_main, ranking_name, obs_ranking_keys, steps_vector); stringlist_free(obs_ranking_keys); int_vector_free(steps_vector); return NULL; }
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 ); }
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 ); }
void enkf_tui_analysis_scale_observation_std__(void * arg) { enkf_main_type * enkf_main = enkf_main_safe_cast(arg); double scale_factor = enkf_tui_util_scanf_double_with_lower_limit("Global scaling factor", PROMPT_LEN, 0); if (enkf_main_have_obs(enkf_main)) { enkf_obs_type * observations = enkf_main_get_obs(enkf_main); enkf_obs_scale_std(observations, scale_factor); } }
void test_iget(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 ); test_assert_int_equal( 32 , enkf_obs_get_size( enkf_obs ) ); for (int iobs = 0; iobs < enkf_obs_get_size( enkf_obs ); iobs++) { obs_vector_type * vec1 = enkf_obs_iget_vector( enkf_obs , iobs ); obs_vector_type * vec2 = enkf_obs_get_vector( enkf_obs , obs_vector_get_key( vec1 )); test_assert_ptr_equal( vec1 , vec2 ); } }
void * enkf_main_scale_obs_std_JOB(void * self, const stringlist_type * args ) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); double scale_factor; util_sscanf_double(stringlist_iget(args, 0), &scale_factor); if (enkf_main_have_obs(enkf_main)) { enkf_obs_type * observations = enkf_main_get_obs(enkf_main); enkf_obs_scale_std(observations, scale_factor); } return NULL; }
void test_gendata( enkf_main_type * enkf_main , const char * obs_key , int report_step ) { enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main ); obs_vector_type * obs_vector = enkf_obs_get_vector( enkf_obs , obs_key); { enkf_plot_gendata_type * gen_data = enkf_plot_gendata_alloc_from_obs_vector( obs_vector ); enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); gen_obs_type * gen_obs = obs_vector_iget_node( obs_vector , report_step ); { double value; double std; bool valid; gen_obs_user_get_with_data_index(gen_obs , "0" , &value , &std , &valid ); test_assert_double_equal( 0.143841 , value ); test_assert_double_equal( 0.0300 , std ); test_assert_true( valid ); } enkf_plot_gendata_load(gen_data, fs, report_step, FORECAST, NULL); test_assert_int_equal( enkf_main_get_ensemble_size( enkf_main ) , enkf_plot_gendata_get_size( gen_data )); { enkf_plot_genvector_type * vector = enkf_plot_gendata_iget( gen_data , 24); test_assert_true( enkf_plot_genvector_is_instance( vector )); test_assert_double_equal( 0.675537 , enkf_plot_genvector_iget( vector , 0 )); test_assert_double_equal( 0.682635 , enkf_plot_genvector_iget( vector , 1 )); test_assert_double_equal( 0.616371 , enkf_plot_genvector_iget( vector , 2 )); } { enkf_plot_genvector_type * vector = enkf_plot_gendata_iget( gen_data , 9 ); test_assert_true( enkf_plot_genvector_is_instance( vector )); test_assert_double_equal( -0.515033 , enkf_plot_genvector_iget( vector , 0 )); test_assert_double_equal( -0.507350 , enkf_plot_genvector_iget( vector , 1 )); test_assert_double_equal( -0.541030 , enkf_plot_genvector_iget( vector , 2 )); } enkf_plot_gendata_free( gen_data ); } }
void * enkf_main_init_misfit_table_JOB(void * self, const stringlist_type * args) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); int history_length = enkf_main_get_history_length(enkf_main); enkf_obs_type * enkf_obs = enkf_main_get_obs(enkf_main); int ens_size = enkf_main_get_ensemble_size(enkf_main); enkf_fs_type * fs = enkf_main_get_fs(enkf_main); bool force_update = true; const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main); misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs ); misfit_ensemble_initialize( misfit_ensemble , ensemble_config , enkf_obs , fs , ens_size , history_length, force_update); return NULL; }
static void enkf_tui_ranking_create_obs( void * arg ) { enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main ); enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs ); if (!misfit_ensemble_initialized( misfit_ensemble )) { fprintf(stderr,"Sorry: must initialzie the misfit table first \n"); return; } else { ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main ); const int history_length = enkf_main_get_history_length( enkf_main ); const int prompt_len = 50; const char * prompt1 = "Observations to use for ranking"; const char * prompt2 = "Name to store ranking under"; const char * store_prompt = "Name of file to store ranking"; int step1,step2; stringlist_type * ranking_keys; char * obs_keys_input; char * ranking_key; char * ranking_file; util_printf_prompt(prompt1 , prompt_len , '=' , "=> "); obs_keys_input = util_alloc_stdin_line(); ranking_keys = enkf_obs_alloc_matching_keylist( enkf_obs , obs_keys_input ); enkf_tui_util_scanf_report_steps(history_length , prompt_len , &step1 , &step2); util_printf_prompt(prompt2 , prompt_len , '=' , "=> "); ranking_key = util_alloc_stdin_line(); if (ranking_key == NULL) ranking_key = util_alloc_string_copy( MISFIT_DEFAULT_RANKING_KEY ); util_printf_prompt(store_prompt , prompt_len , '=' , "=> "); ranking_file = util_alloc_stdin_line(); if (stringlist_get_size( ranking_keys ) > 0) { ranking_table_add_misfit_ranking( ranking_table , misfit_ensemble , ranking_keys , step1 , step2 , ranking_key ); ranking_table_display_ranking( ranking_table , ranking_key); } else fprintf(stderr,"The input string : \"%s\" did not resolve to any valid observation keys \n", obs_keys_input); free( obs_keys_input ); stringlist_free( ranking_keys ); free( ranking_key ); util_safe_free( ranking_file ); } }
static void enkf_tui_ranking_make_misfit_ensemble( void * arg) { arg_pack_type * arg_pack = arg_pack_safe_cast( arg ); enkf_main_type * enkf_main = arg_pack_iget_ptr( arg_pack , 0 ); enkf_fs_type * fs = enkf_main_get_fs(enkf_main); enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main ); const ensemble_config_type * ensemble_config = enkf_main_get_ensemble_config(enkf_main); const int history_length = enkf_main_get_history_length( enkf_main ); const int ens_size = enkf_main_get_ensemble_size( enkf_main ); misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs ); misfit_ensemble_update( misfit_ensemble , ensemble_config , enkf_obs , fs , ens_size , history_length ); { menu_item_type * obs_item = arg_pack_iget_ptr( arg_pack , 1 ); menu_item_enable( obs_item ); } }
void testS( 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 ); enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); int_vector_type * active_list = int_vector_alloc(0,0); obs_data_type * obs_data = obs_data_alloc(1.0); local_obsdata_type * obs_set = local_obsdata_alloc( "KEY" ); bool_vector_type * ens_mask; meas_data_type * meas_data; for (int i= 0; i < enkf_main_get_ensemble_size( enkf_main); i++) int_vector_append( active_list , i ); ens_mask = int_vector_alloc_mask( active_list); obs_data = obs_data_alloc(1.0); meas_data = meas_data_alloc( ens_mask ); enkf_obs_add_local_nodes_with_data( enkf_obs , obs_set , fs , ens_mask ); enkf_obs_get_obs_and_measure_data( enkf_obs , fs , obs_set, FORECAST , active_list , meas_data , obs_data); { FILE * stream = util_fopen("analysis/Smatrix" , "r"); matrix_type * S = meas_data_allocS( meas_data ); matrix_type * S0 = matrix_fread_alloc( stream ); test_assert_true( matrix_equal( S0 , S )); matrix_free( S ); matrix_free( S0 ); fclose( stream ); } int_vector_free( active_list ); meas_data_free( meas_data ); obs_data_free( obs_data ); local_obsdata_free( obs_set ); bool_vector_free( ens_mask ); } }