int main(int argc, char ** argv) { int num_src_drivers = 10; int num_target_drivers = 32; if (argc != 4) usage(); { char * src_path = argv[1] ; char * target_path = argv[2] ; char * dir = argv[3] ; util_make_path( target_path ); if (util_same_file( src_path , target_path)) { fprintf(stderr,"The two directories:%s and %s point to the same location \n" , src_path , target_path ); exit(1); } { char * src_case = util_alloc_sprintf("%s/%s" , src_path , dir ); char * target_case = util_alloc_sprintf("%s/%s" , target_path , dir ); msg_type * msg = msg_alloc("Copying from: " , false); msg_show( msg ); migrate_file(src_case , num_src_drivers , target_case , num_target_drivers , "ANALYZED" , 32 , msg); migrate_file(src_case , num_src_drivers , target_case , num_target_drivers , "FORECAST" , 32 , msg); migrate_file(src_case , num_src_drivers , target_case , num_target_drivers , "PARAMETER" , 32 , msg); migrate_file(src_case , num_src_drivers , target_case , num_target_drivers , "STATIC" , 32 , msg); copy_index( src_case , target_case ); free( src_case); free( target_case ); msg_free( msg , true ); } } }
static ssize_t msg_copy_to_user(const char *prefix, const char *msg, char __user *buf, size_t count, loff_t *f_pos) { ssize_t ret = 0; int len; msg_show(prefix, (AE_Msg*)msg); if (msg == NULL) return 0; len = ((AE_Msg*)msg)->len + sizeof(AE_Msg); if (*f_pos >= len) { ret = 0; goto out; } // TODO: semaphore if ((*f_pos + count) > len) { xlog_printk(ANDROID_LOG_ERROR, AEK_LOG_TAG, "read size overflow, count=%d, *f_pos=%d\n", count, (int)*f_pos); count = len - *f_pos; ret = -EFAULT; goto out; } if (copy_to_user(buf, msg + *f_pos, count)) { xlog_printk(ANDROID_LOG_ERROR, AEK_LOG_TAG, "copy_to_user failed\n"); ret = -EFAULT; goto out; } *f_pos += count; ret = count; out: return ret; }
void misfit_ensemble_initialize( misfit_ensemble_type * misfit_ensemble , const ensemble_config_type * ensemble_config , const enkf_obs_type * enkf_obs , enkf_fs_type * fs , int ens_size , int history_length, bool force_init) { if (force_init || !misfit_ensemble->initialized) { misfit_ensemble_clear( misfit_ensemble ); msg_type * msg = msg_alloc("Evaluating misfit for observation: " , false); double ** chi2_work = __2d_malloc( history_length + 1 , ens_size ); bool_vector_type * iens_valid = bool_vector_alloc( ens_size , true ); hash_iter_type * obs_iter = enkf_obs_alloc_iter( enkf_obs ); const char * obs_key = hash_iter_get_next_key( obs_iter ); misfit_ensemble->history_length = history_length; misfit_ensemble_set_ens_size( misfit_ensemble , ens_size ); msg_show( msg ); while (obs_key != NULL) { obs_vector_type * obs_vector = enkf_obs_get_vector( enkf_obs , obs_key ); msg_update( msg , obs_key ); bool_vector_reset( iens_valid ); bool_vector_iset( iens_valid , ens_size - 1 , true ); obs_vector_ensemble_chi2( obs_vector , fs , iens_valid , 0 , misfit_ensemble->history_length, 0 , ens_size , chi2_work); /** Internalizing the results from the chi2_work table into the misfit structure. */ for (int iens = 0; iens < ens_size; iens++) { misfit_member_type * node = misfit_ensemble_iget_member( misfit_ensemble , iens ); if (bool_vector_iget( iens_valid , iens)) misfit_member_update( node , obs_key , misfit_ensemble->history_length , iens , (const double **) chi2_work); } obs_key = hash_iter_get_next_key( obs_iter ); } bool_vector_free( iens_valid ); msg_free(msg , true ); hash_iter_free( obs_iter ); __2d_free( chi2_work , misfit_ensemble->history_length + 1); misfit_ensemble->initialized = true; } }
int main(int argc , char ** argv) { install_SIGNALS(); if (argc < 4) usage(); { const char * src_mount = argv[1]; const char * target_mount = argv[2]; if (block_fs_is_mount(src_mount)) { const char * pattern = NULL; int iarg; for (iarg = 3; iarg < argc; iarg++) { if (argv[iarg][0] == '-') { /** OK - this is an option .. */ } else pattern = argv[iarg]; } { block_fs_type * src_fs = block_fs_mount(src_mount , 1 , 0 , 1 , 0 , false , true ); block_fs_type * target_fs = block_fs_mount(target_mount , 1 , 0 , 1 , 0 , false , false ); vector_type * files = block_fs_alloc_filelist( src_fs , pattern , NO_SORT , false ); buffer_type * buffer = buffer_alloc( 1024 ); { int i; msg_type * msg = msg_alloc("Copying :" , false); msg_show( msg ); for (i=0; i < vector_get_size( files ); i++) { const user_file_node_type * node = vector_iget_const( files , i ); const char * filename = user_file_node_get_filename( node ); msg_update( msg , filename ); block_fs_fread_realloc_buffer( src_fs , filename , buffer ); block_fs_fwrite_buffer( target_fs , filename , buffer ); } msg_free( msg , true ); } buffer_free( buffer ); vector_free( files ); block_fs_close( target_fs , true); block_fs_close( src_fs , false ); } } else fprintf(stderr,"The files:%s/%s does not seem to be a block_fs mount files.\n" , src_mount , target_mount); } }
void handle_control_message(const char *msg, const char *arg) { if (!strcmp(msg,"start")) { msg_start(arg); } else if (!strcmp(msg,"stop")) { msg_stop(arg); } else if (!strcmp(msg,"restart")) { msg_restart(arg); } #ifdef MTK_INIT else if (!strcmp(msg,"show")) { msg_show(arg); } #endif else { ERROR("unknown control msg '%s'\n", msg); } }
static ssize_t aed_ke_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) { AE_Msg msg; int rsize; // recevied a new request means the previous response is unavilable // 1. set position to be zero // 2. destroy the previous response message *f_pos = 0; msg_destroy(&aed_dev.kerec.msg); // the request must be an *AE_Msg buffer if (count != sizeof(AE_Msg)) { xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "ERR: aed_wirte count=%d\n", count); return -1; } rsize = copy_from_user(&msg, buf, count); if (rsize != 0) { xlog_printk(ANDROID_LOG_DEBUG, AEK_LOG_TAG, "copy_from_user rsize=%d\n", rsize); return -1; } msg_show(__func__, &msg); if (msg.cmdType == AE_REQ) { if (!ke_log_avail()) { ke_gen_notavail_msg(); return count; } switch(msg.cmdId) { case AE_REQ_CLASS: ke_gen_class_msg(); break; case AE_REQ_TYPE: ke_gen_type_msg(); break; case AE_REQ_MODULE: ke_gen_module_msg(); break; case AE_REQ_DETAIL: ke_gen_detail_msg(&msg); break; case AE_REQ_PROCESS: ke_gen_process_msg(); break; case AE_REQ_BACKTRACE: ke_gen_backtrace_msg(); break; default: ke_gen_notavail_msg(); break; } } else if (msg.cmdType == AE_IND) { switch(msg.cmdId) { case AE_IND_LOG_CLOSE: ke_destroy_log(); break; default: // IGNORE break; } } else if (msg.cmdType == AE_RSP) { // IGNORE } return count; }
static void enkf_tui_fs_copy_ensemble__( enkf_main_type * enkf_main, const char * source_case, const char * target_case, int report_step_from, state_enum state_from, int report_step_to, state_enum state_to, bool only_parameters) { msg_type * msg = msg_alloc("Copying: " , false); ensemble_config_type * config = enkf_main_get_ensemble_config(enkf_main); int ens_size = enkf_main_get_ensemble_size(enkf_main); char * ranking_key; const int * ranking_permutation = NULL; int * identity_permutation; ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main ); if (ranking_table_get_size( ranking_table ) > 0) { util_printf_prompt("Name of ranking to resort by (or blank)" , 50 , '=' , "=> "); ranking_key = util_alloc_stdin_line(); if (ranking_table_has_ranking( ranking_table , ranking_key )) ranking_permutation = ranking_table_get_permutation( ranking_table , ranking_key ); else { fprintf(stderr," Sorry: ranking:%s does not exist \n", ranking_key ); return; } } identity_permutation = util_calloc( ens_size , sizeof * identity_permutation ); { int iens; for (iens =0; iens < ens_size; iens++) identity_permutation[iens] = iens; } if (ranking_permutation == NULL) ranking_permutation = identity_permutation; { /* If the current target_case does not exist it is automatically created by the select_write_dir function */ enkf_fs_type * src_fs = enkf_main_mount_alt_fs( enkf_main , source_case , false ); enkf_fs_type * target_fs = enkf_main_mount_alt_fs( enkf_main , target_case , true ); stringlist_type * nodes = ensemble_config_alloc_keylist_from_var_type(config, PARAMETER); { int num_nodes = stringlist_get_size(nodes); msg_show(msg); for(int i = 0; i < num_nodes; i++) { const char * key = stringlist_iget(nodes, i); enkf_config_node_type * config_node = ensemble_config_get_node(config , key); msg_update(msg , key); enkf_node_copy_ensemble(config_node, src_fs , target_fs , report_step_from, state_from, report_step_to , state_to , ens_size , ranking_permutation); } } enkf_fs_decref( src_fs ); enkf_fs_decref( target_fs ); msg_free(msg , true); stringlist_free(nodes); } free( identity_permutation ); }
int main(int argc, char ** argv) { int num_files = argc - 1; if (num_files >= 1) { /* File type and formatted / unformatted is determined from the first argument on the command line. */ char * ecl_base; char * path; ecl_file_enum file_type , target_type; bool fmt_file; /** Look at the first command line argument to determine type and formatted/unformatted status. */ file_type = ecl_util_get_file_type( argv[1] , &fmt_file , NULL); if (file_type == ECL_SUMMARY_FILE) target_type = ECL_UNIFIED_SUMMARY_FILE; else if (file_type == ECL_RESTART_FILE) target_type = ECL_UNIFIED_RESTART_FILE; else { util_exit("The ecl_pack program can only be used with ECLIPSE restart files or summary files.\n"); target_type = -1; } util_alloc_file_components( argv[1] , &path , &ecl_base , NULL); /** Will pack to cwd, even though the source files might be somewhere else. To unpack to the same directory as the source files, just send in @path as first argument when creating the target_file. */ { msg_type * msg; int i , report_step , prev_report_step; char * target_file_name = ecl_util_alloc_filename( NULL , ecl_base , target_type , fmt_file , -1); stringlist_type * filelist = stringlist_alloc_argv_copy( (const char **) &argv[1] , num_files ); ecl_kw_type * seqnum_kw = NULL; fortio_type * target = fortio_open_writer( target_file_name , fmt_file , ECL_ENDIAN_FLIP); if (target_type == ECL_UNIFIED_RESTART_FILE) { int dummy; seqnum_kw = ecl_kw_alloc_new("SEQNUM" , 1 , ECL_INT_TYPE , &dummy); } { char * msg_format = util_alloc_sprintf("Packing %s <= " , target_file_name); msg = msg_alloc( msg_format , false); free( msg_format ); } msg_show( msg ); stringlist_sort( filelist , ecl_util_fname_report_cmp); prev_report_step = -1; for (i=0; i < num_files; i++) { ecl_file_enum this_file_type; this_file_type = ecl_util_get_file_type( stringlist_iget(filelist , i) , NULL , &report_step); if (this_file_type == file_type) { if (report_step == prev_report_step) util_exit("Tried to write same report step twice: %s / %s \n", stringlist_iget(filelist , i-1) , stringlist_iget(filelist , i)); prev_report_step = report_step; msg_update(msg , stringlist_iget( filelist , i)); { ecl_file_type * src_file = ecl_file_open( stringlist_iget( filelist , i) , 0 ); if (target_type == ECL_UNIFIED_RESTART_FILE) { /* Must insert the SEQNUM keyword first. */ ecl_kw_iset_int(seqnum_kw , 0 , report_step); ecl_kw_fwrite( seqnum_kw , target ); } ecl_file_fwrite_fortio( src_file , target , 0); ecl_file_close( src_file ); } } /* Else skipping file of incorrect type. */ } msg_free(msg , false); fortio_fclose( target ); free(target_file_name); stringlist_free( filelist ); if (seqnum_kw != NULL) ecl_kw_free(seqnum_kw); } free(ecl_base); util_safe_free(path); } }
double obs_vector_total_chi2(const obs_vector_type * obs_vector , enkf_fs_type * fs , int iens, state_enum load_state) { int report_step; double sum_chi2 = 0; enkf_node_type * enkf_node = enkf_node_alloc( obs_vector->config_node ); node_id_type node_id = {.report_step = 0, .iens = iens , .state = load_state }; for (report_step = 0; report_step < vector_get_size( obs_vector->nodes ); report_step++) { if (vector_iget(obs_vector->nodes , report_step) != NULL) { node_id.report_step = report_step; if (enkf_node_try_load( enkf_node , fs , node_id)) sum_chi2 += obs_vector_chi2__(obs_vector , report_step , enkf_node, node_id); } } enkf_node_free( enkf_node ); return sum_chi2; } /** This function will sum up all timesteps of the obs_vector, for all ensemble members. */ void obs_vector_ensemble_total_chi2(const obs_vector_type * obs_vector , enkf_fs_type * fs , int ens_size , state_enum load_state , double * sum_chi2) { const bool verbose = true; msg_type * msg; int report_step; int iens; char * msg_text = NULL; for (iens = 0; iens < ens_size; iens++) sum_chi2[iens] = 0; if (verbose) { msg = msg_alloc("Observation: " , false); msg_show(msg); } { node_id_type node_id = {.report_step = 0, .iens = iens , .state = load_state }; enkf_node_type * enkf_node = enkf_node_alloc( obs_vector->config_node ); for (report_step = 0; report_step < vector_get_size( obs_vector->nodes); report_step++) { if (verbose) { msg_text = util_realloc_sprintf( msg_text , "%s[%03d]" , obs_vector->obs_key , report_step); msg_update(msg , msg_text); } if (vector_iget(obs_vector->nodes , report_step) != NULL) { node_id.report_step = report_step; for (iens = 0; iens < ens_size; iens++) { node_id.iens = iens; if (enkf_node_try_load( enkf_node , fs , node_id)) sum_chi2[iens] += obs_vector_chi2__(obs_vector , report_step , enkf_node, node_id); } } } enkf_node_free( enkf_node ); } if (verbose) { msg_free(msg , true); util_safe_free( msg_text ); } } const char * obs_vector_get_obs_key( const obs_vector_type * obs_vector) { return obs_vector->obs_key; } /*****************************************************************/ VOID_FREE(obs_vector)
void unpack_file(const char * filename) { ecl_file_enum target_type = ECL_OTHER_FILE; ecl_file_enum file_type; bool fmt_file; file_type = ecl_util_get_file_type(filename , &fmt_file , NULL); if (file_type == ECL_UNIFIED_SUMMARY_FILE) target_type = ECL_SUMMARY_FILE; else if (file_type == ECL_UNIFIED_RESTART_FILE) target_type = ECL_RESTART_FILE; else util_exit("Can only unpack unified ECLIPSE summary and restart files\n"); if (target_type == ECL_SUMMARY_FILE) { printf("** Warning: when unpacking unified summary files it as ambigous - starting with 0001 -> \n"); } { ecl_file_type * src_file = ecl_file_open( filename , 0 ); int size; int offset; int report_step = 0; int block_index = 0; char * path; char * base; msg_type * msg; util_alloc_file_components( filename , &path , &base , NULL); { char * label = util_alloc_sprintf("Unpacking %s => ", filename); msg = msg_alloc( label , false); free( label ); } msg_show(msg); if (target_type == ECL_SUMMARY_FILE) size = ecl_file_get_num_named_kw( src_file , "SEQHDR" ); else size = ecl_file_get_num_named_kw( src_file , "SEQNUM" ); while (true) { if (block_index == size) break; if (target_type == ECL_SUMMARY_FILE) { ecl_file_select_block( src_file , SEQHDR_KW , block_index ); report_step += 1; offset = 0; } else { ecl_kw_type * seqnum_kw; ecl_file_select_block( src_file , SEQNUM_KW , block_index ); seqnum_kw = ecl_file_iget_named_kw( src_file , SEQNUM_KW , 0); report_step = ecl_kw_iget_int( seqnum_kw , 0); offset = 1; } /** Will unpack to cwd, even though the source files might be somewhere else. To unpack to the same directory as the source files, just send in @path as first argument when creating the target_file. */ { char * target_file = ecl_util_alloc_filename( NULL , base , target_type , fmt_file , report_step); fortio_type * fortio_target = fortio_open_writer( target_file , fmt_file , ECL_ENDIAN_FLIP ); msg_update(msg , target_file); ecl_file_fwrite_fortio( src_file , fortio_target , offset); fortio_fclose(fortio_target); free(target_file); } block_index++; } ecl_file_close( src_file ); util_safe_free(path); free(base); msg_free(msg , true); } }