void site_config_init_env(site_config_type * site_config, const config_content_type * config) { { if (config_content_has_item( config , SETENV_KEY)) { config_content_item_type * setenv_item = config_content_get_item(config, SETENV_KEY); int i; for (i = 0; i < config_content_item_get_size(setenv_item); i++) { const config_content_node_type * setenv_node = config_content_item_iget_node(setenv_item, i); const char * var = config_content_node_iget(setenv_node, 0); const char * value = config_content_node_iget(setenv_node, 1); site_config_setenv(site_config, var, value); } } } { if (config_content_has_item( config , UPDATE_PATH_KEY)) { config_content_item_type * path_item = config_content_get_item(config, UPDATE_PATH_KEY); int i; for (i = 0; i < config_content_item_get_size(path_item); i++) { const config_content_node_type * path_node = config_content_item_iget_node(path_item, i); const char * path = config_content_node_iget(path_node, 0); const char * value = config_content_node_iget(path_node, 1); site_config_update_pathvar(site_config, path, value); } } } }
void ensemble_config_init_SUMMARY( ensemble_config_type * ensemble_config , const config_content_type * config , const ecl_sum_type * refcase) { if (config_content_has_item(config , SUMMARY_KEY)) { const config_content_item_type * item = config_content_get_item( config , SUMMARY_KEY ); int i; for (i=0; i < config_content_item_get_size( item ); i++) { const config_content_node_type * node = config_content_item_iget_node( item , i ); int j; for (j= 0; j < config_content_node_get_size( node ); j++) { const char * key = config_content_node_iget( node , j ); summary_key_matcher_add_summary_key(ensemble_config->summary_key_matcher, key); if (util_string_has_wildcard( key )) { //todo: DEPRECATED. In the Future the matcher should take care of this. if (ensemble_config->refcase != NULL) { int k; stringlist_type * keys = stringlist_alloc_new ( ); ecl_sum_select_matching_general_var_list( ensemble_config->refcase , key , keys ); /* expanding the wildcard notation with help of the refcase. */ for (k=0; k < stringlist_get_size( keys ); k++) ensemble_config_add_summary(ensemble_config , stringlist_iget(keys , k) , LOAD_FAIL_SILENT ); stringlist_free( keys ); } } else ensemble_config_add_summary(ensemble_config , key , LOAD_FAIL_SILENT); } } } }
static void site_config_add_jobs(site_config_type * site_config, const config_content_type * config) { if (config_content_has_item(config, INSTALL_JOB_KEY)) { const config_content_item_type * content_item = config_content_get_item(config, INSTALL_JOB_KEY); int num_jobs = config_content_item_get_size(content_item); for (int job_nr = 0; job_nr < num_jobs; job_nr++) { config_content_node_type * node = config_content_item_iget_node(content_item, job_nr); const char * job_key = config_content_node_iget(node, 0); const char * description_file = config_content_node_iget_as_abspath(node, 1); site_config_install_job(site_config, job_key, description_file); } } if (config_content_has_item(config, INSTALL_JOB_DIRECTORY_KEY)) { const config_content_item_type * content_item = config_content_get_item(config, INSTALL_JOB_DIRECTORY_KEY); int num_dirs = config_content_item_get_size(content_item); printf("num_dirs = %d \n",num_dirs); for (int dir_nr = 0; dir_nr < num_dirs; dir_nr++) { config_content_node_type * node = config_content_item_iget_node(content_item, dir_nr); const char * directory = config_content_node_iget_as_abspath(node, 0); ext_joblist_add_jobs_in_directory(site_config->joblist , directory, site_config->__license_root_path, site_config->user_mode ); } } }
void ensemble_config_init_SUMMARY( ensemble_config_type * ensemble_config , const config_type * config , const ecl_sum_type * refcase) { const config_content_item_type * item = config_get_content_item( config , SUMMARY_KEY ); if (item != NULL) { int i; for (i=0; i < config_content_item_get_size( item ); i++) { const config_content_node_type * node = config_content_item_iget_node( item , i ); int j; for (j= 0; j < config_content_node_get_size( node ); j++) { const char * key = config_content_node_iget( node , j ); if (util_string_has_wildcard( key )) { if (ensemble_config->refcase != NULL) { int k; stringlist_type * keys = stringlist_alloc_new ( ); ecl_sum_select_matching_general_var_list( ensemble_config->refcase , key , keys ); /* expanding the wildcard notatition with help of the refcase. */ for (k=0; k < stringlist_get_size( keys ); k++) ensemble_config_add_summary(ensemble_config , stringlist_iget(keys , k) , LOAD_FAIL_SILENT ); stringlist_free( keys ); } else util_exit("error: when using summary wildcards like: \"%s\" you must supply a valid refcase.\n",key); } else ensemble_config_add_summary(ensemble_config , key , LOAD_FAIL_SILENT); } } } }
void output_table_init( const ecl_sum_type * refcase, hash_type * output_table , const config_content_type * config ) { int i,j; if (config_content_has_item( config , "OUTPUT")) { const config_content_item_type * output_item = config_content_get_item( config , "OUTPUT"); for (i = 0; i < config_content_item_get_size( output_item ); i++) { const config_content_node_type * output_node = config_content_item_iget_node( output_item , i ); const char * file = config_content_node_iget( output_node , 0 ); const char * format_string = config_content_node_iget( output_node , 1 ); output_type * output = output_alloc( file , format_string ); /* All the keys are just added - without any check. */ for (j = 2; j < config_content_node_get_size( output_node ); j++) output_add_key( refcase , output , config_content_node_iget( output_node , j)); hash_insert_hash_owned_ref( output_table , file , output , output_free__ ); } } }
void ecl_config_static_kw_init( ecl_config_type * ecl_config , const config_type * config ) { const config_content_item_type * content_item = config_get_content_item( config , STATIC_KW_KEY ); if (content_item != NULL) { int j; for (j=0; j < config_content_item_get_size( content_item ); j++) { const config_content_node_type * content_node = config_content_item_iget_node( content_item , j); int k; for (k = 0; k < config_content_node_get_size( content_node ); k++) ecl_config_add_static_kw(ecl_config , config_content_node_iget( content_node , k )); } } }
static void site_config_add_jobs(site_config_type * site_config, const config_type * config) { if (config_item_set(config, INSTALL_JOB_KEY)) { const config_content_item_type * content_item = config_get_content_item(config, INSTALL_JOB_KEY); int num_jobs = config_content_item_get_size(content_item); for (int job_nr = 0; job_nr < num_jobs; job_nr++) { config_content_node_type * node = config_content_item_iget_node(content_item, job_nr); const char * job_key = config_content_node_iget(node, 0); const char * description_file = config_content_node_iget_as_abspath(node, 1); site_config_install_job(site_config, job_key, description_file); } } }
void ensemble_config_init_GEN_KW( ensemble_config_type * ensemble_config , const config_type * config ) { const config_content_item_type * gen_kw_item = config_get_content_item( config , GEN_KW_KEY ); if (gen_kw_item != NULL) { int i; for (i=0; i < config_content_item_get_size( gen_kw_item ); i++) { config_content_node_type * node = config_content_item_iget_node( gen_kw_item , i ); const char * key = config_content_node_iget( node , 0 ); const char * template_file = config_content_node_iget_as_path( node , 1 ); const char * enkf_outfile = config_content_node_iget( node , 2 ); const char * parameter_file = config_content_node_iget_as_path( node , 3 ); hash_type * opt_hash = hash_alloc(); config_content_node_init_opt_hash( node , opt_hash , 4 ); { const char * forward_string = hash_safe_get( opt_hash , FORWARD_INIT_KEY ); enkf_config_node_type * config_node; bool forward_init = false; if (forward_string) { if (!util_sscanf_bool( forward_string , &forward_init)) fprintf(stderr,"** Warning: parsing %s as bool failed - using FALSE \n",forward_string); } config_node = ensemble_config_add_gen_kw( ensemble_config , key , forward_init); enkf_config_node_update_gen_kw( config_node , enkf_outfile , template_file , parameter_file , hash_safe_get( opt_hash , MIN_STD_KEY ) , hash_safe_get( opt_hash , INIT_FILES_KEY)); } hash_free( opt_hash ); } } }
void ensemble_config_init_SURFACE( ensemble_config_type * ensemble_config , const config_type * config ) { const config_content_item_type * item = config_get_content_item( config , SURFACE_KEY ); if (item != NULL) { int i; for (i=0; i < config_content_item_get_size( item ); i++) { const config_content_node_type * node = config_content_item_iget_node( item , i ); const char * key = config_content_node_iget( node , 0 ); { hash_type * options = hash_alloc(); /* INIT_FILE:<init_files> OUTPUT_FILE:<outfile> BASE_SURFACE:<base_file> */ config_content_node_init_opt_hash( node , options , 1 ); { const char * init_file_fmt = hash_safe_get( options , INIT_FILES_KEY ); const char * output_file = hash_safe_get( options , OUTPUT_FILE_KEY); const char * base_surface = hash_safe_get( options , BASE_SURFACE_KEY); const char * min_std_file = hash_safe_get( options , MIN_STD_KEY); const char * forward_string = hash_safe_get( options , FORWARD_INIT_KEY ); bool forward_init = false; if (forward_string) { if (!util_sscanf_bool( forward_string , &forward_init)) fprintf(stderr,"** Warning: parsing %s as bool failed - using FALSE \n",forward_string); } if ((init_file_fmt == NULL) || (output_file == NULL) || (base_surface == NULL)) { fprintf(stderr,"** error: when entering a surface you must provide arguments:\n"); fprintf(stderr,"** %s:/path/to/input/files%%d \n",INIT_FILES_KEY); fprintf(stderr,"** %s:name_of_output_file\n", OUTPUT_FILE_KEY); fprintf(stderr,"** %s:base_surface_file\n",BASE_SURFACE_KEY); exit(1); } { enkf_config_node_type * config_node = ensemble_config_add_surface( ensemble_config , key , forward_init); enkf_config_node_update_surface( config_node , base_surface , init_file_fmt , output_file , min_std_file ); } } hash_free( options ); } } } }
void ensemble_config_init_CUSTOM_KW(ensemble_config_type * ensemble_config, const config_content_type * config) { if (config_content_has_item(config, CUSTOM_KW_KEY)) { const config_content_item_type * custom_kw_item = config_content_get_item(config, CUSTOM_KW_KEY); for (int i = 0; i < config_content_item_get_size(custom_kw_item); i++) { config_content_node_type * node = config_content_item_iget_node(custom_kw_item, i); const char * key = config_content_node_iget(node, 0); const char * result_file = config_content_node_iget_as_path(node, 1); const char * output_file = NULL; if(config_content_node_get_size(node) > 2) { output_file = config_content_node_iget_as_path(node, 2); } enkf_config_node_type * config_node = ensemble_config_add_custom_kw(ensemble_config, key, result_file, output_file); enkf_config_node_update_custom_kw(config_node, result_file, output_file); enkf_config_node_set_internalize(config_node, 0); } } }
void ensemble_init( ensemble_type * ensemble , config_content_type * config) { /*1 : Loading ensembles and settings from the config instance */ /*1a: Loading the eclipse summary cases. */ { thread_pool_type * tp = thread_pool_alloc( LOAD_THREADS , true ); { int i,j; if (config_content_has_item( config , "CASE_LIST")) { const config_content_item_type * case_item = config_content_get_item( config , "CASE_LIST" ); for (j=0; j < config_content_item_get_size( case_item ); j++) { const config_content_node_type * case_node = config_content_item_iget_node( case_item , j ); for (i=0; i < config_content_node_get_size( case_node ); i++) { const char * case_glob = config_content_node_iget( case_node , i ); ensemble_load_from_glob( ensemble , case_glob , tp); } } } } thread_pool_join( tp ); thread_pool_free( tp ); } { const sum_case_type * tmp = vector_iget_const( ensemble->data , 0 ); ensemble->refcase = tmp->ecl_sum; } /*1b: Other config settings */ if (config_content_has_item( config , "NUM_INTERP" )) ensemble->num_interp = config_content_iget_as_int( config , "NUM_INTERP" , 0 , 0 ); /*2: Remaining initialization */ ensemble_init_time_interp( ensemble ); if (vector_get_size( ensemble->data ) < MIN_SIZE ) util_exit("Sorry - quantiles make no sense with with < %d realizations; should have ~> 100.\n" , MIN_SIZE); }
void ensemble_config_init_FIELD( ensemble_config_type * ensemble_config , const config_type * config , ecl_grid_type * grid) { const config_content_item_type * item = config_get_content_item( config , FIELD_KEY ); if (item != NULL) { int i; for (i=0; i < config_content_item_get_size( item ); i++) { const config_content_node_type * node = config_content_item_iget_node( item , i ); const char * key = config_content_node_iget( node , 0 ); const char * var_type_string = config_content_node_iget( node , 1 ); enkf_config_node_type * config_node; { hash_type * options = hash_alloc(); int truncation = TRUNCATE_NONE; double value_min = -1; double value_max = -1; config_content_node_init_opt_hash( node , options , 2 ); if (hash_has_key( options , MIN_KEY)) { truncation |= TRUNCATE_MIN; value_min = atof(hash_get( options , MIN_KEY)); } if (hash_has_key( options , MAX_KEY)) { truncation |= TRUNCATE_MAX; value_max = atof(hash_get( options , MAX_KEY)); } if (strcmp(var_type_string , DYNAMIC_KEY) == 0) { config_node = ensemble_config_add_field( ensemble_config , key , grid , false); enkf_config_node_update_state_field( config_node , truncation , value_min , value_max ); } else if (strcmp(var_type_string , PARAMETER_KEY) == 0) { const char * ecl_file = config_content_node_iget( node , 2 ); const char * init_file_fmt = hash_safe_get( options , INIT_FILES_KEY ); const char * init_transform = hash_safe_get( options , INIT_TRANSFORM_KEY ); const char * output_transform = hash_safe_get( options , OUTPUT_TRANSFORM_KEY ); const char * min_std_file = hash_safe_get( options , MIN_STD_KEY ); const char * forward_string = hash_safe_get( options , FORWARD_INIT_KEY ); bool forward_init = false; if (forward_string) { if (!util_sscanf_bool( forward_string , &forward_init)) fprintf(stderr,"** Warning: parsing %s as bool failed - using FALSE \n",forward_string); } config_node = ensemble_config_add_field( ensemble_config , key , grid , forward_init); enkf_config_node_update_parameter_field( config_node, ecl_file , init_file_fmt , min_std_file , truncation , value_min , value_max , init_transform , output_transform ); } else if (strcmp(var_type_string , GENERAL_KEY) == 0) { /* General - not really interesting .. */ const char * ecl_file = config_content_node_iget( node , 2 ); const char * enkf_infile = config_content_node_iget( node , 3 ); const char * init_file_fmt = hash_safe_get( options , INIT_FILES_KEY ); const char * init_transform = hash_safe_get( options , INIT_TRANSFORM_KEY ); const char * output_transform = hash_safe_get( options , OUTPUT_TRANSFORM_KEY ); const char * input_transform = hash_safe_get( options , INPUT_TRANSFORM_KEY ); const char * min_std_file = hash_safe_get( options , MIN_STD_KEY ); const char * forward_string = hash_safe_get( options , FORWARD_INIT_KEY ); bool forward_init = false; if (forward_string) { if (!util_sscanf_bool( forward_string , &forward_init)) fprintf(stderr,"** Warning: parsing %s as bool failed - using FALSE \n",forward_string); } config_node = ensemble_config_add_field( ensemble_config , key , grid , forward_init); enkf_config_node_update_general_field( config_node, ecl_file , enkf_infile , init_file_fmt , min_std_file , truncation , value_min , value_max , init_transform , input_transform , output_transform); } else util_abort("%s: field type: %s is not recognized\n",__func__ , var_type_string); hash_free( options ); } } } }
const char * config_content_get_value(const config_content_type * config , const char * kw) { config_content_node_type * node = config_content_get_value_node__( config , kw ); return config_content_node_iget(node , 0); }