void test_correct_time_vector() {
ecl_sum_type * ecl_sum = test_alloc_ecl_sum();
time_t_vector_type * t = time_t_vector_alloc( 0 , 0 );
time_t_vector_append(t, util_make_date_utc( 2,1,2010 ));
time_t_vector_append(t, util_make_date_utc( 4,1,2010 ));
time_t_vector_append(t, util_make_date_utc( 6,1,2010 ));
time_t_vector_append(t, util_make_date_utc( 8,1,2010 ));
ecl_sum_type * ecl_sum_resampled = ecl_sum_alloc_resample(ecl_sum, "kk", t);
test_assert_int_equal( ecl_sum_get_report_time(ecl_sum_resampled, 2) , util_make_date_utc( 6,1,2010 ));
const ecl_smspec_type * smspec_resampled = ecl_sum_get_smspec(ecl_sum_resampled);
const smspec_node_type * node1 = ecl_smspec_iget_node(smspec_resampled, 1);
const smspec_node_type * node2 = ecl_smspec_iget_node(smspec_resampled, 2);
const smspec_node_type * node3 = ecl_smspec_iget_node(smspec_resampled, 3);
test_assert_string_equal( "BPR" , smspec_node_get_keyword(node2) );
test_assert_string_equal( "BARS" , smspec_node_get_unit(node2) );
test_assert_double_equal(3.33333, ecl_sum_get_from_sim_time( ecl_sum_resampled, util_make_date_utc( 6,1,2010 ), node1) );
test_assert_double_equal(3.33333, ecl_sum_get_from_sim_time( ecl_sum_resampled, util_make_date_utc( 2,1,2010 ), node2) );
test_assert_double_equal(10.0000, ecl_sum_get_from_sim_time( ecl_sum_resampled, util_make_date_utc( 4,1,2010 ), node3) );
ecl_sum_free(ecl_sum_resampled);
time_t_vector_free(t);
ecl_sum_free(ecl_sum);
}
int main(int argc , char ** argv) {
const char * data_file = argv[1];
ecl_sum_type * ecl_sum = ecl_sum_fread_alloc_case( data_file , ":");
if (ecl_sum != NULL) {
stringlist_type * keys = stringlist_alloc_new();
if (argc == 2)
ecl_sum_select_matching_general_var_list( ecl_sum , "*" , keys);
else {
for (int iarg = 2; iarg < argc; iarg++) {
printf("Matchging:%s \n",argv[iarg]);
ecl_sum_select_matching_general_var_list( ecl_sum , argv[iarg] , keys);
}
}
stringlist_sort( keys , NULL );
{
int i;
for (i=0; i < stringlist_get_size( keys ); i++)
printf("%s \n",stringlist_iget( keys , i ));
}
stringlist_free( keys );
ecl_sum_free(ecl_sum);
} else
fprintf(stderr,"key_list.x: No summary data found for case:%s\n", data_file );
}
void test_time_before() {
ecl_sum_type * ecl_sum = test_alloc_ecl_sum();
time_t_vector_type * t = time_t_vector_alloc( 0 , 0 );
time_t_vector_append(t, util_make_date_utc( 1,1,2009 ));
test_assert_NULL( ecl_sum_alloc_resample(ecl_sum, "kk", t) );
time_t_vector_free(t);
ecl_sum_free(ecl_sum);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifReaderEclipseSummary::close()
{
if (ecl_sum)
{
ecl_sum_free(ecl_sum);
ecl_sum = NULL;
}
}
int main( int argc , char ** argv) {
const char * case1 = argv[1];
ecl_sum_type * ecl_sum1 = ecl_sum_fread_alloc_case( case1 , ":");
test_assert_true( ecl_sum_is_instance( ecl_sum1 ));
test_time_range( ecl_sum1 );
test_days( ecl_sum1 );
test_is_oil_producer(ecl_sum1);
ecl_sum_free( ecl_sum1 );
exit(0);
}
int main( int argc , char ** argv) {
const char * case1 = argv[1];
const char * case2 = argv[2];
const char * compatible_string = argv[3];
bool compatible;
ecl_sum_type * ecl_sum1 = ecl_sum_fread_alloc_case( case1 , ":");
ecl_sum_type * ecl_sum2 = ecl_sum_fread_alloc_case( case2 , ":");
test_assert_true( ecl_sum_is_instance( ecl_sum1 ));
test_assert_true( ecl_sum_is_instance( ecl_sum2 ));
test_assert_true( ecl_sum_report_step_compatible( ecl_sum1 , ecl_sum1) );
test_assert_true( util_sscanf_bool( compatible_string , &compatible ));
test_assert_true( ecl_sum_report_step_compatible( ecl_sum1 , ecl_sum1) );
test_assert_true( ecl_sum_report_step_compatible( ecl_sum2 , ecl_sum2) );
test_assert_bool_equal( compatible , ecl_sum_report_step_compatible( ecl_sum1 , ecl_sum2 ));
ecl_sum_free( ecl_sum1 );
ecl_sum_free( ecl_sum2 );
exit(0);
}
ecl_sum_type * ecl_sum_fread_alloc_case__(const char * input_file , const char * key_join_string , bool include_restart){
ecl_sum_type * ecl_sum = ecl_sum_alloc__(input_file , key_join_string);
if (ecl_sum_fread_case( ecl_sum , include_restart))
return ecl_sum;
else {
/*
Loading a case failed - we discard the partly initialized
ecl_sum structure and jump ship.
*/
ecl_sum_free( ecl_sum );
return NULL;
}
}
void test_load() {
test_work_area_type * work_area = test_work_area_alloc("unsmry_loader");
ecl_sum_type * ecl_sum = write_ecl_sum();
test_assert_true( util_file_exists("CASE.SMSPEC") );
test_assert_true( util_file_exists("CASE.UNSMRY") );
ecl::unsmry_loader * loader = new ecl::unsmry_loader(ecl_sum_get_smspec(ecl_sum), "CASE.UNSMRY", 0);
const std::vector<double> FOPT_value = loader->get_vector(1);
const std::vector<double> BPR_value = loader->get_vector(2);
const std::vector<double> WWCT_value = loader->get_vector(3);
test_assert_int_equal( FOPT_value.size(), 4 );
test_assert_double_equal( FOPT_value[3] , 6.0 );
test_assert_double_equal( BPR_value[2] , 10.0 );
test_assert_double_equal( WWCT_value[1] , 10.0 );
delete loader;
ecl_sum_free(ecl_sum);
test_work_area_free(work_area);
}
void ecl_test( const char * ecl_case ) {
ecl_sum_type * ecl_sum = ecl_sum_fread_alloc_case( ecl_case , ":");
time_t start_time = ecl_sum_get_start_time( ecl_sum );
time_t end_time = ecl_sum_get_end_time( ecl_sum );
time_map_type * ecl_map = time_map_alloc( );
test_assert_true( time_map_summary_update( ecl_map , ecl_sum ) );
test_assert_true( time_map_summary_update( ecl_map , ecl_sum ) );
test_assert_time_t_equal( time_map_get_start_time( ecl_map ) , start_time );
test_assert_time_t_equal( time_map_get_end_time( ecl_map ) , end_time );
test_assert_double_equal( time_map_get_end_days( ecl_map ) , ecl_sum_get_sim_length( ecl_sum ));
time_map_clear( ecl_map );
time_map_update( ecl_map , 1 , 256 );
test_assert_false( time_map_summary_update( ecl_map , ecl_sum ));
time_map_free( ecl_map );
ecl_sum_free( ecl_sum );
}
void ecl_sum_free__(void * __ecl_sum) {
ecl_sum_type * ecl_sum = ecl_sum_safe_cast( __ecl_sum);
ecl_sum_free( ecl_sum );
}
void sum_case_free( sum_case_type * sum_case) {
ecl_sum_free( sum_case->ecl_sum );
double_vector_free( sum_case->interp_data );
free( sum_case );
}
SummaryComparator::~SummaryComparator(){
ecl_sum_free(ecl_sum1);
ecl_sum_free(ecl_sum2);
stringlist_free(keys1);
stringlist_free(keys2);
}
ECLSummaryReader::~ECLSummaryReader()
{
ecl_sum_free(ecl_sum_);
}
int main(int argc , char ** argv) {
install_SIGNALS();
{
bool report_only = false;
bool list_mode = false;
bool include_restart = true;
bool print_header = true;
int arg_offset = 1;
#ifdef ERT_HAVE_GETOPT
if (argc == 1)
print_help_and_exit();
else {
static struct option long_options[] = {
{"no-restart" , 0 , 0 , 'n'} ,
{"list" , 0 , 0 , 'l'} ,
{"report-only" , 0 , 0 , 'r'} ,
{"no-header" , 0 , 0 , 'x'} ,
{"help" , 0 , 0 , 'h'} ,
{ 0 , 0 , 0 , 0} };
while (1) {
int c;
int option_index = 0;
c = getopt_long (argc, argv, "nlRrx", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'n':
include_restart = false;
break;
case 'r':
report_only = true;
break;
case 'l':
list_mode = true;
break;
case 'x':
print_header = false;
break;
case 'h':
print_help_and_exit();
break;
case '?':
printf("Hmmm - unrecognized option???");
break;
}
}
arg_offset = optind; /* External static variable in the getopt scope*/
}
#endif
if (arg_offset >= argc)
print_help_and_exit();
{
char * data_file = argv[arg_offset];
ecl_sum_type * ecl_sum;
int num_keys = argc - arg_offset - 1;
const char ** arg_list = (const char **) &argv[arg_offset + 1];
ecl_sum = ecl_sum_fread_alloc_case__( data_file , ":" , include_restart);
/** If no keys have been presented the function will list available keys. */
if (num_keys == 0)
list_mode = true;
if (ecl_sum != NULL) {
if (list_mode) {
/*
The program is called in list mode, we only print the
(matching) keys in a table on stdout. If no arguments
have been given on the commandline, all internalized keys
will be printed.
*/
stringlist_type * keys = stringlist_alloc_new();
if (num_keys == 0) {
ecl_sum_select_matching_general_var_list( ecl_sum , "*" , keys);
stringlist_sort(keys , NULL );
} else
build_key_list( ecl_sum , keys , num_keys , arg_list);
{
int columns = 5;
int i;
for (i=0; i< stringlist_get_size( keys ); i++) {
printf("%-24s ",stringlist_iget( keys , i ));
if ((i % columns) == 4)
printf("\n");
}
printf("\n");
}
stringlist_free( keys );
} else {
/* Normal operation print results for the various keys on stdout. */
ecl_sum_fmt_type fmt;
stringlist_type * key_list = stringlist_alloc_new( );
build_key_list( ecl_sum , key_list , num_keys , arg_list);
if (print_header)
ecl_sum_fmt_init_summary_x(ecl_sum , &fmt );
else
fmt.print_header = false;
ecl_sum_fprintf(ecl_sum , stdout , key_list , report_only , &fmt);
stringlist_free( key_list );
}
ecl_sum_free(ecl_sum);
} else
fprintf(stderr,"summary.x: No summary data found for case:%s\n", data_file );
}
}
}
