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 * enkf_main_analysis_enkf_update_JOB( void * self , const stringlist_type * args) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); enkf_fs_type * target_fs = enkf_main_get_fs( enkf_main ); int target_step; int_vector_type * step_list; // Argument 0: The number of the step to write to if (stringlist_get_size(args) > 1) util_sscanf_int(stringlist_iget( args , 1) , &target_step); else target_step = 0; // Argument 1 - ??: The timesteps to use in the update if (stringlist_get_size( args ) > 2) { char * step_args = stringlist_alloc_joined_substring(args , 2 , stringlist_get_size(args) , " "); step_list = string_util_alloc_active_list( step_args ); free( step_args ); } else step_list = int_vector_alloc(1,target_step); enkf_main_UPDATE( enkf_main , step_list , target_fs , target_step , SMOOTHER_UPDATE); int_vector_free( step_list ); return NULL; }
void * enkf_main_export_runpath_file_JOB(void * self, const stringlist_type * args) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); int ensemble_size = enkf_main_get_ensemble_size(enkf_main); analysis_config_type * analysis_config = enkf_main_get_analysis_config(enkf_main); analysis_iter_config_type * iter_config = analysis_config_get_iter_config(analysis_config); int num_iterations = analysis_iter_config_get_num_iterations(iter_config); const model_config_type * model_config = enkf_main_get_model_config(enkf_main); int_vector_type * realizations = int_vector_alloc(1, 0); int_vector_init_range(realizations, 0, ensemble_size, 1); int_vector_type * iterations = int_vector_alloc(1, 0); if (stringlist_get_size(args) > 0) { int offset = 0; while (true) { if (offset == stringlist_get_size( args )) break; if (0 == strcmp("|" , stringlist_iget( args, offset ))) break; ++offset; } if (0 != strcmp("*", stringlist_iget(args,0))) { char * range_str = stringlist_alloc_joined_substring( args, 0, offset, ""); string_util_init_value_list(range_str, realizations); free(range_str); } if ((offset < stringlist_get_size(args)) && model_config_runpath_requires_iter(model_config)) { if (0 == strcmp("*", stringlist_iget(args, (offset+1)))) int_vector_init_range(iterations, 0, num_iterations, 1); else { char * range_str = stringlist_alloc_joined_substring( args, offset+1, stringlist_get_size(args), ""); string_util_init_value_list(range_str, iterations); free(range_str); } } } enkf_main_export_runpath_file(enkf_main, realizations, iterations); int_vector_free(realizations); int_vector_free(iterations); return NULL; }
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; }
void test_join() { const char * elt0 = "AAA"; const char * elt1 = "BBB"; const char * elt2 = "CCC"; const char * elt3 = "DDD"; const char * elt4 = "EEE"; const char * elt5 = "FFF"; stringlist_type * s = stringlist_alloc_new(); { // empty join const char* empty_join = stringlist_alloc_joined_string(s, "!!!"); test_assert_not_NULL(empty_join); test_assert_string_equal("", empty_join); } stringlist_append_copy( s , elt0 ); stringlist_append_copy( s , elt1 ); stringlist_append_copy( s , elt2 ); const char * sep0 = ""; const char * sep1 = "!!!"; const char * sep2 = " abc "; const char * j0 = stringlist_alloc_joined_string( s, sep0); const char * j1 = stringlist_alloc_joined_string( s, sep1); const char * j2 = stringlist_alloc_joined_string( s, sep2); test_assert_string_equal( j0, "AAABBBCCC"); test_assert_string_equal( j1, "AAA!!!BBB!!!CCC"); test_assert_string_equal( j2, "AAA abc BBB abc CCC"); stringlist_type * s1 = stringlist_alloc_new(); stringlist_append_copy( s1 , elt0 ); test_assert_string_equal( "AAA", stringlist_alloc_joined_string( s1, sep0)); test_assert_string_equal( "AAA", stringlist_alloc_joined_string( s1, sep1)); test_assert_string_equal( "AAA", stringlist_alloc_joined_string( s1, sep2)); stringlist_type * sub = stringlist_alloc_new(); stringlist_append_copy( sub , elt0 ); stringlist_append_copy( sub , elt1 ); stringlist_append_copy( sub , elt2 ); stringlist_append_copy( sub , elt3 ); stringlist_append_copy( sub , elt4 ); stringlist_append_copy( sub , elt5 ); test_assert_string_equal( "CCC:DDD:EEE", stringlist_alloc_joined_substring( sub, 2, 5, ":")); }
void * enkf_main_analysis_update_JOB( void * self , const stringlist_type * args) { enkf_main_type * enkf_main = enkf_main_safe_cast( self ); enkf_fs_type * target_fs; int target_step; int_vector_type * step_list; bool decrease_ref = false; // Argument 0: Which case to write to if (stringlist_get_size(args)) { const char * target_fs_name = stringlist_iget( args , 0 ); if (strcmp( target_fs_name , CURRENT_CASE_STRING) == 0) target_fs = enkf_main_get_fs( enkf_main ); else { target_fs = enkf_main_mount_alt_fs( enkf_main , target_fs_name , true); decrease_ref = true; } } else target_fs = enkf_main_get_fs( enkf_main ); { // Argument 1: The number of the step to write to if (stringlist_get_size(args) > 1) util_sscanf_int(stringlist_iget( args , 1) , &target_step); else target_step = 0; // Argument 2 - ??: The timesteps to use in the update if (stringlist_get_size( args ) > 2) { char * step_args = stringlist_alloc_joined_substring(args , 2 , stringlist_get_size(args) , " "); step_list = string_util_alloc_active_list( step_args ); free( step_args ); } else { int stride = 1; time_map_type * time_map = enkf_fs_get_time_map( enkf_main_get_fs( enkf_main )); step_list = enkf_main_update_alloc_step_list( enkf_main , 0 , time_map_get_last_step( time_map ) , stride); } enkf_main_UPDATE( enkf_main , step_list , target_fs , target_step , SMOOTHER_UPDATE); int_vector_free( step_list ); if (decrease_ref) enkf_fs_decref( target_fs ); } return NULL; }
void site_config_init(site_config_type * site_config , const config_type * config, bool user_config) { site_config_add_jobs(site_config , config); { int i; for (i = 0; i < config_get_occurences( config , SETENV_KEY); i++) { const stringlist_type * tokens = config_iget_stringlist_ref(config , SETENV_KEY , i); const char * var = stringlist_iget( tokens , 0); const char * value = stringlist_iget( tokens , 1); site_config_setenv( site_config , var , value ); } for (i=0; i < config_get_occurences( config, UPDATE_PATH_KEY); i++) { const stringlist_type * tokens = config_iget_stringlist_ref(config , UPDATE_PATH_KEY , i); const char * path = stringlist_iget( tokens , 0); const char * value = stringlist_iget( tokens , 1); site_config_update_pathvar( site_config , path , value ); } } /* When LSF is used several enviroment variables must be set (by the site wide file) - i.e. the calls to SETENV must come first. */ if (!site_config->user_mode) site_config_create_queue_drivers( site_config ); /* Set the umask for all file creation. A value of '0' will ensure that all files and directories are created with 'equal rights' for everyone - might be handy if you are helping someone... The default statoil value is 0022, i.e. write access is removed from group and others. The string is supposed to be in OCTAL representation (without any prefix characters). */ if (config_item_set(config , UMASK_KEY)) { const char * string_mask = config_iget( config , UMASK_KEY , 0 , 0); mode_t umask_value; if (util_sscanf_octal_int( string_mask , &umask_value)) site_config_set_umask( site_config , umask_value); else util_abort("%s: failed to parse:\"%s\" as a valid octal literal \n",__func__ , string_mask); } if (config_item_set(config , MAX_SUBMIT_KEY)) site_config_set_max_submit( site_config , config_get_value_as_int( config , MAX_SUBMIT_KEY )); /* LSF options */ { if (config_item_set(config , LSF_QUEUE_KEY)) site_config_set_lsf_queue( site_config , config_iget( config , LSF_QUEUE_KEY , 0 , 0)); if (config_item_set(config , LSF_RESOURCES_KEY)) { char * lsf_resource_request = config_alloc_joined_string(config , LSF_RESOURCES_KEY , " "); site_config_set_lsf_request( site_config , lsf_resource_request ); free( lsf_resource_request ); } if (config_item_set(config , MAX_RUNNING_LSF_KEY)) site_config_set_max_running_lsf( site_config , config_iget_as_int( config , MAX_RUNNING_LSF_KEY , 0 , 0)); if (config_item_set(config , LSF_SERVER_KEY)) site_config_set_lsf_server( site_config , config_iget( config , LSF_SERVER_KEY , 0 , 0)); } /* RSH options */ { if (config_item_set( config , RSH_COMMAND_KEY )) site_config_set_rsh_command( site_config , config_iget(config , RSH_COMMAND_KEY , 0,0)); if (config_item_set( config , MAX_RUNNING_RSH_KEY)) site_config_set_max_running_rsh( site_config , config_iget_as_int( config , MAX_RUNNING_RSH_KEY , 0,0)); /* Parsing the "host1:4" strings. */ if (user_config) { if (config_item_set( config , RSH_HOST_KEY)) { stringlist_type * rsh_host_list = config_alloc_complete_stringlist(config , RSH_HOST_KEY); int i; for (i=0; i < stringlist_get_size( rsh_host_list ); i++) site_config_add_rsh_host_from_string( site_config , stringlist_iget( rsh_host_list , i ) ); stringlist_free( rsh_host_list ); } } } if (config_item_set( config , QUEUE_SYSTEM_KEY)) { job_driver_type driver_type; { const char * queue_system = config_iget(config , QUEUE_SYSTEM_KEY , 0,0); if (strcmp(queue_system , LSF_DRIVER_NAME) == 0) { driver_type = LSF_DRIVER; } else if (strcmp(queue_system , RSH_DRIVER_NAME) == 0) driver_type = RSH_DRIVER; else if (strcmp(queue_system , LOCAL_DRIVER_NAME) == 0) driver_type = LOCAL_DRIVER; else { util_abort("%s: queue system :%s not recognized \n",__func__ , queue_system); driver_type = NULL_DRIVER; } } site_config_set_job_queue__( site_config , driver_type ); } /* Parsing local options */ if (config_item_set( config , MAX_RUNNING_LOCAL_KEY)) site_config_set_max_running_local( site_config , config_iget_as_int( config , MAX_RUNNING_LOCAL_KEY , 0,0)); if (config_item_set(config , JOB_SCRIPT_KEY)) site_config_set_job_script( site_config , config_iget( config , JOB_SCRIPT_KEY , 0 , 0)); if (config_item_set(config , LICENSE_PATH_KEY)) site_config_set_license_root_path( site_config , config_iget( config , LICENSE_PATH_KEY , 0 , 0)); if (user_config) site_config_install_job_queue( site_config ); /* Setting QUEUE_OPTIONS */ { int i; for (i=0; i < config_get_occurences(config , QUEUE_OPTION_KEY); i++) { stringlist_type * tokens = config_iget_stringlist_ref(config , QUEUE_OPTION_KEY , i); const char * driver_name = stringlist_iget( tokens , 0 ); const char * option_key = stringlist_iget( tokens , 1 ); const char * option_value = stringlist_alloc_joined_substring( tokens , 2 , stringlist_get_size( tokens ), " "); /* If it is desirable to keep the exact number of spaces in the option_value it should be quoted with "" in the configuration file. */ site_config_set_queue_option( site_config , driver_name , option_key , option_value ); } } }
char * stringlist_alloc_joined_string(const stringlist_type * s , const char * sep) { return stringlist_alloc_joined_substring( s , 0 , stringlist_get_size( s ) , sep ); }