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