static bool enkf_config_node_has_container(const enkf_config_node_type * node , enkf_fs_type * fs , node_id_type node_id) { bool has_container = true; for (int inode=0; inode < vector_get_size( node->container_nodes ); inode++) { enkf_config_node_type * child_node = vector_iget( node->container_nodes , inode ); if (!enkf_config_node_has_node( child_node , fs , node_id )) { has_container = false; break; } } return has_container; }
static void enkf_main_copy_ensemble( const enkf_main_type * enkf_main, enkf_fs_type * source_case_fs, int source_report_step, state_enum source_state, enkf_fs_type * target_case_fs, int target_report_step, state_enum target_state, const bool_vector_type * iens_mask, const char * ranking_key , /* It is OK to supply NULL - but if != NULL it must exist */ const stringlist_type * node_list) { const int ens_size = enkf_main_get_ensemble_size( enkf_main ); state_map_type * target_state_map = enkf_fs_get_state_map(target_case_fs); { int * ranking_permutation; int inode , src_iens; if (ranking_key != NULL) { ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main ); ranking_permutation = (int *) ranking_table_get_permutation( ranking_table , ranking_key ); } else { ranking_permutation = util_calloc( ens_size , sizeof * ranking_permutation ); for (src_iens = 0; src_iens < ens_size; src_iens++) ranking_permutation[src_iens] = src_iens; } for (inode =0; inode < stringlist_get_size( node_list ); inode++) { enkf_config_node_type * config_node = ensemble_config_get_node( enkf_main_get_ensemble_config(enkf_main) , stringlist_iget( node_list , inode )); for (src_iens = 0; src_iens < enkf_main_get_ensemble_size( enkf_main ); src_iens++) { if (bool_vector_safe_iget(iens_mask , src_iens)) { int target_iens = ranking_permutation[src_iens]; node_id_type src_id = {.report_step = source_report_step , .iens = src_iens , .state = source_state }; node_id_type target_id = {.report_step = target_report_step , .iens = target_iens , .state = target_state }; /* The copy is careful ... */ if (enkf_config_node_has_node( config_node , source_case_fs , src_id)) enkf_node_copy( config_node , source_case_fs , target_case_fs , src_id , target_id ); if (0 == target_report_step) state_map_iset(target_state_map, target_iens, STATE_INITIALIZED); } } } if (ranking_permutation == NULL) free( ranking_permutation ); } }
static bool obs_vector_has_data_at_report_step( const obs_vector_type * obs_vector , const bool_vector_type * active_mask , enkf_fs_type * fs, int report_step) { void * obs_node = vector_iget( obs_vector->nodes , report_step ); if ( obs_node ) { node_id_type node_id = {.report_step = report_step }; for (int iens = 0; iens < bool_vector_size( active_mask ); iens++) { if (bool_vector_iget( active_mask , iens)) { node_id.iens = iens; if (! enkf_config_node_has_node(obs_vector->config_node , fs , node_id )) return false; } } } /* Will return true unconditionally if we do not have observation data at this report step; or alternatively if the active_mask is all false. */ return true; }
static bool enkf_main_case_is_initialized__( const enkf_main_type * enkf_main , enkf_fs_type * fs , bool_vector_type * __mask) { stringlist_type * parameter_keys = ensemble_config_alloc_keylist_from_var_type( enkf_main->ensemble_config , PARAMETER ); bool_vector_type * mask; bool initialized = true; int ikey = 0; if (__mask != NULL) mask = __mask; else mask = bool_vector_alloc(0 , true ); while ((ikey < stringlist_get_size( parameter_keys )) && (initialized)) { const enkf_config_node_type * config_node = ensemble_config_get_node( enkf_main->ensemble_config , stringlist_iget( parameter_keys , ikey) ); int iens = 0; do { if (bool_vector_safe_iget( mask , iens)) { node_id_type node_id = {.report_step = 0 , .iens = iens , .state = ANALYZED }; initialized = enkf_config_node_has_node( config_node , fs , node_id); } iens++; } while ((iens < enkf_main->ens_size) && (initialized)); ikey++; } stringlist_free( parameter_keys ); if (__mask == NULL) bool_vector_free( mask ); return initialized; } bool enkf_main_case_is_initialized( const enkf_main_type * enkf_main , const char * case_name , bool_vector_type * __mask) { enkf_fs_type * fs = enkf_main_mount_alt_fs(enkf_main , case_name , false ); if (fs) { bool initialized = enkf_main_case_is_initialized__(enkf_main , fs , __mask); enkf_fs_decref( fs ); return initialized; } else return false; }