int main(int argc , char ** argv) {
const char * config_file = argv[1];
config_parser_type * config = config_alloc();
{
config_schema_item_type * item = config_add_schema_item(config , "APPEND" , false );
config_schema_item_set_argc_minmax( item , 1 , 1);
}
config_add_schema_item(config , "NEXT" , false );
config_content_type * content = config_parse(config , config_file , "--" , NULL , NULL , NULL , false , true );
if (config_content_is_valid( content )) {
if (config_content_get_size( content ) == 4) {
const config_content_node_type * node0 = config_content_iget_node( content , 0 );
if (strcmp( config_content_node_get_kw( node0 ) , "APPEND") == 0) {
if (config_content_node_get_size(node0) == 1) {
const config_content_node_type * node3 = config_content_iget_node( content , 3 );
if (strcmp( config_content_node_get_kw( node3 ) , "NEXT") == 0) {
if (config_content_node_get_size(node3) == 2) {
config_content_free( content );
exit(0);
} else printf("Size error node3\n");
} else printf("kw error node3 \n");
} else printf("Size error node0\n");
} else printf("kw error node0 kw:%s \n", config_content_node_get_kw( node0 ));
} else printf("Size error \n");
} else printf("Parse error");
config_content_free( content );
exit(1);
}
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 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);
}
}
}
}
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 ));
}
}
}
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 ert_workflow_list_init( ert_workflow_list_type * workflow_list , config_content_type * config ) {
/* Adding jobs */
{
if (config_content_has_item( config , WORKFLOW_JOB_DIRECTORY_KEY)) {
const config_content_item_type * jobpath_item = config_content_get_item( config , WORKFLOW_JOB_DIRECTORY_KEY);
for (int i=0; i < config_content_item_get_size( jobpath_item ); i++) {
config_content_node_type * path_node = config_content_item_iget_node( jobpath_item , i );
for (int j=0; j < config_content_node_get_size( path_node ); j++)
ert_workflow_list_add_jobs_in_directory( workflow_list , config_content_node_iget_as_abspath( path_node , j ) );
}
}
}
{
if (config_content_has_item( config , LOAD_WORKFLOW_JOB_KEY)) {
const config_content_item_type * job_item = config_content_get_item( config , LOAD_WORKFLOW_JOB_KEY);
for (int i=0; i < config_content_item_get_size( job_item ); i++) {
config_content_node_type * job_node = config_content_item_iget_node( job_item , i );
const char * config_file = config_content_node_iget_as_path( job_node , 0 );
const char * job_name = config_content_node_safe_iget( job_node , 1 );
ert_workflow_list_add_job( workflow_list , job_name , config_file);
}
}
}
/* Adding workflows */
{
if (config_content_has_item( config , LOAD_WORKFLOW_KEY)) {
const config_content_item_type * workflow_item = config_content_get_item( config , LOAD_WORKFLOW_KEY);
for (int i=0; i < config_content_item_get_size( workflow_item ); i++) {
config_content_node_type * workflow_node = config_content_item_iget_node( workflow_item , i );
const char * workflow_file = config_content_node_iget_as_path( workflow_node , 0 );
const char * workflow_name = config_content_node_safe_iget( workflow_node , 1 );
ert_workflow_list_add_workflow( workflow_list , workflow_file , workflow_name );
}
}
}
}
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 ecl_config_init( ecl_config_type * ecl_config , const config_type * config ) {
if (config_item_set( config , ECLBASE_KEY ))
ecl_config_set_eclbase( ecl_config , config_iget(config , ECLBASE_KEY ,0,0) );
if (config_item_set( config , DATA_FILE_KEY ))
ecl_config_set_data_file( ecl_config , config_iget( config , DATA_FILE_KEY ,0,0));
if (config_item_set( config , SCHEDULE_FILE_KEY ))
ecl_config_set_schedule_file( ecl_config , config_iget( config , SCHEDULE_FILE_KEY ,0,0));
if (config_item_set(config , GRID_KEY))
ecl_config_set_grid( ecl_config , config_iget(config , GRID_KEY , 0,0) );
if (config_item_set( config , ADD_FIXED_LENGTH_SCHEDULE_KW_KEY)) {
int iocc;
for (iocc = 0; iocc < config_get_occurences(config , ADD_FIXED_LENGTH_SCHEDULE_KW_KEY); iocc++)
ecl_config_add_fixed_length_schedule_kw( ecl_config ,
config_iget(config , ADD_FIXED_LENGTH_SCHEDULE_KW_KEY , iocc , 0) ,
config_iget_as_int(config , ADD_FIXED_LENGTH_SCHEDULE_KW_KEY , iocc , 1));
}
if (config_item_set( config , REFCASE_KEY)) {
const char * refcase_path = config_get_value_as_path( config , REFCASE_KEY );
if (!ecl_config_load_refcase( ecl_config , refcase_path))
fprintf(stderr,"** Warning: loading refcase:%s failed \n", refcase_path);
}
if (config_item_set( config , REFCASE_LIST_KEY)) {
config_content_item_type * item = config_get_content_item( config , REFCASE_LIST_KEY);
int i;
for (i=0; i < config_content_item_get_size( item ); i++) {
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 * case_glob = config_content_node_iget_as_path( node , j );
ecl_refcase_list_add_matching( ecl_config->refcase_list , case_glob );
}
}
}
/* Deprecated */
if (config_item_set( config , PLOT_REFCASE_LIST_KEY)) {
const char * case_list_file = config_get_value( config , PLOT_REFCASE_LIST_KEY);
FILE * stream = util_fopen(case_list_file , "r");
bool at_eof;
do {
char * case_name = util_fscanf_alloc_line(stream , &at_eof);
if (case_name) {
ecl_refcase_list_add_case( ecl_config->refcase_list , case_name);
free( case_name );
}
} while (!at_eof);
fclose( stream );
}
if (config_item_set(config , INIT_SECTION_KEY))
ecl_config_set_init_section( ecl_config , config_get_value( config , INIT_SECTION_KEY ));
else
if (ecl_config->can_restart)
/**
This is a hard error - the datafile contains <INIT>, however
the config file does NOT contain INIT_SECTION, i.e. we have
no information to fill in for the <INIT> section. This case
will not be able to initialize an ECLIPSE model, and that is
broken behaviour.
*/
util_exit("Sorry: when the datafile contains <INIT> the config file MUST have the INIT_SECTION keyword. \n");
/*
The user has not supplied a INIT_SECTION keyword whatsoever,
this essentially means that we can not restart - because:
1. The EQUIL section must be inlined in the DATAFILE without any
special markup.
2. ECLIPSE will fail hard if the datafile contains both an EQUIL
section and a restart statement, and when we have not marked
the EQUIL section specially with the INIT_SECTION keyword it
is impossible for ERT to dynamically change between a
datafile with initialisation and a datafile for restart.
IFF the user has no intentitions of any form of restart, this is
perfectly legitemate.
*/
if (config_item_set( config , END_DATE_KEY )) {
const char * date_string = config_get_value( config , END_DATE_KEY );
time_t end_date;
if (util_sscanf_date( date_string , &end_date))
ecl_config_set_end_date( ecl_config , end_date );
else
fprintf(stderr,"** WARNING **: Failed to parse %s as a date - should be in format dd/mm/yyyy \n",date_string);
}
}
void ecl_config_init(ecl_config_type * ecl_config, const config_content_type * config)
{
if (config_content_has_item(config, ECLBASE_KEY)) {
ui_return_type * ui_return = ecl_config_validate_eclbase(ecl_config, config_content_iget(config, ECLBASE_KEY, 0, 0));
if (ui_return_get_status(ui_return) == UI_RETURN_OK)
ecl_config_set_eclbase(ecl_config, config_content_iget(config, ECLBASE_KEY, 0, 0));
else
util_abort("%s: failed to set eclbase format. Error:%s\n", __func__ , ui_return_get_last_error(ui_return));
ui_return_free(ui_return);
}
if (config_content_has_item(config, DATA_FILE_KEY))
{
ui_return_type * ui_return = ecl_config_validate_data_file(ecl_config, config_content_iget(config, DATA_FILE_KEY, 0, 0));
if (ui_return_get_status( ui_return ) == UI_RETURN_OK)
ecl_config_set_data_file( ecl_config, config_content_iget(config, DATA_FILE_KEY, 0, 0) );
else
util_abort("%s: problem setting ECLIPSE data file\n",__func__ , ui_return_get_last_error(ui_return));
ui_return_free(ui_return);
}
if (config_content_has_item(config, SCHEDULE_FILE_KEY)) {
const char * schedule_target_file = config_content_safe_iget(config, SCHEDULE_FILE_KEY, 0, 1);
if (schedule_target_file) {
ui_return_type * ui_return_sched_target_file = ecl_config_validate_schedule_file(ecl_config, schedule_target_file);
if (!ui_return_get_status(ui_return_sched_target_file) == UI_RETURN_OK) {
util_abort("%s: failed to set target schedule file. Error:%s\n",__func__ , ui_return_get_last_error(ui_return_sched_target_file));
}
ui_return_free(ui_return_sched_target_file);
}
ui_return_type * ui_return = ecl_config_validate_schedule_file(ecl_config, config_content_iget(config, SCHEDULE_FILE_KEY, 0, 0));
if (ui_return_get_status(ui_return) == UI_RETURN_OK)
ecl_config_set_schedule_file(ecl_config, config_content_iget(config, SCHEDULE_FILE_KEY, 0, 0), schedule_target_file);
else
util_abort("%s: failed to set schedule file. Error:%s\n",__func__ , ui_return_get_last_error(ui_return));
ui_return_free(ui_return);
}
if (config_content_has_item(config, GRID_KEY)) {
const char * grid_file = config_content_iget(config, GRID_KEY, 0, 0);
ui_return_type * ui_return = ecl_config_validate_grid( ecl_config , grid_file);
if (ui_return_get_status(ui_return) == UI_RETURN_OK)
ecl_config_set_grid(ecl_config, grid_file );
else
util_abort("%s: failed to set grid file:%s Error:%s \n",__func__ , grid_file , ui_return_get_last_error(ui_return));
ui_return_free( ui_return );
}
if (config_content_has_item(config, ADD_FIXED_LENGTH_SCHEDULE_KW_KEY))
{
int iocc;
for (iocc = 0; iocc < config_content_get_occurences(config, ADD_FIXED_LENGTH_SCHEDULE_KW_KEY); iocc++)
ecl_config_add_fixed_length_schedule_kw(ecl_config,
config_content_iget(config, ADD_FIXED_LENGTH_SCHEDULE_KW_KEY, iocc, 0),
config_content_iget_as_int(config, ADD_FIXED_LENGTH_SCHEDULE_KW_KEY, iocc, 1));
}
if (config_content_has_item(config, REFCASE_KEY))
{
const char * refcase_path = config_content_get_value_as_path(config, REFCASE_KEY);
if (!ecl_config_load_refcase(ecl_config, refcase_path))
fprintf(stderr, "** Warning: loading refcase:%s failed \n", refcase_path);
}
if (config_content_has_item(config, REFCASE_LIST_KEY))
{
config_content_item_type * item = config_content_get_item(config, REFCASE_LIST_KEY);
int i;
for (i = 0; i < config_content_item_get_size(item); i++)
{
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 * case_glob = config_content_node_iget_as_path(node, j);
ecl_refcase_list_add_matching(ecl_config->refcase_list, case_glob);
}
}
}
if (config_content_has_item(config, INIT_SECTION_KEY))
ecl_config_set_init_section(ecl_config, config_content_get_value(config, INIT_SECTION_KEY));
else if (ecl_config->can_restart)
/**
This is a hard error - the datafile contains <INIT>, however
the config file does NOT contain INIT_SECTION, i.e. we have
no information to fill in for the <INIT> section. This case
will not be able to initialize an ECLIPSE model, and that is
broken behaviour.
*/
util_exit("Sorry: when the datafile contains <INIT> the config file MUST have the INIT_SECTION keyword. \n");
/*
The user has not supplied a INIT_SECTION keyword whatsoever,
this essentially means that we can not restart - because:
1. The EQUIL section must be inlined in the DATAFILE without any
special markup.
2. ECLIPSE will fail hard if the datafile contains both an EQUIL
section and a restart statement, and when we have not marked
the EQUIL section specially with the INIT_SECTION keyword it
is impossible for ERT to dynamically change between a
datafile with initialisation and a datafile for restart.
IFF the user has no intentitions of any form of restart, this is
perfectly legitemate.
*/
if (config_content_has_item(config, END_DATE_KEY))
{
const char * date_string = config_content_get_value(config, END_DATE_KEY);
time_t end_date;
if (util_sscanf_date_utc(date_string, &end_date))
ecl_config_set_end_date(ecl_config, end_date);
else
fprintf(stderr, "** WARNING **: Failed to parse %s as a date - should be in format dd/mm/yyyy \n", date_string);
}
}
