static void field_config_set_init_transform( field_config_type * config , const char * __init_transform_name ) {
const char * init_transform_name = NULL;
if (field_trans_table_has_key( config->trans_table , __init_transform_name))
init_transform_name = __init_transform_name;
config->init_transform_name = util_realloc_string_copy( config->init_transform_name , init_transform_name );
if (init_transform_name != NULL)
config->init_transform = field_trans_table_lookup( config->trans_table , init_transform_name);
else
config->init_transform = NULL;
}
void ensemble_config_set_gen_kw_format( ensemble_config_type * ensemble_config , const char * gen_kw_format_string) {
if (!util_string_equal( gen_kw_format_string , ensemble_config->gen_kw_format_string)) {
stringlist_type * gen_kw_keys = ensemble_config_alloc_keylist_from_impl_type( ensemble_config , GEN_KW );
int i;
ensemble_config->gen_kw_format_string = util_realloc_string_copy( ensemble_config->gen_kw_format_string , gen_kw_format_string );
for (i=0; i < stringlist_get_size( gen_kw_keys ); i++) {
enkf_config_node_type * config_node = ensemble_config_get_node( ensemble_config , stringlist_iget( gen_kw_keys , i ));
gen_kw_config_update_tag_format( enkf_config_node_get_ref( config_node ) , gen_kw_format_string );
}
stringlist_free( gen_kw_keys );
}
}
bool model_config_select_runpath( model_config_type * model_config , const char * path_key) {
if (hash_has_key( model_config->runpath_map , path_key )) {
model_config->current_runpath = hash_get( model_config->runpath_map , path_key );
model_config->current_path_key = util_realloc_string_copy( model_config->current_path_key , path_key);
return true;
} else {
if (model_config->current_runpath != NULL) // OK - we already have a valid selection - stick to that and return False.
return false;
else {
util_abort("%s: path_key:%s does not exist - and currently no valid runpath selected \n",__func__ , path_key);
return false;
}
}
}
static void field_config_set_output_transform( field_config_type * config , const char * __output_transform_name ) {
const char * output_transform_name = NULL;
if (field_trans_table_has_key( config->trans_table , __output_transform_name))
output_transform_name = __output_transform_name;
else if (__output_transform_name) {
fprintf(stderr , "Sorry: the field transformation function:%s is not recognized \n\n",__output_transform_name);
field_trans_table_fprintf(config->trans_table , stderr);
util_exit("Exiting ... \n");
}
config->output_transform_name = util_realloc_string_copy( config->output_transform_name , output_transform_name );
if (output_transform_name != NULL)
config->output_transform = field_trans_table_lookup( config->trans_table , output_transform_name);
else
config->output_transform = NULL;
}
void enkf_config_node_update_min_std( enkf_config_node_type * config_node , const char * min_std_file ) {
if (!util_string_equal( config_node->min_std_file , min_std_file )) {
/* The current min_std_file and the new input are different, and
the min_std node must be cleared. */
if (config_node->min_std != NULL) {
enkf_node_free( config_node->min_std );
config_node->min_std = NULL;
free( config_node->min_std_file );
}
}
config_node->min_std_file = util_realloc_string_copy( config_node->min_std_file , min_std_file );
if (config_node->min_std_file != NULL) {
config_node->min_std = enkf_node_alloc( config_node );
enkf_node_fload( config_node->min_std , min_std_file );
}
}
void ecl_config_set_data_file( ecl_config_type * ecl_config , const char * data_file) {
ecl_config->data_file = util_realloc_string_copy( ecl_config->data_file , data_file );
{
FILE * stream = util_fopen( ecl_config->data_file , "r");
parser_type * parser = parser_alloc(NULL , NULL , NULL , NULL , "--" , "\n" );
char * init_tag = enkf_util_alloc_tagged_string( "INIT" );
ecl_config->can_restart = parser_fseek_string( parser , stream , init_tag , false , true );
free( init_tag );
parser_free( parser );
fclose( stream );
}
ecl_config->start_date = ecl_util_get_start_date( ecl_config->data_file );
ecl_config->num_cpu = ecl_util_get_num_cpu( ecl_config->data_file );
}
/**
input_value can be NULL.
*/
static void subst_list_string_set_value(subst_list_string_type * node, const char * input_value , const char * doc_string , subst_insert_type insert_mode) {
subst_list_string_free_content( node );
{
char * value;
if (insert_mode == SUBST_DEEP_COPY)
value = util_alloc_string_copy(input_value);
else
value = (char *) input_value;
if (insert_mode == SUBST_SHARED_REF)
node->value_owner = false;
else
node->value_owner = true;
node->value = value;
}
if (doc_string != NULL)
node->doc_string = util_realloc_string_copy( node->doc_string , doc_string );
}
void gen_kw_config_set_parameter_file( gen_kw_config_type * config , const char * parameter_file ) {
config->parameter_file = util_realloc_string_copy( config->parameter_file , parameter_file );
vector_clear( config->parameters );
if (parameter_file != NULL) {
FILE * stream = util_fopen(parameter_file , "r");
while (true) {
char parameter_name[256];
int fscanf_return;
fscanf_return = fscanf(stream , "%s" , parameter_name);
if (fscanf_return == 1) {
gen_kw_parameter_type * parameter = gen_kw_parameter_alloc( parameter_name , config->tag_fmt);
trans_func_type * trans_func = trans_func_fscanf_alloc( stream );
gen_kw_parameter_set_trans_func( parameter , trans_func );
vector_append_owned_ref( config->parameters , parameter , gen_kw_parameter_free__ );
} else
break; /* OK - we are ate EOF. */
}
fclose( stream );
}
}
static void __print_helptext(char * label, int l) {
bool end_reached = false;
char * label_copy = util_alloc_string_copy( label );
char * first_part = "Dummy3";
char * second_part = "Dummy4";
while(!end_reached) {
int i;
if(strlen(label_copy) > l) {
util_binary_split_string_from_max_length(label_copy , " ", l , &first_part , &second_part);
printf("| %s",first_part);
for (i=strlen(first_part); i < l; i++)
fputc(' ' , stdout);
printf(" |\n");
label_copy = util_realloc_string_copy(label_copy, second_part);
}
else {
printf("| %s",label_copy);
for (i=strlen(label_copy); i < l; i++)
fputc(' ' , stdout);
printf(" |\n");
end_reached = true;
}
}
}
void rml_enkf_log_set_log_file( rml_enkf_log_type * data , const char * log_file ) {
data->log_file = util_realloc_string_copy( data->log_file , log_file );
}
void runpath_list_set_line_fmt( runpath_list_type * list , const char * line_fmt ) {
list->line_fmt = util_realloc_string_copy( list->line_fmt , line_fmt );
}
void parser_set_comment_end( parser_type * parser , const char * comment_end ) {
__verify_string_length( comment_end );
parser->comment_end = util_realloc_string_copy( parser->comment_end , comment_end );
}
void hook_manager_set_path( hook_manager_type * hook_manager , const char * path) {
hook_manager->path = util_realloc_string_copy( hook_manager->path , path );
}
void plot_config_set_image_type(plot_config_type * plot_config , const char * image_type) {
plot_config->image_type = util_realloc_string_copy(plot_config->image_type , image_type);
}
void matrix_set_name( matrix_type * matrix , const char * name) {
matrix->name = util_realloc_string_copy( matrix->name , name );
}
void util_abort_test_set_intercept_function(const char * function) {
intercept_function = util_realloc_string_copy( intercept_function , function );
}
void site_config_set_default_browser( site_config_type * site_config , const char * default_browser ) {
site_config->default_browser = util_realloc_string_copy( site_config->default_browser , default_browser );
}
void site_config_set_lsf_request( site_config_type * site_config , const char * lsf_request) {
queue_driver_type * lsf_driver = site_config_get_queue_driver( site_config , LSF_DRIVER_NAME);
queue_driver_set_option( lsf_driver, LSF_RESOURCE , lsf_request );
if (!site_config->user_mode)
site_config->lsf_request_site = util_realloc_string_copy( site_config->lsf_request_site , lsf_request);
}
void ecl_config_set_schedule_prediction_file( ecl_config_type * ecl_config , const char * schedule_prediction_file ) {
ecl_config->schedule_prediction_file = util_realloc_string_copy( ecl_config->schedule_prediction_file , schedule_prediction_file );
}
static void smspec_node_set_lgr_name( smspec_node_type * index , const char * lgr_name ) {
index->lgr_name = util_realloc_string_copy(index->lgr_name , lgr_name);
}
void ecl_config_set_init_section( ecl_config_type * ecl_config , const char * input_init_section ) {
/* The semantic regarding INIT_SECTION is as follows:
1. If the INIT_SECTION points to an existing file - the
ecl_config->input_init_section is set to the absolute path of
this file.
2. If the INIT_SECTION points to a not existing file:
a. We assert that INIT_SECTION points to a pure filename,
i.e. /some/path/which/does/not/exist is NOT accepted. In
the case the input argument contain a path a error message
will be printed on stderr and the ->init_section will not
be set.
b. The ecl_config->input_init_section is set to point to this
file.
c. WE TRUST THE USER TO SUPPLY CONTENT (THROUGH SOME FUNKY
FORWARD MODEL) IN THE RUNPATH. This can unfortunately not
be checked/verified before the ECLIPSE simulation fails.
The INIT_SECTION keyword and <INIT> in the datafile (checked with
ecl_config->can_restart) interplay as follows:
CASE | INIT_SECTION | <INIT> | OK ?
---------------------------------------------
0 | Present | Present | Yes
1 | Not Present | Present | No
2 | Present | Not present| No
3 | Not Present | Not present| Yes
---------------------------------------------
Case 0: This is the most flexible case, which can do arbitrary
restart.
Case 1: In this case the datafile will contain a <INIT> tag, we
we do not have the info to replace that tag with for
initialisation, and ECLIPSE will fail. Strictly speaking this
case can actually restart, but that is not enough - we let
this case fail hard.
Case 2: We have some INIT_SECTION infor, but no tag in he
datafile to update. If the datafile has embedded
initialisation info this case will work for init; but it is
logically flawed, and not accepted. Currently only a warning.
Case 3: This case has just the right amount of information for
initialisation, but it is 'consistently unable' to restart.
*/
if (ecl_config->can_restart) { /* The <INIT> tag is set. */
ecl_config->input_init_section = util_realloc_string_copy( ecl_config->input_init_section , input_init_section ); /* input_init_section = path/to/init_section */
if (util_file_exists( ecl_config->input_init_section )) { /* init_section = $CWD/path/to/init_section */
util_safe_free( ecl_config->init_section );
ecl_config->init_section = util_alloc_realpath(input_init_section);
} else {
char * path;
util_alloc_file_components( ecl_config->input_init_section , &path , NULL , NULL );
if (path != NULL)
fprintf(stderr,"** Warning: %s: When INIT_SECTION:%s points to a non-existing file - you can not have any path components.\n",__func__ , input_init_section);
else
ecl_config->init_section = util_alloc_string_copy(input_init_section);
util_safe_free( path );
}
} else
/*
The <INIT> tag is not set - we can not utilize the
input_init_section info, and we just ignore it.
*/
fprintf(stderr,"** Warning: <INIT> tag was not found in datafile - can not utilize INIT_SECTION keyword - ignored.\n");
}
void runpath_list_set_export_file( runpath_list_type * list , const char * export_file ) {
list->export_file = util_realloc_string_copy( list->export_file , export_file );
}
void site_config_set_manual_url( site_config_type * site_config , const char * manual_url ) {
site_config->manual_url = util_realloc_string_copy( site_config->manual_url , manual_url );
}
void parser_set_quoters( parser_type * parser , const char * quoters ) {
__verify_string_length( quoters );
parser->quoters = util_realloc_string_copy( parser->quoters , quoters );
}
void field_config_set_ecl_kw_name(field_config_type * config , const char * ecl_kw_name) {
config->ecl_kw_name = util_realloc_string_copy(config->ecl_kw_name , ecl_kw_name);
}
void parser_set_specials( parser_type * parser , const char * specials ) {
__verify_string_length( specials );
parser->specials = util_realloc_string_copy( parser->specials , specials );
}
void plot_config_set_path(plot_config_type * plot_config , const char * plot_path) {
plot_config->plot_path = util_realloc_string_copy(plot_config->plot_path , plot_path);
util_make_path( plot_path );
}
void parser_set_delete_set( parser_type * parser , const char * delete_set ) {
__verify_string_length( delete_set );
parser->delete_set = util_realloc_string_copy( parser->delete_set , delete_set );
}
void plot_config_set_driver(plot_config_type * plot_config , const char * plot_driver) {
plot_config->driver = util_realloc_string_copy(plot_config->driver , plot_driver);
}
void parser_set_comment_start( parser_type * parser , const char * comment_start ) {
__verify_string_length( comment_start );
parser->comment_start = util_realloc_string_copy( parser->comment_start , comment_start );
}
