void sched_file_update_blocks(sched_file_type * sched_file,
int restart1 ,
int restart2 ,
sched_kw_type_enum kw_type,
sched_file_callback_ftype * callback,
void * callback_arg) {
int restart_nr;
if (restart2 > sched_file_get_num_restart_files(sched_file))
restart2 = sched_file_get_num_restart_files(sched_file) - 1;
for (restart_nr = restart1; restart_nr <= restart2; restart_nr++) {
sched_block_type * sched_block = sched_file_iget_block( sched_file , restart_nr );
sched_file_update_block( sched_block , restart_nr , kw_type , callback , callback_arg);
}
}
void ecl_config_set_schedule_file( ecl_config_type * ecl_config , const char * schedule_file ) {
if (ecl_config->start_date == -1)
util_abort("%s: must set ecl_data_file first \n",__func__);
{
char * base; /* The schedule target file will be without any path component */
char * ext;
util_alloc_file_components(schedule_file , NULL , &base , &ext);
ecl_config->schedule_target_file = util_alloc_filename(NULL , base , ext);
free(ext);
free(base);
}
ecl_config->sched_file = sched_file_alloc( ecl_config->start_date );
sched_file_parse(ecl_config->sched_file , schedule_file );
ecl_config->last_history_restart = sched_file_get_num_restart_files( ecl_config->sched_file ) - 1; /* We keep track of this - so we can stop assimilation at the end of history */
{
hash_iter_type * iter = hash_iter_alloc( ecl_config->fixed_length_kw );
while (!hash_iter_is_complete( iter )) {
const char * key = hash_iter_get_next_key( iter );
int length = hash_get_int( ecl_config->fixed_length_kw , key );
sched_file_add_fixed_length_kw( ecl_config->sched_file , key , length);
}
hash_iter_free( iter );
}
}
static void sched_file_build_block_dates(sched_file_type * sched_file)
{
int num_restart_files = sched_file_get_num_restart_files(sched_file);
time_t curr_time, new_time;
if(num_restart_files < 1)
util_abort("%s: Error - empty sched_file - aborting.\n", __func__);
/* Special case for block 0. */
sched_block_type * sched_block = sched_file_iget_block(sched_file, 0);
sched_block->block_start_time = sched_file->start_time ;
sched_block->block_end_time = sched_file->start_time ;
curr_time = sched_file->start_time;
for(int i=1; i<num_restart_files; i++)
{
sched_block = sched_file_iget_block(sched_file, i);
sched_block->block_start_time = curr_time;
sched_kw_type * timing_kw = sched_block_get_last_kw_ref(sched_block);
new_time = sched_kw_get_new_time(timing_kw, curr_time);
if(curr_time > new_time)
util_abort("%s: Schedule file contains negative timesteps - aborting.\n",__func__);
curr_time = new_time;
sched_block->block_end_time = curr_time;
}
}
void sched_file_update(sched_file_type * sched_file,
sched_kw_type_enum kw_type,
sched_file_callback_ftype * callback,
void * callback_arg) {
sched_file_update_blocks(sched_file , 1 , sched_file_get_num_restart_files(sched_file) - 1 , kw_type , callback , callback_arg);
}
void sched_file_summarize(const sched_file_type * sched_file , FILE * stream) {
int len = sched_file_get_num_restart_files(sched_file);
time_t start_time = sched_file_iget_block_start_time(sched_file , 0);
for(int i=1; i<len; i++) {
time_t t = sched_file_iget_block_start_time(sched_file , i);
__sched_file_summarize_line(i - 1 , start_time , t , stream);
}
{
time_t t = sched_file_iget_block_end_time(sched_file , len - 1);
__sched_file_summarize_line(len - 1 , start_time , t , stream);
}
}
int sched_file_get_restart_nr_from_time_t(const sched_file_type * sched_file, time_t time)
{
int num_restart_files = sched_file_get_num_restart_files(sched_file);
for( int i=0; i<num_restart_files; i++ ) {
time_t block_end_time = sched_file_iget_block_end_time(sched_file, i);
if (block_end_time > time) {
int mday,year,month;
util_set_date_values( time , &mday , &month , &year);
util_abort("%s: Date: %02d/%02d/%04d does not cooincide with any report time. Aborting.\n", __func__ , mday , month , year);
} else if (block_end_time == time)
return i;
}
// If we are here, time did'nt correspond a restart file. Abort.
{
int mday,year,month;
util_set_date_values( time , &mday , &month , &year);
util_abort("%s: Date: %02d/%02d/%04d does not cooincide with any report time. Aborting.\n", __func__ , mday , month , year);
}
return 0;
}
static void sched_file_fprintf_i__(const sched_file_type * sched_file, int last_restart_file, const char * file , bool addEND)
{
FILE * stream = util_fopen(file, "w");
int num_restart_files = sched_file_get_num_restart_files(sched_file);
last_restart_file = util_int_min( last_restart_file , num_restart_files - 1);
if (last_restart_file > num_restart_files) {
util_abort("%s: you asked for restart nr:%d - the last available restart nr is: %d \n",__func__ , last_restart_file , num_restart_files);
/* Must abort here because the calling scope is expecting to find last_restart_file. */
}
for(int i=0; i<= last_restart_file; i++)
{
const sched_block_type * sched_block = vector_iget_const( sched_file->blocks , i);
sched_block_fprintf(sched_block, stream);
}
if (addEND)
fprintf(stream, "END\n");
fclose(stream);
}
int ecl_config_get_num_restart_files(const ecl_config_type * ecl_config) {
return sched_file_get_num_restart_files(ecl_config->sched_file);
}
void sched_history_update( sched_history_type * sched_history, const sched_file_type * sched_file ) {
sched_history_realloc( sched_history );
sched_history_add_FIELD_group( sched_history );
{
int block_nr;
stringlist_type * well_list = stringlist_alloc_new();
stringlist_type * group_list = stringlist_alloc_new();
for (block_nr = 0; block_nr < sched_file_get_num_restart_files( sched_file ); block_nr++) {
sched_block_type * block = sched_file_iget_block( sched_file , block_nr );
int kw_nr;
int report_step = block_nr;
time_t_vector_iset( sched_history->time , block_nr , sched_file_iget_block_end_time( sched_file , block_nr));
for (kw_nr = 0; kw_nr < sched_block_get_size( block ); kw_nr++) {
sched_kw_type * kw = sched_block_iget_kw( block , kw_nr );
sched_kw_type_enum kw_type = sched_kw_get_type( kw );
switch( kw_type ) {
case(WCONHIST):
{
const sched_kw_wconhist_type * wconhist = sched_kw_get_data( kw );
sched_kw_wconhist_init_well_list( wconhist , well_list );
int iw;
for (iw = 0; iw < stringlist_get_size( well_list ); iw++) {
const char * well_name = stringlist_iget( well_list , iw );
well_history_type * well_history = sched_history_get_well( sched_history , well_name );
well_history_add_keyword( well_history , kw , report_step );
}
}
sched_history_set_historical( sched_history , block_nr );
break;
case(WCONPROD): /* This is only added to turn the well OFF from WCONHIST behaviour. It is currently not
possible to query the well for anything when it is in WCONPROD state. */
{
const sched_kw_wconprod_type * wconprod = sched_kw_get_data( kw );
sched_kw_wconprod_init_well_list( wconprod , well_list );
int iw;
for (iw = 0; iw < stringlist_get_size( well_list ); iw++) {
const char * well_name = stringlist_iget( well_list , iw );
well_history_type * well_history = sched_history_get_well( sched_history , well_name );
well_history_add_keyword( well_history , kw , report_step);
}
}
bool_vector_iset_default( sched_history->historical , block_nr , false );
break;
case(WCONINJE):
{
const sched_kw_wconinje_type * wconinje = sched_kw_get_data( kw );
sched_kw_wconinje_init_well_list( wconinje , well_list );
int iw;
for (iw = 0; iw < stringlist_get_size( well_list ); iw++) {
const char * well_name = stringlist_iget( well_list , iw );
well_history_type * well_history = sched_history_get_well( sched_history , well_name );
well_history_add_keyword( well_history , kw , report_step);
}
if (sched_kw_wconinje_historical( wconinje ))
sched_history_set_historical( sched_history , block_nr );
}
break;
case(WCONINJH):
/* ... */
sched_history_set_historical( sched_history , block_nr );
break;
case(WELSPECS):
{
const sched_kw_welspecs_type * welspecs = sched_kw_get_data( kw );
sched_kw_welspecs_init_child_parent_list( welspecs , well_list , group_list );
sched_history_add_wells( sched_history , welspecs , well_list );
sched_history_add_groups_welspecs( sched_history , welspecs , report_step , well_list , group_list );
for (int iw = 0; iw < stringlist_get_size( well_list ); iw++) {
const char * well_name = stringlist_iget( well_list , iw );
well_history_type * well_history = sched_history_get_well( sched_history , well_name );
well_history_add_keyword( well_history , kw , report_step);
}
}
break;
case(GRUPTREE):
{
const sched_kw_gruptree_type * gruptree = sched_kw_get_data( kw );
stringlist_type * parent_group_list = group_list;
stringlist_type * child_group_list = well_list;
sched_kw_gruptree_init_child_parent_list( gruptree , child_group_list , parent_group_list );
sched_history_add_groups_gruptree( sched_history , gruptree , report_step , well_list , group_list );
}
break;
default:
/* */
break;
}
}
}
stringlist_free( well_list );
stringlist_free( group_list );
}
sched_history_install_index( sched_history );
}
/* Writes the complete schedule file. */
void sched_file_fprintf(const sched_file_type * sched_file, const char * file)
{
int num_restart_files = sched_file_get_num_restart_files(sched_file);
sched_file_fprintf_i__( sched_file , num_restart_files - 1 , file , sched_file->hasEND);
}
