void well_rate_sample_shift( well_rate_type * well_rate ) {
int size = time_t_vector_size( well_rate->time_vector );
double * R = util_malloc( size * sizeof * R , __func__);
int i;
rand_stdnormal_vector( size , R );
for (i=0; i < size; i++)
R[i] = R[i] * double_vector_iget( well_rate->std_shift , i ) + double_vector_iget( well_rate->mean_shift , i );
double_vector_iset( well_rate->shift , 0 , R[0]);
for (i=1; i < size; i++) {
double dt = 1.0 * (time_t_vector_iget( well_rate->time_vector , i ) - time_t_vector_iget( well_rate->time_vector , i - 1)) / (24 * 3600); /* Days */
double a = exp(-dt / well_rate->corr_length );
double shift = a * double_vector_iget( well_rate->shift , i - 1 ) + (1 - a) * R[i];
double base_rate = double_vector_safe_iget( well_rate->base_value , i);
/* The time series is sampled - irrespective of whether the well is open or not. */
if ((shift + base_rate) < 0)
shift = -base_rate;
if (sched_history_well_open( well_rate->sched_history , well_rate->name , i))
double_vector_iset( well_rate->shift , i , shift );
else
double_vector_iset( well_rate->shift , i , 0);
}
free( R );
}
void well_rate_eval_stat( well_rate_type * well_rate ) {
for (int i = 0; i < stringlist_get_size( well_rate->mean_shift_string ); i++) {
double mean_shift = sscanfp( double_vector_safe_iget( well_rate->base_value , i ) , stringlist_iget( well_rate->mean_shift_string , i));
double std_shift = sscanfp( double_vector_safe_iget( well_rate->base_value , i ) , stringlist_iget( well_rate->std_shift_string , i));
double_vector_iset( well_rate->mean_shift , i , mean_shift );
double_vector_iset( well_rate->std_shift , i , std_shift);
}
}
void group_rate_init( group_rate_type * group_rate ) {
for (int iw = 0; iw < vector_get_size( group_rate->well_rates ); iw++) {
const well_rate_type * well_rate = vector_iget( group_rate->well_rates , iw );
for (int tstep = 0; tstep < well_rate_get_length( well_rate ); tstep++)
double_vector_iadd( group_rate->base_rate , tstep , well_rate_iget_rate( well_rate , tstep ));
}
for (int i = 0; i < stringlist_get_size( group_rate->min_shift_string ); i++) {
double_vector_iset( group_rate->min_shift , i , sscanfp( double_vector_safe_iget( group_rate->base_rate , i ) , stringlist_iget( group_rate->min_shift_string , i)));
double_vector_iset( group_rate->max_shift , i , sscanfp( double_vector_safe_iget( group_rate->base_rate , i ) , stringlist_iget( group_rate->max_shift_string , i)));
}
}
static void data_ranking_init(data_ranking_type * ranking ,
enkf_fs_type * fs ,
enkf_config_node_type * config_node,
const char * key_index ,
int step ,
state_enum state ) {
enkf_node_type * enkf_node = enkf_node_alloc( config_node );
int iens;
for (iens = 0; iens < ranking->ens_size; iens++) {
double value;
node_id_type node_id = {.report_step = step ,
.iens = iens ,
.state = state
};
if (enkf_node_user_get( enkf_node , fs , key_index , node_id , &value)) {
double_vector_iset( ranking->data_ensemble , iens , value );
bool_vector_iset( ranking->valid , iens , true );
}
}
if (ranking->sort_increasing)
ranking->sort_permutation = double_vector_alloc_sort_perm( ranking->data_ensemble );
else
ranking->sort_permutation = double_vector_alloc_rsort_perm( ranking->data_ensemble );
enkf_node_free( enkf_node );
}
static void SUMMARY_SET_VALUE( summary_type * summary , node_id_type node_id , double value) {
if (summary->vector_storage) {
double_vector_type * storage_vector = SELECT_VECTOR( summary , node_id.state );
double_vector_iset( storage_vector , node_id.report_step , value);
} else
summary->data[0] = value;
}
int ecl_sum_data_get_report_step_from_days(const ecl_sum_data_type * data , double sim_days) {
if ((sim_days < data->days_start) || (sim_days > data->sim_length))
return -1;
else {
int report_step = -1;
double_vector_type * days_map = double_vector_alloc( 0 , 0 );
int_vector_type * report_map = int_vector_alloc( 0 , 0 );
int i;
for (i=1; i < int_vector_size( data->report_last_index ); i++) {
int ministep_index = int_vector_iget( data->report_last_index , i );
const ecl_sum_tstep_type * ministep = vector_iget_const( data->data , ministep_index );
double_vector_iset( days_map , i , ecl_sum_tstep_get_sim_days( ministep ));
int_vector_iset( report_map , i , ecl_sum_tstep_get_report( ministep ));
}
{
/** Hmmmm - double == comparison ... */
int index = double_vector_index_sorted( days_map , sim_days );
if (index >= 0)
report_step = int_vector_iget( report_map , index );
}
int_vector_free( report_map );
double_vector_free( days_map );
return report_step;
}
}
void test_diag_std() {
const int N = 25;
double_vector_type * data = double_vector_alloc( 0,0);
rng_type * rng = rng_alloc(MZRAN , INIT_DEV_URANDOM );
matrix_type * m = matrix_alloc( N , N );
double sum1 = 0;
double sum2 = 0;
int i;
for (i=0; i < N; i++) {
double R = rng_get_double( rng );
matrix_iset(m , i , i , R);
double_vector_iset( data , i , R );
sum1 += R;
sum2 += R*R;
}
{
double mean = sum1 / N;
double std = sqrt( sum2 / N - mean * mean );
test_assert_double_equal( std , matrix_diag_std( m , mean ));
test_assert_double_equal( statistics_std( data ) , matrix_diag_std( m , mean ));
test_assert_double_equal( statistics_mean( data ) , mean );
}
matrix_free( m );
rng_free( rng );
}
void ecl_sum_resample_from_sim_days( const ecl_sum_type * ecl_sum , const double_vector_type * sim_days , double_vector_type * value , const char * gen_key) {
const smspec_node_type * node = ecl_smspec_get_general_var_node( ecl_sum->smspec , gen_key);
double_vector_reset( value );
{
int i;
for (i=0; i < double_vector_size( sim_days ); i++)
double_vector_iset( value , i , ecl_sum_data_get_from_sim_days( ecl_sum->data , double_vector_iget( sim_days , i ) , node));
}
}
void sched_history_init_vector( const sched_history_type * sched_history , const char * key , double_vector_type * value) {
const bool * historical = bool_vector_get_ptr( sched_history->historical );
double_vector_reset( value );
for (int i=0; i < time_t_vector_size( sched_history->time ); i++) {
if (historical[i])
double_vector_iset( value , i , sched_history_iget( sched_history , key , i));
else
break;
}
}
void well_rate_ishift( well_rate_type * well_rate , int index, double new_shift) {
if (sched_history_well_open( well_rate->sched_history , well_rate->name , index)) {
double base_rate = double_vector_safe_iget( well_rate->base_value , index);
double shift = double_vector_safe_iget( well_rate->shift , index) + new_shift;
if ((base_rate + shift) < 0)
shift = -base_rate;
double_vector_iset( well_rate->shift , index , shift );
}
}
void misfit_ranking_iset( misfit_ranking_type * misfit_ranking , int iens , hash_type * obs_hash , double total_misfit) {
if (iens > vector_get_size(misfit_ranking->ensemble))
vector_grow_NULL( misfit_ranking->ensemble , iens );
if (obs_hash != NULL)
vector_iset_owned_ref( misfit_ranking->ensemble , iens , obs_hash , hash_free__ );
else
vector_iset_ref( misfit_ranking->ensemble , iens , NULL );
double_vector_iset( misfit_ranking->total , iens , total_misfit );
}
void gen_data_export_data(const gen_data_type * gen_data , double_vector_type * export_data) {
ecl_data_type internal_type = gen_data_config_get_internal_data_type(gen_data->config);
if (ecl_type_is_double(internal_type))
double_vector_memcpy_from_data( export_data , (const double *) gen_data->data , gen_data_get_size( gen_data ));
else {
double_vector_reset( export_data );
float * float_data = (float *) gen_data->data;
for (int i = 0; i < gen_data_get_size( gen_data ); i++)
double_vector_iset( export_data , i , float_data[i]);
}
}
bool obs_vector_load_from_HISTORY_OBSERVATION(obs_vector_type * obs_vector ,
const conf_instance_type * conf_instance ,
const history_type * history ,
ensemble_config_type * ensemble_config,
double std_cutoff ) {
if(!conf_instance_is_of_class(conf_instance, "HISTORY_OBSERVATION"))
util_abort("%s: internal error. expected \"HISTORY_OBSERVATION\" instance, got \"%s\".\n",__func__, conf_instance_get_class_name_ref(conf_instance) );
{
bool initOK = false;
int size , restart_nr;
double_vector_type * value = double_vector_alloc(0,0);
double_vector_type * std = double_vector_alloc(0,0);
bool_vector_type * valid = bool_vector_alloc(0 , false);
/* The auto_corrf parameters can not be "segmentized" */
double auto_corrf_param = -1;
const char * auto_corrf_name = NULL;
double error = conf_instance_get_item_value_double(conf_instance, "ERROR" );
double error_min = conf_instance_get_item_value_double(conf_instance, "ERROR_MIN" );
const char * error_mode = conf_instance_get_item_value_ref( conf_instance, "ERROR_MODE");
const char * sum_key = conf_instance_get_name_ref( conf_instance );
if(conf_instance_has_item(conf_instance, "AUTO_CORRF")) {
auto_corrf_name = conf_instance_get_item_value_ref( conf_instance , "AUTO_CORRF");
auto_corrf_param = conf_instance_get_item_value_double(conf_instance, "AUTO_CORRF_PARAM");
if(conf_instance_has_item(conf_instance, "AUTO_CORRF_PARAM"))
auto_corrf_param = conf_instance_get_item_value_double(conf_instance, "AUTO_CORRF_PARAM");
else
util_abort("%s: When specifying AUTO_CORRF you must also give a vlaue for AUTO_CORRF_PARAM",__func__);
}
// Get time series data from history object and allocate
size = history_get_last_restart(history);
if (history_init_ts( history , sum_key , value , valid )) {
// Create the standard deviation vector
if(strcmp(error_mode, "ABS") == 0) {
for( restart_nr = 0; restart_nr < size; restart_nr++)
double_vector_iset( std , restart_nr , error );
} else if(strcmp(error_mode, "REL") == 0) {
for( restart_nr = 0; restart_nr < size; restart_nr++)
double_vector_iset( std , restart_nr , error * abs( double_vector_iget( value , restart_nr )));
} else if(strcmp(error_mode, "RELMIN") == 0) {
for(restart_nr = 0; restart_nr < size; restart_nr++) {
double tmp_std = util_double_max( error_min , error * abs( double_vector_iget( value , restart_nr )));
double_vector_iset( std , restart_nr , tmp_std);
}
} else
util_abort("%s: Internal error. Unknown error mode \"%s\"\n", __func__, error_mode);
// Handle SEGMENTs which can be used to customize the observation error. */
{
stringlist_type * segment_keys = conf_instance_alloc_list_of_sub_instances_of_class_by_name(conf_instance, "SEGMENT");
stringlist_sort( segment_keys , NULL );
int num_segments = stringlist_get_size(segment_keys);
for(int segment_nr = 0; segment_nr < num_segments; segment_nr++)
{
const char * segment_name = stringlist_iget(segment_keys, segment_nr);
const conf_instance_type * segment_conf = conf_instance_get_sub_instance_ref(conf_instance, segment_name);
int start = conf_instance_get_item_value_int( segment_conf, "START" );
int stop = conf_instance_get_item_value_int( segment_conf, "STOP" );
double error_segment = conf_instance_get_item_value_double(segment_conf, "ERROR" );
double error_min_segment = conf_instance_get_item_value_double(segment_conf, "ERROR_MIN" );
const char * error_mode_segment = conf_instance_get_item_value_ref( segment_conf, "ERROR_MODE");
if(start < 0)
{
printf("%s: WARNING - Segment out of bounds. Truncating start of segment to 0.\n", __func__);
start = 0;
}
if(stop >= size)
{
printf("%s: WARNING - Segment out of bounds. Truncating end of segment to %d.\n", __func__, size - 1);
stop = size -1;
}
if(start > stop)
{
printf("%s: WARNING - Segment start after stop. Truncating end of segment to %d.\n", __func__, start );
stop = start;
}
// Create the standard deviation vector
if(strcmp(error_mode_segment, "ABS") == 0) {
for( restart_nr = start; restart_nr <= stop; restart_nr++)
double_vector_iset( std , restart_nr , error_segment) ;
} else if(strcmp(error_mode_segment, "REL") == 0) {
for( restart_nr = start; restart_nr <= stop; restart_nr++)
double_vector_iset( std , restart_nr , error_segment * abs(double_vector_iget( value , restart_nr)));
} else if(strcmp(error_mode_segment, "RELMIN") == 0) {
for(restart_nr = start; restart_nr <= stop ; restart_nr++) {
double tmp_std = util_double_max( error_min_segment , error_segment * abs( double_vector_iget( value , restart_nr )));
double_vector_iset( std , restart_nr , tmp_std);
}
} else
util_abort("%s: Internal error. Unknown error mode \"%s\"\n", __func__, error_mode);
}
stringlist_free(segment_keys);
}
/*
This is where the summary observations are finally added.
*/
for (restart_nr = 0; restart_nr < size; restart_nr++) {
if (bool_vector_safe_iget( valid , restart_nr)) {
if (double_vector_iget( std , restart_nr) > std_cutoff) {
obs_vector_add_summary_obs( obs_vector , restart_nr , sum_key , sum_key ,
double_vector_iget( value ,restart_nr) , double_vector_iget( std , restart_nr ) ,
auto_corrf_name , auto_corrf_param);
} else
fprintf(stderr,"** Warning: to small observation error in observation %s:%d - ignored. \n", sum_key , restart_nr);
}
}
initOK = true;
}
double_vector_free(std);
double_vector_free(value);
bool_vector_free(valid);
return initOK;
}
}
void ecl_grav_add_std_density( ecl_grav_type * grav , ecl_phase_enum phase , int pvtnum , double density) {
double_vector_type * std_density = hash_get( grav->std_density , ecl_util_get_phase_name( phase ));
double_vector_iset( std_density , pvtnum , density );
}
void misfit_ts_iset( misfit_ts_type * vector , int time_index , double value ) {
double_vector_iset( vector->data , time_index , value );
}
