void test_init_case_job(ert_test_context_type * test_context, const char * job_name , const char * job_file) {
stringlist_type * args = stringlist_alloc_new();
enkf_main_type * enkf_main = ert_test_context_get_main(test_context);
test_assert_true( ert_test_context_install_workflow_job( test_context , "JOB" , job_file ) );
//Test init current case from existing
{
enkf_fs_type * cur_fs = enkf_main_mount_alt_fs( enkf_main , "new_current_case" , true );
enkf_main_select_fs(enkf_main, "new_current_case");
test_assert_ptr_not_equal(cur_fs , enkf_main_get_fs( enkf_main ));
stringlist_append_copy( args, "default"); //case to init from
test_assert_true( ert_test_context_run_worklow_job( test_context , "JOB" , args) );
enkf_fs_decref(cur_fs);
}
{
const char * current_case = enkf_main_get_current_fs( enkf_main );
test_assert_string_equal(current_case, "new_current_case");
test_assert_true(enkf_fs_has_node(enkf_main_get_fs(enkf_main), "PERMZ", PARAMETER, 0, 0, ANALYZED));
enkf_fs_type * default_fs = enkf_main_mount_alt_fs( enkf_main , "default" , true );
state_map_type * default_state_map = enkf_fs_get_state_map(default_fs);
state_map_type * current_state_map = enkf_fs_get_state_map(enkf_main_get_fs(enkf_main));
test_assert_int_equal(state_map_get_size(default_state_map), state_map_get_size(current_state_map));
enkf_fs_decref(default_fs);
}
//Test init case from existing case:
stringlist_clear(args);
stringlist_append_copy(args, "default"); //case to init from
stringlist_append_copy(args, "new_not_current_case");
test_assert_true( ert_test_context_run_worklow_job( test_context , "JOB" , args) );
{
enkf_fs_type * fs = enkf_main_mount_alt_fs(enkf_main, "new_not_current_case", true);
test_assert_not_NULL( fs );
test_assert_true( enkf_fs_has_node(fs, "PERMZ", PARAMETER, 0, 0, ANALYZED ));
enkf_fs_type * default_fs = enkf_main_mount_alt_fs( enkf_main , "default" , true );
state_map_type * default_state_map = enkf_fs_get_state_map(default_fs);
state_map_type * new_state_map = enkf_fs_get_state_map(fs);
test_assert_int_equal(state_map_get_size(default_state_map), state_map_get_size(new_state_map));
enkf_fs_decref(fs);
}
stringlist_free( args );
}
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 );
}
}
}
}
static void enkf_main_copy_ensemble( 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,
int target_report_step,
state_enum target_state,
const bool_vector_type * iens_mask,
const char * ranking_key , /* It is OK to supply NULL - but if != NULL it must exist */
const stringlist_type * node_list) {
const int ens_size = enkf_main_get_ensemble_size( enkf_main );
state_map_type * target_state_map = enkf_fs_get_state_map(target_case_fs);
{
int * ranking_permutation;
int inode , src_iens;
if (ranking_key != NULL) {
ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main );
ranking_permutation = (int *) ranking_table_get_permutation( ranking_table , ranking_key );
} else {
ranking_permutation = util_calloc( ens_size , sizeof * ranking_permutation );
for (src_iens = 0; src_iens < ens_size; src_iens++)
ranking_permutation[src_iens] = src_iens;
}
for (inode =0; inode < stringlist_get_size( node_list ); inode++) {
enkf_config_node_type * config_node = ensemble_config_get_node( enkf_main_get_ensemble_config(enkf_main) , stringlist_iget( node_list , inode ));
for (src_iens = 0; src_iens < enkf_main_get_ensemble_size( enkf_main ); src_iens++) {
if (bool_vector_safe_iget(iens_mask , src_iens)) {
int target_iens = ranking_permutation[src_iens];
node_id_type src_id = {.report_step = source_report_step , .iens = src_iens , .state = source_state };
node_id_type target_id = {.report_step = target_report_step , .iens = target_iens , .state = target_state };
/* The copy is careful ... */
if (enkf_config_node_has_node( config_node , source_case_fs , src_id))
enkf_node_copy( config_node ,
source_case_fs , target_case_fs ,
src_id , target_id );
if (0 == target_report_step)
state_map_iset(target_state_map, target_iens, STATE_INITIALIZED);
}
}
}
if (ranking_permutation == NULL)
free( ranking_permutation );
}
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
const char * root_path = argv[1];
const char * config_file = argv[2];
const char * init_file = argv[3];
const char * forward_init_string = argv[4];
test_work_area_type * work_area = test_work_area_alloc(config_file );
test_work_area_copy_directory_content( work_area , root_path );
test_work_area_install_file( work_area , init_file );
{
bool forward_init;
bool strict = true;
enkf_main_type * enkf_main;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
util_clear_directory( "Storage" , true , true );
enkf_main = enkf_main_bootstrap( config_file , strict , true );
{
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_node_type * surface_node = enkf_state_get_node( state , "SURFACE" );
{
const enkf_config_node_type * surface_config_node = enkf_node_get_config( surface_node );
char * init_file1 = enkf_config_node_alloc_initfile( surface_config_node , NULL , 0);
char * init_file2 = enkf_config_node_alloc_initfile( surface_config_node , "/tmp", 0);
test_assert_bool_equal( enkf_config_node_use_forward_init( surface_config_node ) , forward_init );
test_assert_string_equal( init_file1 , "Surface.irap");
test_assert_string_equal( init_file2 , "/tmp/Surface.irap");
free( init_file1 );
free( init_file2 );
}
test_assert_bool_equal( enkf_node_use_forward_init( surface_node ) , forward_init );
if (forward_init)
test_assert_bool_not_equal( enkf_node_initialize( surface_node , 0 , enkf_state_get_rng( state )) , forward_init);
// else hard_failure()
}
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
if (forward_init) {
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
run_arg_type * run_arg = run_arg_alloc_ENSEMBLE_EXPERIMENT( fs , 0 ,0 , "simulations/run0");
enkf_node_type * surface_node = enkf_state_get_node( state , "SURFACE" );
node_id_type node_id = {.report_step = 0 ,
.iens = 0,
.state = ANALYZED };
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
{
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
test_assert_false( enkf_node_has_data( surface_node , fs, node_id ));
util_unlink_existing( "simulations/run0/Surface.irap" );
test_assert_false( enkf_node_forward_init( surface_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , run_arg , &error );
test_assert_true(LOAD_FAILURE & error);
error = 0;
{
enkf_fs_type * fs = enkf_main_get_fs(enkf_main);
state_map_type * state_map = enkf_fs_get_state_map(fs);
state_map_iset(state_map, 0, STATE_INITIALIZED);
}
enkf_state_load_from_forward_model(state, run_arg , &error, false, msg_list);
stringlist_free( msg_list );
test_assert_true(LOAD_FAILURE & error);
}
util_copy_file( init_file , "simulations/run0/Surface.irap");
{
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
test_assert_true( enkf_node_forward_init( surface_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , run_arg , &error );
test_assert_int_equal(0, error);
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
test_assert_int_equal(0, error);
{
double value;
test_assert_true( enkf_node_user_get( surface_node , fs , "0" , node_id , &value));
test_assert_double_equal( 2735.7461 , value);
test_assert_true( enkf_node_user_get( surface_node , fs , "5" , node_id , &value));
test_assert_double_equal( 2737.0122 , value);
}
}
util_clear_directory( "simulations" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
test_assert_true( util_is_file( "simulations/run0/SURFACE.INC" ));
test_assert_true( enkf_node_fload( surface_node , "simulations/run0/SURFACE.INC"));
{
double value;
test_assert_true( enkf_node_user_get( surface_node , fs , "0" , node_id , &value));
test_assert_double_equal( 2735.7461 , value);
test_assert_true( enkf_node_user_get( surface_node , fs , "5" , node_id , &value));
test_assert_double_equal( 2737.0122 , value);
}
util_clear_directory( "simulations" , true , true );
}
enkf_main_free( enkf_main );
}
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
const char * root_path = argv[1];
const char * config_file = argv[2];
const char * forward_init_string = argv[3];
test_work_area_type * work_area = test_work_area_alloc(config_file );
test_work_area_copy_directory_content( work_area , root_path );
{
bool forward_init;
bool strict = true;
enkf_main_type * enkf_main;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
util_clear_directory( "Storage" , true , true );
enkf_main = enkf_main_bootstrap( NULL , config_file , strict , true );
{
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_node_type * gen_kw_node = enkf_state_get_node( state , "MULTFLT" );
{
const enkf_config_node_type * gen_kw_config_node = enkf_node_get_config( gen_kw_node );
char * init_file1 = enkf_config_node_alloc_initfile( gen_kw_config_node , NULL , 0);
char * init_file2 = enkf_config_node_alloc_initfile( gen_kw_config_node , "/tmp", 0);
test_assert_bool_equal( enkf_config_node_use_forward_init( gen_kw_config_node ) , forward_init );
test_assert_string_equal( init_file1 , "MULTFLT_INIT");
test_assert_string_equal( init_file2 , "/tmp/MULTFLT_INIT");
free( init_file1 );
free( init_file2 );
}
test_assert_bool_equal( enkf_node_use_forward_init( gen_kw_node ) , forward_init );
if (forward_init)
test_assert_bool_not_equal( enkf_node_initialize( gen_kw_node , 0 , enkf_state_get_rng( state )) , forward_init);
// else hard_failure()
}
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
if (forward_init) {
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
run_arg_type * run_arg = run_arg_alloc_ENSEMBLE_EXPERIMENT( fs , 0 , 0 , "simulations/run0");
enkf_node_type * gen_kw_node = enkf_state_get_node( state , "MULTFLT" );
node_id_type node_id = {.report_step = 0 ,
.iens = 0,
.state = ANALYZED };
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
{
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
bool_vector_type * iactive = bool_vector_alloc( enkf_main_get_ensemble_size( enkf_main ) , true);
test_assert_false( enkf_node_has_data( gen_kw_node , fs, node_id ));
util_unlink_existing( "simulations/run0/MULTFLT_INIT" );
test_assert_false( enkf_node_forward_init( gen_kw_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , run_arg , &error );
test_assert_true(LOAD_FAILURE & error);
error = 0;
{
enkf_fs_type * fs = enkf_main_get_fs( enkf_main );
state_map_type * state_map = enkf_fs_get_state_map(fs);
state_map_iset(state_map , 0 , STATE_INITIALIZED);
}
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
bool_vector_free( iactive );
test_assert_true(LOAD_FAILURE & error);
}
{
FILE * stream = util_fopen("simulations/run0/MULTFLT_INIT" , "w");
fprintf(stream , "123456.0\n" );
fclose( stream );
}
{
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
test_assert_true( enkf_node_forward_init( gen_kw_node , "simulations/run0" , 0 ));
enkf_state_forward_init( state , run_arg , &error );
test_assert_int_equal(0, error);
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
test_assert_int_equal(0, error);
{
double value;
test_assert_true( enkf_node_user_get( gen_kw_node , fs , "MULTFLT" , node_id , &value));
test_assert_double_equal( 123456.0 , value);
}
}
test_assert_true( util_is_file ("simulations/run0/parameters.txt")); //Export of gen kw params
util_clear_directory( "simulations" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
test_assert_true( util_is_file( "simulations/run0/MULTFLT.INC" ));
{
FILE * stream = util_fopen("simulations/run0/MULTFLT.INC" , "r");
double value;
fscanf(stream , "%lg" , &value);
fclose( stream );
test_assert_double_equal( 123456.0 , value);
}
util_clear_directory( "simulations" , true , true );
run_arg_free( run_arg );
}
enkf_main_free( enkf_main );
}
test_work_area_free( work_area );
}
int main(int argc, char ** argv) {
const char * config_file = argv[1];
test_work_area_type * work_area = test_work_area_alloc( "enkf_main_fs" );
char * model_config;
util_alloc_file_components( config_file , NULL , &model_config , NULL);
test_work_area_copy_parent_content( work_area , config_file );
{
const char * site_config = "/project/res/etc/ERT/site-config";
enkf_main_type * enkf_main = enkf_main_bootstrap( site_config , model_config , false , false );
enkf_main_select_fs( enkf_main , "enkf");
test_assert_true( enkf_main_case_is_current( enkf_main , "enkf"));
test_assert_false( enkf_main_case_is_current( enkf_main , "default_fs"));
test_assert_false( enkf_main_case_is_current( enkf_main , "does_not_exist"));
test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
{
enkf_fs_type * fs_ref = enkf_main_get_fs_ref( enkf_main );
test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
enkf_fs_decref( fs_ref );
test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
}
{
state_map_type * map1 = enkf_fs_get_state_map( enkf_main_get_fs( enkf_main ));
state_map_type * map2 = enkf_main_alloc_readonly_state_map(enkf_main , "enkf");
test_assert_true(state_map_equal( map1 , map2 ));
state_map_free( map2 );
}
{
enkf_fs_type * fs1 = enkf_main_mount_alt_fs( enkf_main , "default" , false );
enkf_fs_type * fs2 = enkf_main_mount_alt_fs( enkf_main , "enkf" , false );
test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
test_assert_int_equal( 2 , enkf_fs_get_refcount( fs2 ));
test_assert_int_equal( 1 , enkf_fs_get_refcount( fs1 ));
enkf_fs_decref( fs1 );
enkf_fs_decref( fs2 );
}
{
enkf_fs_type * enkf_fs = enkf_main_mount_alt_fs( enkf_main , "enkf" , false );
enkf_main_select_fs( enkf_main , "default");
test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
enkf_fs_decref( enkf_fs );
}
{
enkf_fs_type * default_fs = enkf_main_mount_alt_fs( enkf_main , "default" , false );
test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
enkf_main_select_fs( enkf_main , "default");
test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
enkf_fs_decref( default_fs );
test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
}
/*****************************************************************/
{
enkf_fs_type * fs = enkf_main_mount_alt_fs( enkf_main , "default" , false );
test_assert_int_equal( 2 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
enkf_main_set_fs( enkf_main , fs , NULL );
enkf_fs_decref( fs );
test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
}
{
enkf_fs_type * fs = enkf_main_mount_alt_fs( enkf_main , "enkf" , false );
enkf_fs_type * current = enkf_main_mount_alt_fs( enkf_main , "default" , false );
test_assert_int_equal( 2 , enkf_fs_get_refcount( current ));
test_assert_int_equal( 1 , enkf_fs_get_refcount( fs));
enkf_main_set_fs( enkf_main , fs , NULL);
test_assert_int_equal( 2 , enkf_fs_get_refcount( fs));
test_assert_int_equal( 1 , enkf_fs_get_refcount( current ));
enkf_fs_decref( current );
enkf_fs_decref( fs);
}
test_assert_int_equal( 1 , enkf_fs_get_refcount( enkf_main_get_fs( enkf_main )));
enkf_main_free( enkf_main );
}
test_work_area_free( work_area );
exit(0);
}
