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 );
}
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);
}
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);
}
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);
}
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 );
}
void data_ranking_free( data_ranking_type * ranking ) {
double_vector_free( ranking->data_ensemble );
bool_vector_free( ranking->valid );
util_safe_free( ranking->sort_permutation );
util_safe_free( ranking->user_key );
free( ranking );
}
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);
}
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;
}
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);
}
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 );
}
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 stepwise_free( stepwise_type * stepwise ) {
if (stepwise->active_set != NULL) {
bool_vector_free( stepwise->active_set );
}
if (stepwise->beta != NULL)
matrix_free( stepwise->beta );
if (stepwise->X_mean != NULL)
matrix_free( stepwise->X_mean );
if (stepwise->X_norm != NULL)
matrix_free( stepwise->X_norm );
if (stepwise->data_owner) {
matrix_free( stepwise->X0 );
matrix_free( stepwise->E0 );
matrix_free( stepwise->Y0 );
}
free( stepwise );
}
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);
}
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);
}
void well_rate_free( well_rate_type * well_rate ) {
free( well_rate->name );
double_vector_free( well_rate->shift );
double_vector_free( well_rate->mean_shift );
double_vector_free( well_rate->std_shift );
double_vector_free( well_rate->base_value );
bool_vector_free( well_rate->percent_std );
free( well_rate );
}
void sched_history_free( sched_history_type * sched_history ) {
time_t_vector_free( sched_history->time );
bool_vector_free( sched_history->historical );
hash_free( sched_history->well_history );
hash_free( sched_history->group_history );
hash_free( sched_history->index );
free( sched_history->sep_string );
free( sched_history );
}
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 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;
}
}
static void enkf_main_jobs_export_field(const enkf_main_type * enkf_main, const stringlist_type * args, field_file_format_type file_type) {
const char * field = stringlist_iget(args, 0);
const char * file_name = stringlist_iget(args, 1);
int report_step = 0;
util_sscanf_int(stringlist_iget(args,2), &report_step);
bool_vector_type * iactive = alloc_iactive_vector_from_range(args, 4, stringlist_get_size(args), enkf_main_get_ensemble_size(enkf_main));
enkf_main_export_field(enkf_main,field, file_name, iactive, file_type, report_step ) ;
bool_vector_free(iactive);
}
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_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 = alloc_iactive_vector_from_range(args, 0, stringlist_get_size(args), ens_size);
bool_vector_iset( iactive , ens_size - 1 , true );
enkf_main_run_exp( enkf_main , iactive , true );
bool_vector_free(iactive);
return NULL;
}
void gen_data_config_free(gen_data_config_type * config) {
int_vector_free( config->data_size_vector );
util_safe_free( config->key );
util_safe_free( config->template_buffer );
util_safe_free( config->template_file );
util_safe_free( config->template_key );
bool_vector_free( config->active_mask );
free(config);
}
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);
}
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);
}
void model_config_free(model_config_type * model_config) {
if (model_config->enkf_sched != NULL)
enkf_sched_free( model_config->enkf_sched );
free( model_config->enspath );
free( model_config->rftpath );
util_safe_free( model_config->jobname_fmt );
util_safe_free( model_config->enkf_sched_file );
util_safe_free( model_config->select_case );
util_safe_free( model_config->case_table_file );
util_safe_free( model_config->current_path_key);
if (model_config->history != NULL)
history_free(model_config->history);
if (model_config->forward_model != NULL)
forward_model_free(model_config->forward_model);
bool_vector_free(model_config->internalize_state);
bool_vector_free(model_config->__load_state);
hash_free(model_config->runpath_map);
if (model_config->case_names != NULL) stringlist_free( model_config->case_names );
free(model_config);
}
void ert_run_context_free( ert_run_context_type * context ) {
if (context->result_fs) {
enkf_fs_decrease_write_count(context->result_fs);
}
if (context->update_target_fs) {
enkf_fs_decrease_write_count(context->update_target_fs);
}
vector_free( context->run_args );
bool_vector_free( context->iactive );
int_vector_free( context->iens_map );
free( context );
}
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 );
}
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 );
test_work_area_set_store(work_area, true);
bool strict = true;
enkf_main_type * enkf_main = enkf_main_bootstrap( NULL , config_file , strict , true );
enkf_fs_type * init_fs = enkf_main_get_fs(enkf_main);
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
run_arg_type * run_arg = run_arg_alloc_ENSEMBLE_EXPERIMENT( init_fs , 0 ,0 , "simulations/run0");
enkf_node_type * field_node = enkf_state_get_node( state , "PORO" );
bool forward_init;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
test_assert_bool_equal( enkf_node_use_forward_init( field_node ) , forward_init );
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
util_clear_directory( "Storage" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
if (forward_init)
util_copy_file( init_file , "simulations/run0/petro.grdecl");
{
bool_vector_type * iactive = bool_vector_alloc( enkf_main_get_ensemble_size(enkf_main) , true);
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
bool_vector_free( iactive );
test_assert_int_equal(error, 0);
}
test_assert_true(check_original_exported_data_equal(field_node));
run_arg_free( run_arg );
enkf_main_free(enkf_main);
test_work_area_free(work_area);
}
static void enkf_main_jobs_export_field(const enkf_main_type * enkf_main, const stringlist_type * args, field_file_format_type file_type) {
const char * field = stringlist_iget(args, 0);
const char * file_name = stringlist_iget(args, 1);
int report_step = 0;
util_sscanf_int(stringlist_iget(args,2), &report_step);
state_enum state = enkf_types_get_state_enum(stringlist_iget(args, 3));
if (BOTH == state) {
fprintf(stderr,"** Field export jobs only supports state_enum ANALYZED or FORECAST, not BOTH.\n");
return;
}
bool_vector_type * iactive = alloc_iactive_vector_from_range(args, 4, stringlist_get_size(args), enkf_main_get_ensemble_size(enkf_main));
enkf_main_export_field(enkf_main,field, file_name, iactive, file_type, report_step, state) ;
bool_vector_free(iactive);
}
static void sched_history_realloc( sched_history_type * sched_history ) {
if (sched_history->well_history != NULL)
hash_free( sched_history->well_history );
sched_history->well_history = hash_alloc();
if (sched_history->group_history != NULL)
hash_free( sched_history->group_history );
sched_history->group_history = hash_alloc();
if (sched_history->historical != NULL)
bool_vector_free( sched_history->historical );
sched_history->historical = bool_vector_alloc( 0 , true );
if (sched_history->time != NULL)
time_t_vector_free(sched_history->time);
sched_history->time = time_t_vector_alloc( 0 , 0 );
sched_history->last_history_step = 0;
}
