static void library_set_aspect_filter(library_view_t* view, aspect_enum aspect) { log_debug("aspect"); set_t* filtered_artists = library_filtered_artists(view->library); set_t* filtered_albums = library_filtered_albums(view->library); log_debug3("albums %d, artists %d", set_count(filtered_albums), set_count(filtered_artists)); if (aspect == GENRE_ASPECT) { string_model_set_valid(view->artist_model, filtered_artists); string_model_set_valid(view->album_model, filtered_albums); if (set_count(filtered_artists) <= set_count(filtered_albums)) { library_view_aspect_page(view, ARTIST_ASPECT); } else { library_view_aspect_page(view, ALBUM_ASPECT); } } else if (aspect == ALBUM_ASPECT) { string_model_set_valid(view->artist_model, filtered_artists); } else if (aspect == ARTIST_ASPECT) { string_model_set_valid(view->album_model, filtered_albums); library_view_aspect_page(view, ALBUM_ASPECT); } playlist_model_set_valid(view->playlist_model, library_filtered_tracks(view->library)); get_column_layout(view, playlist_model_tracks_hash(view->playlist_model)); }
void *hamt_delete(struct hamt_root *root, uint128_t *hash) { if (unlikely(ston(root->slot) == NULL)) { return NULL; } struct hamt_state s; s.level = 0; s.ptr[0] = &root->slot; void *found_item = __hamt_search(root, hash, &s); if (unlikely(found_item == NULL)) { return NULL; } if (unlikely(s.level == 0)) { root->slot = (struct hamt_slot){0}; goto done; } struct hamt_slot *found_slot = s.ptr[s.level]; s.level--; struct hamt_node *node = ston(*s.ptr[s.level]); int slice = slice_get(*hash, s.level); if (set_count(node->mask) != 2) { *s.ptr[s.level] = ntos(__hamt_del_node(root, node, slice)); goto done; } else { // set_count == 2 struct hamt_slot other_slot = \ __hamt_get_other_slot(node, found_slot); if(!is_leaf(&other_slot)) { uint64_t other_slice = set_first(set_del(node->mask, slice)); __hamt_free_node(root, node); *s.ptr[s.level] = ntos(__hamt_new_node1(root, other_slice, other_slot)); goto done; } else { while (1) { __hamt_free_node(root, node); if (unlikely(s.level == 0)) { root->slot = other_slot; goto done; } s.level--; node = ston(*s.ptr[s.level]); if (set_count(node->mask) != 1) { break; } } slice = slice_get(*hash, s.level); int slot = set_slot_number(node->mask, slice); node->slots[slot] = other_slot; goto done; } } done: return found_item; }
void BufferedFile::refill_buffer() { if (at_eof()) { return; } int bytes_to_read = buffer_size(); int max = file_size() - file_pos(); if (bytes_to_read > max) { bytes_to_read = max; } int count_read; { // The file_pointer() may be shared with a FileDecoder // object. This may cause BufferedFile::file_pos() to become out // of date. A call to OsFile_seek() makes everything consistent again. AllocationDisabler raw_pointers_used_in_this_block; Buffer::Raw fb = data_buffer(); OsFile_seek(file_pointer(), file_pos(), SEEK_SET); count_read = OsFile_read(file_pointer(), fb().base_address(), 1, bytes_to_read); } set_count(count_read); set_file_pos(long(file_pos() + count_read)); set_index(0); if (count_read <= 0) { set_at_eof(true); } return; }
size_t BufferedFile::get_bytes(address buffer, jint num, bool is_buffered) { jint total_read = 0; Buffer::Raw fb = data_buffer(); if (!is_buffered) { OsFile_seek(file_pointer(), (long)(-(count() - index())), SEEK_CUR); set_count(0); // flush buffer set_index(0); return OsFile_read(file_pointer(), buffer, 1, num); } else { while (!at_eof() && num > 0) { int num_to_read = (num > (count() - index())) ? (count() - index()) :num; // num_to_read may be zero if (num_to_read) { jvm_memcpy(buffer, fb().base_address() + (index() * sizeof (jbyte)), num_to_read); buffer += num_to_read; num -= num_to_read; set_index(index() + num_to_read); total_read += num_to_read; } if (num > 0) { refill_buffer(); } } } return total_read; }
void print_cache_contents(FILE *fp, struct cache *c) { struct decoded_address addr; struct set *set; struct cache_entry *entry; char valid; char dirty; fprintf(fp, "\n"); fprintf(fp, "L%d Cache Contents", c->cache_level); for (int i = 0; i < set_count(c); ++i) { fprintf(fp, "\n| "); addr.index = i; set = &c->sets[i]; for (int j = 0; j < blocks_per_set(c); ++j) { entry = &set->entries[j]; valid = entry->flags & VALID ? 'V' : ' '; dirty = entry->flags & DIRTY ? 'D' : ' '; fprintf(fp, "%c%c ", valid, dirty); addr.tag = entry->tag; for (int k = 0; k < bytes_per_block(c); ++k) { addr.offset = k; fprintf(fp, "%p ", encode_address(&addr, c)); } fprintf(fp, "| "); } } fprintf(fp, "\n"); }
void FreeList<Chunk>::getFirstNChunksFromList(size_t n, FreeList<Chunk>* fl) { assert_proper_lock_protection(); assert(fl->count() == 0, "Precondition"); if (count() > 0) { int k = 1; fl->set_head(head()); n--; Chunk* tl = head(); while (tl->next() != NULL && n > 0) { tl = tl->next(); n--; k++; } assert(tl != NULL, "Loop Inv."); // First, fix up the list we took from. Chunk* new_head = tl->next(); set_head(new_head); set_count(count() - k); if (new_head == NULL) { set_tail(NULL); } else { new_head->link_prev(NULL); } // Now we can fix up the tail. tl->link_next(NULL); // And return the result. fl->set_tail(tl); fl->set_count(k); } }
/* initialize block */ void cache_init(struct cache *cache, struct cache *next, int level, unsigned c, unsigned b, unsigned s) { /* most values are 0 to start with */ memset(cache, 0, sizeof(*cache)); cache->c = c; cache->b = b; cache->s = s; cache->cache_level = level; cache->next = next; /* Allocate all the memory at once. The buffer is structured as set0 * for the cache, followed by set1, set2, ..., followed by all the * entries for set0, followed for all the entries for set1, etc. */ cache->set_count = set_count(cache); int entries_per_set = blocks_per_set(cache); size_t sizeof_sets_total = cache->set_count * sizeof(*cache->sets); int entry_count_total = cache->set_count * entries_per_set; size_t sizeof_single_entry = sizeof(*cache->sets[0].entries); size_t sizeof_entries_total = entry_count_total * sizeof_single_entry; cache->sets = ecalloc(sizeof_sets_total + sizeof_entries_total); /* set up the pointers for the above memory layout. Fist cache_entry * comes after all the sets */ struct cache_entry *e; e = (struct cache_entry *) (cache->sets + cache->set_count); for (int i = 0; i < cache->set_count; ++i) { cache->sets[i].entry_count = entries_per_set; cache->sets[i].entries = e; e += cache->sets[i].entry_count; } }
void BufferedFile::init() { set_at_eof(false); set_count(0); set_index(0); set_file_pos(0); }
static struct hamt_node *__hamt_add_slot(struct hamt_root *root, struct hamt_slot *slot_ptr, void *item, uint128_t *item_hash, int level) { uint64_t slice = slice_get(*item_hash, level); struct hamt_node *old_node = ston(*slot_ptr); int old_size = set_count(old_node->mask); int new_size = old_size + 1; struct hamt_node *node = __hamt_new_node(root, set_add(old_node->mask, slice), new_size); *slot_ptr = ntos(node); int slot = set_slot_number(node->mask, slice); memcpy(&node->slots[0], &old_node->slots[0], sizeof(struct hamt_slot)*slot); memcpy(&node->slots[slot+1], &old_node->slots[slot], sizeof(struct hamt_slot)*(old_size-slot)); node->slots[slot] = item_to_slot(item); __hamt_free_node(root, old_node); return node; }
bool build(inner_node *parent, const size_t depth) { const size_t this_id(num_nodes); if(num_nodes == size) return false; ++num_nodes; if(depth == 0) node[this_id] = new inner_node(this, parent, 0, this_id); else { auto my_node(new inner_node(this, parent, radix, this_id)); node[this_id] = my_node; size_t num_children(0); for(size_t i(0); i < radix; ++i) { if(build(my_node, depth - 1)) num_children++; } if(num_children != radix) my_node->set_count(num_children); } return true; }
static void __ohamt_delete(struct ohamt_root *root, uint128_t hash, struct ohamt_state *s) { if (unlikely(s->level == 0)) { root->slot = (struct ohamt_slot){0}; goto done; } struct ohamt_slot *found_slot = s->ptr[s->level]; s->level--; struct ohamt_node *node = ston(*s->ptr[s->level]); int slice = slice_get(hash, s->level); if (set_count(node->mask) != 2) { *s->ptr[s->level] = ntos(__ohamt_del_node(root, node, slice)); goto done; } else { // set_count == 2 struct ohamt_slot other_slot = \ __ohamt_get_other_slot(node, found_slot); if(!is_leaf(&other_slot)) { uint64_t other_slice = set_first(set_del(node->mask, slice)); __ohamt_free_node(root, node); *s->ptr[s->level] = ntos(__ohamt_new_node1(root, other_slice, other_slot)); goto done; } else { while (1) { __ohamt_free_node(root, node); if (unlikely(s->level == 0)) { root->slot = other_slot; goto done; } s->level--; node = ston(*s->ptr[s->level]); if (set_count(node->mask) != 1) { break; } } slice = slice_get(hash, s->level); int slot = set_slot_number(node->mask, slice); node->slots[slot] = other_slot; goto done; } } done: return; }
void FreeList<Chunk>::reset() { // Don't set the _size to 0 because this method is // used with a existing list that has a size but which has // been emptied. // Don't clear the _protecting_lock of an existing list. set_count(0); set_head(NULL); set_tail(NULL); }
void AgingStub::init(nmethod* nm) { CountCodePattern* patt = CountStub::pattern[Comparing]; set_recompile_addr(first_inst_addr(MakeOld_stub)); set_count_addr(patt, (int32)&sendCounts[id()]); int32* p = (int32*)(int32(insts()) + patt->limit_offset); assert(*p == patt->initial_limit, "???"); fint limit = nm->agingLimit(); *p = limit; set_count(1); }
void BufferedFile::init(Buffer *data, int buffer_size, int file_size, int buffer_count) { // initialize the buffer init(); set_file_pos(buffer_count); set_count(buffer_count); set_data_buffer(data); set_buffer_size(buffer_size); set_file_size(file_size); }
int BufferedFile::seek(jint offset, int origin) { int ndx = index(); int cnt = count(); switch (origin) { case SEEK_CUR: // we may have data in the buffer so seek relative to current index into // buffer if (cnt > 0) { // we have some data, so seek from current index if (offset + ndx >= 0 && offset + ndx < cnt) { // we are seeking somewhere in the buffer, just set the ndx and return set_index((int) (ndx + offset)); return 0; } else { // we are seeking out of buffer, do a SEEK_CUR to the right position offset -= (cnt - ndx); set_file_pos((long)(file_pos() + offset)); } } break; case SEEK_SET: if (cnt > 0) { if (offset >= (file_pos() - cnt) && offset < file_pos()) { // we're seeking in the buffer so just adjust pointer set_index((int) (cnt - (file_pos() - offset))); return 0; } } set_file_pos(offset); break; case SEEK_END: if (cnt > 0) { if (cnt == file_size()) { // The whole thing is in the buffer so just adjust the index if ((cnt + offset ) >= 0) { set_index((int) (cnt + offset)); return 0; } } // There's more data beyond what we have in the buffer so just seek there } set_file_pos(long(file_size() + offset)); break; } set_count(0); // flush buffer set_index(0); if (file_pos() < file_size()) { set_at_eof(false); } return (int) OsFile_seek(file_pointer(), offset, origin); }
static inline void __ohamt_erase(struct ohamt_root *root, struct ohamt_slot *slot) { if (!is_leaf(slot)) { struct ohamt_node *node = ston(*slot); int i; for (i=0; i < set_count(node->mask); i++) { __ohamt_erase(root, &node->slots[i]); } __ohamt_free_node(root, node); slot->off = 0; } }
void bump_count(const char *const user) { const int n = get_count(user); if (n >= max) { system("/bin/logd message access attempt overrun!"); syslog(LOG_EMERG, "access attempt overrun!"); #if CONFIG_USER_FLATFSD_FLATFSD if (system("exec flatfsd -i") != -1) sleep(60); /* we should reboot while ehile, but just in case */ #endif system("/bin/reboot"); } else set_count(user, n+1); }
std::shared_ptr<odata_value> odata_test_service::get_people() { auto people_type = m_model->find_entity_type(U("Person")); auto people_collection_type = std::make_shared<edm_collection_type>(people_type); auto people_collection = std::make_shared<odata_collection_value>(people_collection_type); people_collection->add_collection_value(get_single_people(U("russellwhyte"))); people_collection->set_is_top_level(true); people_collection->set_next_link(U("http://localhost:4789/$metadata#People?$skiptoken=1")); people_collection->set_delta_link(U("http://localhost:4789/$metadata#People?$deltatoken=0826")); people_collection->set_count(1); return people_collection; }
int BufferedFile::close() { if (file_pointer() != NULL) { int result = OsFile_close(file_pointer()); set_file_pointer(0); set_file_size(0); set_file_pos(0); set_index(0); set_count(0); return result; } else { return -1; } }
void AgingStub::init(nmethod* nm) { CountCodePattern* patt = CountStub::pattern[Comparing]; int32* p = (int32*)insts(); set_recompile_addr(first_inst_addr(MakeOld_stub)); set_count_addr(patt, (int32)&sendCounts[id()]); fint limit = nm->agingLimit(); if (limit > 1023) { setSetHiImm(p + patt->limit_sethi_offset, limit); } else { // setHi would set to 0, so use an add instead p[patt->limit_sethi_offset] = add_inst; setArithImm(p + patt->limit_sethi_offset, limit); } set_count(1); }
ShaderParam :: ShaderParam(const char *name, Type type, int count) : mActive(false), mLocation(INVALID_LOCATION), mType(type) { mName.assign(name); mIdataSize = DEFAULT_SIZE; mIdata = new int[DEFAULT_SIZE]; mFdataSize = DEFAULT_SIZE; mFdata = new float[DEFAULT_SIZE]; // will alloc enough memory set_count(count); }
static struct hamt_node *__hamt_del_node(struct hamt_root *root, struct hamt_node *old_node, int slice) { int slot = set_slot_number(old_node->mask, slice); int old_size = set_count(old_node->mask); int new_size = old_size - 1; struct hamt_node *node = __hamt_new_node(root, set_del(old_node->mask, slice), new_size); memcpy(&node->slots[0], &old_node->slots[0], sizeof(struct hamt_slot)*slot); memcpy(&node->slots[slot], &old_node->slots[slot+1], sizeof(struct hamt_slot)*(old_size-slot-1)); __hamt_free_node(root, old_node); return node; }
void t_count_spectra::hit (t_component_id component, t_transaction_id transaction, t_count count, bool ignore_unknown_components) { assert(component > 0); assert(transaction > 0); if (component > get_component_count() || transaction > get_transaction_count()) { if (!ignore_unknown_components) set_count(std::max(component, get_component_count()), std::max(transaction, get_transaction_count())); else return; } activity[(transaction - 1) * get_component_count() + (component - 1)] += count; }
jboolean VMEventModifier::match(DebuggerEvent *d_event, bool *should_delete) { *should_delete = false; if (d_event == NULL) return false; switch (mod_kind()) { case JDWP_EventRequest_Set_Out_modifiers_Modifier_Conditional: /* reserved for future use */ break; case JDWP_EventRequest_Set_Out_modifiers_Modifier_ThreadOnly: return thread_match(d_event); case JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassOnly: return ((ClassMatchModifier *)this)->class_only(d_event); case JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassMatch: return ((ClassMatchModifier *)this)->class_match(d_event); case JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassExclude: return !((ClassMatchModifier *)this)->class_match(d_event); case JDWP_EventRequest_Set_Out_modifiers_Modifier_LocationOnly: return ((LocationModifier *)this)->match(d_event); case JDWP_EventRequest_Set_Out_modifiers_Modifier_ExceptionOnly: { ExceptionModifier *exm = (ExceptionModifier *)(this); bool ret = true; if (exm->clazz_id() != 0) { InstanceClass::Raw clazz1 = JavaDebugger::get_object_by_id(d_event->clazz_id()); InstanceClass::Raw clazz2 = JavaDebugger::get_object_by_id(exm->clazz_id()); if (!clazz1().is_subclass_of(&clazz2)) { ret = false; } } ret = ret && ((exm->sig_caught() && d_event->sig_caught()) || (exm->sig_uncaught() && d_event->sig_uncaught())); if (!ret) return false; break; } case JDWP_EventRequest_Set_Out_modifiers_Modifier_FieldOnly: break; case JDWP_EventRequest_Set_Out_modifiers_Modifier_Step: return ((StepModifier *)this)->match(d_event); case JDWP_EventRequest_Set_Out_modifiers_Modifier_Count: { int count; // just the fact that we have a count modifier means it is active if ((count = event_count()) == 1) { // we will send this event now set_count(0); // but first turn it off return true; } else if (count > 1) { // decrement and return false set_count(--count); return false; } else { // must be <=0, so no event *should_delete = true; return false; } } } return true; }
static void __hamt_free_node(struct hamt_root *root, struct hamt_node *node) { int len = set_count(node->mask); int size = sizeof(struct hamt_node) + len * sizeof(struct hamt_slot); root->mem_free(node, size); }
int main(int argc, char *argv[]) { FILE *fp; char buffer[512]; size_t i, j, r; unsigned int d = 0; uint64_t s, e, a, ri, si, ai, sr, rg, sg, ag, sd, ng; struct ck_hs_stat st; char **t; r = 20; s = 8; srand(time(NULL)); if (argc < 2) { ck_error("Usage: ck_hs <dictionary> [<repetitions> <initial size>]\n"); } if (argc >= 3) r = atoi(argv[2]); if (argc >= 4) s = (uint64_t)atoi(argv[3]); keys = malloc(sizeof(char *) * keys_capacity); assert(keys != NULL); fp = fopen(argv[1], "r"); assert(fp != NULL); while (fgets(buffer, sizeof(buffer), fp) != NULL) { buffer[strlen(buffer) - 1] = '\0'; keys[keys_length++] = strdup(buffer); assert(keys[keys_length - 1] != NULL); if (keys_length == keys_capacity) { t = realloc(keys, sizeof(char *) * (keys_capacity *= 2)); assert(t != NULL); keys = t; } } t = realloc(keys, sizeof(char *) * keys_length); assert(t != NULL); keys = t; set_init(); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; ck_hs_stat(&hs, &st); fprintf(stderr, "# %zu entries stored, %u duplicates, %u probe.\n", set_count(), d, st.probe_maximum); fprintf(stderr, "# reverse_insertion serial_insertion random_insertion serial_replace reverse_get serial_get random_get serial_remove negative_get\n\n"); a = 0; for (j = 0; j < r; j++) { if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = keys_length; i > 0; i--) d += set_insert(keys[i - 1]) == false; e = rdtsc(); a += e - s; } ri = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; e = rdtsc(); a += e - s; } si = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { keys_shuffle(keys); if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; e = rdtsc(); a += e - s; } ai = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_replace(keys[i]); e = rdtsc(); a += e - s; } sr = a / (r * keys_length); set_reset(); for (i = 0; i < keys_length; i++) set_insert(keys[i]); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = keys_length; i > 0; i--) { if (set_get(keys[i - 1]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } rg = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) { if (set_get(keys[i]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } sg = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { keys_shuffle(keys); s = rdtsc(); for (i = 0; i < keys_length; i++) { if (set_get(keys[i]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } ag = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_remove(keys[i]); e = rdtsc(); a += e - s; for (i = 0; i < keys_length; i++) set_insert(keys[i]); } sd = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) { set_get("\x50\x03\x04\x05\x06\x10"); } e = rdtsc(); a += e - s; } ng = a / (r * keys_length); printf("%zu " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 "\n", keys_length, ri, si, ai, sr, rg, sg, ag, sd, ng); return 0; }
static cmd_args_t * args_init(int argc, char **argv) { cmd_args_t *args; uint32_t fl_th = 0; uint32_t fl_rc = 0; uint32_t fl_of = 0; uint32_t fl_rs = 0; uint32_t fl_cs = 0; uint32_t fl_bs = 0; int c, rc, i; if (argc == 1) { usage(); return ((cmd_args_t *)NULL); } /* Configure and populate the args structures */ args = malloc(sizeof (*args)); if (args == NULL) return (NULL); memset(args, 0, sizeof (*args)); /* provide a default block size of 128K */ args->B.next_val = 0; args->B.val[0] = MIN_BLKSIZE; args->B.val_count = 1; while ((c = getopt_long(argc, argv, short_opt, long_opt, NULL)) != -1) { rc = 0; switch (c) { case 't': /* --thread count */ rc = set_count(REGEX_NUMBERS, REGEX_NUMBERS_COMMA, &args->T, optarg, &fl_th, "threadcount"); break; case 'l': /* --threadcount_low */ rc = set_lhi(REGEX_NUMBERS, &args->T, optarg, FLAG_LOW, &fl_th, "threadcount_low"); break; case 'h': /* --threadcount_high */ rc = set_lhi(REGEX_NUMBERS, &args->T, optarg, FLAG_HIGH, &fl_th, "threadcount_high"); break; case 'e': /* --threadcount_inc */ rc = set_lhi(REGEX_NUMBERS, &args->T, optarg, FLAG_INCR, &fl_th, "threadcount_incr"); break; case 'n': /* --regioncount */ rc = set_count(REGEX_NUMBERS, REGEX_NUMBERS_COMMA, &args->N, optarg, &fl_rc, "regioncount"); break; case 'i': /* --regioncount_low */ rc = set_lhi(REGEX_NUMBERS, &args->N, optarg, FLAG_LOW, &fl_rc, "regioncount_low"); break; case 'j': /* --regioncount_high */ rc = set_lhi(REGEX_NUMBERS, &args->N, optarg, FLAG_HIGH, &fl_rc, "regioncount_high"); break; case 'k': /* --regioncount_inc */ rc = set_lhi(REGEX_NUMBERS, &args->N, optarg, FLAG_INCR, &fl_rc, "regioncount_incr"); break; case 'o': /* --offset */ rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA, &args->O, optarg, &fl_of, "offset"); break; case 'm': /* --offset_low */ rc = set_lhi(REGEX_SIZE, &args->O, optarg, FLAG_LOW, &fl_of, "offset_low"); break; case 'q': /* --offset_high */ rc = set_lhi(REGEX_SIZE, &args->O, optarg, FLAG_HIGH, &fl_of, "offset_high"); break; case 'r': /* --offset_inc */ rc = set_lhi(REGEX_NUMBERS, &args->O, optarg, FLAG_INCR, &fl_of, "offset_incr"); break; case 'c': /* --chunksize */ rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA, &args->C, optarg, &fl_cs, "chunksize"); break; case 'a': /* --chunksize_low */ rc = set_lhi(REGEX_SIZE, &args->C, optarg, FLAG_LOW, &fl_cs, "chunksize_low"); break; case 'b': /* --chunksize_high */ rc = set_lhi(REGEX_SIZE, &args->C, optarg, FLAG_HIGH, &fl_cs, "chunksize_high"); break; case 'g': /* --chunksize_inc */ rc = set_lhi(REGEX_NUMBERS, &args->C, optarg, FLAG_INCR, &fl_cs, "chunksize_incr"); break; case 's': /* --regionsize */ rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA, &args->S, optarg, &fl_rs, "regionsize"); break; case 'A': /* --regionsize_low */ rc = set_lhi(REGEX_SIZE, &args->S, optarg, FLAG_LOW, &fl_rs, "regionsize_low"); break; case 'B': /* --regionsize_high */ rc = set_lhi(REGEX_SIZE, &args->S, optarg, FLAG_HIGH, &fl_rs, "regionsize_high"); break; case 'C': /* --regionsize_inc */ rc = set_lhi(REGEX_NUMBERS, &args->S, optarg, FLAG_INCR, &fl_rs, "regionsize_incr"); break; case 'S': /* --blocksize */ rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA, &args->B, optarg, &fl_bs, "blocksize"); break; case 'L': /* --load */ rc = set_load_params(args, optarg); break; case 'p': /* --pool */ args->pool = optarg; break; case 'M': args->name = optarg; break; case 'x': /* --cleanup */ args->flags |= DMU_REMOVE; break; case 'P': /* --prerun */ strncpy(args->pre, optarg, ZPIOS_PATH_SIZE - 1); break; case 'R': /* --postrun */ strncpy(args->post, optarg, ZPIOS_PATH_SIZE - 1); break; case 'G': /* --log */ strncpy(args->log, optarg, ZPIOS_PATH_SIZE - 1); break; case 'I': /* --regionnoise */ rc = set_noise(&args->regionnoise, optarg, "regionnoise"); break; case 'N': /* --chunknoise */ rc = set_noise(&args->chunknoise, optarg, "chunknoise"); break; case 'T': /* --threaddelay */ rc = set_noise(&args->thread_delay, optarg, "threaddelay"); break; case 'V': /* --verify */ args->flags |= DMU_VERIFY; break; case 'z': /* --zerocopy */ args->flags |= (DMU_WRITE_ZC | DMU_READ_ZC); break; case 'O': /* --nowait */ args->flags |= DMU_WRITE_NOWAIT; break; case 'f': /* --noprefetch */ args->flags |= DMU_READ_NOPF; break; case 'H': /* --human-readable */ args->human_readable = 1; break; case 'v': /* --verbose */ args->verbose++; break; case '?': rc = 1; break; default: fprintf(stderr, "Unknown option '%s'\n", argv[optind - 1]); rc = EINVAL; break; } if (rc) { usage(); args_fini(args); return (NULL); } } check_mutual_exclusive_command_lines(fl_th, "threadcount"); check_mutual_exclusive_command_lines(fl_rc, "regioncount"); check_mutual_exclusive_command_lines(fl_of, "offset"); check_mutual_exclusive_command_lines(fl_rs, "regionsize"); check_mutual_exclusive_command_lines(fl_cs, "chunksize"); if (args->pool == NULL) { fprintf(stderr, "Error: Pool not specificed\n"); usage(); args_fini(args); return (NULL); } if ((args->flags & (DMU_WRITE_ZC | DMU_READ_ZC)) && (args->flags & DMU_VERIFY)) { fprintf(stderr, "Error, --zerocopy incompatible --verify, " "used for performance analysis only\n"); usage(); args_fini(args); return (NULL); } /* validate block size(s) */ for (i = 0; i < args->B.val_count; i++) { int bs = args->B.val[i]; if (bs < MIN_BLKSIZE || bs > MAX_BLKSIZE || !POW_OF_TWO(bs)) { fprintf(stderr, "Error: invalid block size %d\n", bs); args_fini(args); return (NULL); } } return (args); }
int ex_get_side_set_node_list(int exoid, ex_entity_id side_set_id, void_int *side_set_node_cnt_list, void_int *side_set_node_list) { size_t m; size_t i, j; int64_t elem, side; int64_t num_side_sets, num_elem_blks, num_df, ndim; int64_t tot_num_elem = 0, tot_num_ss_elem = 0, elem_num = 0; size_t connect_offset, side_num, node_pos; void_int *elem_blk_ids = NULL; void_int *connect = NULL; void_int *ss_elem_ndx = NULL; void_int *ss_elem_node_ndx = NULL; void_int *ss_parm_ndx = NULL; void_int *side_set_elem_list = NULL; void_int *side_set_side_list = NULL; size_t elem_ctr, node_ctr, elem_num_pos; size_t num_nodes_per_elem; int int_size, ids_size; int err_stat = EX_NOERR; int status; struct elem_blk_parm *elem_blk_parms = NULL; /* side to node translation tables - These tables are used to look up the side number based on the first and second node in the side/face list. The side node order is found in the original Exodus document, SAND87-2997. The element node order is found in the ExodusII document, SAND92-2137. These tables were generated by following the right-hand rule for determining the outward normal. */ /* triangle */ static int tri_table[3][3] = { /* 1 2 3 side */ {1,2,4}, {2,3,5}, {3,1,6} /* nodes */ }; /* triangle 3d */ static int tri3_table[5][7] = { /* 1 2 side */ {1,2,3,4,5,6,7}, {3,2,1,6,5,4,7}, /* nodes */ /* 3 4 5 side */ {1,2,4,0,0,0,0}, {2,3,5,0,0,0,0}, {3,1,6,0,0,0,0} /* nodes */ }; /* quad */ static int quad_table[4][3] = { /* 1 2 3 4 side */ {1,2,5}, {2,3,6}, {3,4,7}, {4,1,8} /* nodes */ }; /* shell */ static int shell_table[6][8] = { /* 1 2 side */ {1,2,3,4,5,6,7,8}, {1,4,3,2,8,7,6,5} , /* nodes */ /* 3 4 side */ {1,2,5,0,0,0,0,0}, {2,3,6,0,0,0,0,0} , /* nodes */ /* 5 6 side */ {3,4,7,0,0,0,0,0}, {4,1,8,0,0,0,0,0} /* nodes */ }; /* tetra */ static int tetra_table[4][6] = { /* 1 2 3 4 side */ {1,2,4,5,9,8}, {2,3,4,6,10,9}, {1,4,3,8,10,7}, {1,3,2,7,6,5} /* nodes */ }; /* wedge */ static int wedge_table[5][8] = { /* 1 2 3 side */ {1,2,5,4,7,11,13,10}, {2,3,6,5,8,12,14,11}, {1,4,6,3,10,15,12,9}, /* 4 5 side */ {1,3,2,0,9,8,7,0}, {4,5,6,0,13,14,15,0} /* nodes */ }; /* hex */ static int hex_table[6][9] = { /* 1 2 side */ {1,2,6,5,9,14,17,13,26}, {2,3,7,6,10,15,18,14,25}, /* nodes */ /* 3 4 side */ {3,4,8,7,11,16,19,15,27}, {1,5,8,4,13,20,16,12,24}, /* nodes */ /* 5 6 side */ {1,4,3,2,12,11,10,9,22}, {5,6,7,8,17,18,19,20,23} /* nodes */ }; /* pyramid */ static int pyramid_table[5][8] = { /* 1 2 3 side */ {1,2,5,0,6,11,10,0}, {2,3,5,0,7,12,11,0}, {3,4,5,0,8,13,12,0}, /* nodes */ /* 4 5 side */ {1,5,4,0,10,13,9,0}, {1,4,3,2,9,8,7,6} /* nodes */ }; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* first check if any side sets are specified */ /* inquire how many side sets have been stored */ num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS); if (num_side_sets < 0) { sprintf(errmsg, "Error: failed to get number of side sets in file id %d",exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } if (num_side_sets == 0) { sprintf(errmsg, "Warning: no side sets defined in file id %d",exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_WARN); return(EX_WARN); } /* Lookup index of side set id in VAR_SS_IDS array */ ex_id_lkup(exoid,EX_SIDE_SET,side_set_id); if (exerrval != 0) { if (exerrval == EX_NULLENTITY) { sprintf(errmsg, "Warning: side set %"PRId64" is NULL in file id %d", side_set_id,exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_NULLENTITY); return (EX_WARN); } else { sprintf(errmsg, "Error: failed to locate side set %"PRId64" in VAR_SS_IDS array in file id %d", side_set_id,exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } } num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK); if (num_elem_blks < 0) { sprintf(errmsg, "Error: failed to get number of element blocks in file id %d",exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } tot_num_elem = ex_inquire_int(exoid, EX_INQ_ELEM); if (tot_num_elem < 0) { sprintf(errmsg, "Error: failed to get total number of elements in file id %d",exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } /* get the dimensionality of the coordinates; this is necessary to distinguish between 2d TRIs and 3d TRIs */ ndim = ex_inquire_int(exoid, EX_INQ_DIM); if (ndim < 0) { sprintf(errmsg, "Error: failed to get dimensionality in file id %d",exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return(EX_FATAL); } int_size = sizeof(int); if (ex_int64_status(exoid) & EX_BULK_INT64_API) { int_size = sizeof(int64_t); } ids_size = sizeof(int); if (ex_int64_status(exoid) & EX_IDS_INT64_API) { ids_size = sizeof(int64_t); } /* First determine the # of elements in the side set*/ if (int_size == sizeof(int64_t)) { status = ex_get_set_param(exoid,EX_SIDE_SET, side_set_id,&tot_num_ss_elem,&num_df); } else { int tot, df; status = ex_get_set_param(exoid,EX_SIDE_SET, side_set_id,&tot,&df); tot_num_ss_elem = tot; num_df = df; } if (status != EX_NOERR) { sprintf(errmsg, "Error: failed to get number of elements in side set %"PRId64" in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } /* Allocate space for the side set element list */ if (!(side_set_elem_list=malloc(tot_num_ss_elem*int_size))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set element list for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the side set side list */ if (!(side_set_side_list=malloc(tot_num_ss_elem*int_size))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set side list for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } if (ex_get_set(exoid, EX_SIDE_SET, side_set_id, side_set_elem_list, side_set_side_list) == -1) { safe_free(side_set_elem_list); safe_free(side_set_side_list); sprintf(errmsg, "Error: failed to get side set %"PRId64" in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the ss element index array */ if (!(ss_elem_ndx= malloc(tot_num_ss_elem*int_size))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem sort array for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } /* Sort side set element list into index array - non-destructive */ if (int_size == sizeof(int64_t)) { /* Sort side set element list into index array - non-destructive */ int64_t *elems = (int64_t*)ss_elem_ndx; for (i=0; i<tot_num_ss_elem; i++) { elems[i] = i; /* init index array to current position */ } ex_iqsort64(side_set_elem_list, ss_elem_ndx,tot_num_ss_elem); } else { /* Sort side set element list into index array - non-destructive */ int *elems = (int*)ss_elem_ndx; for (i=0; i<tot_num_ss_elem; i++) { elems[i] = i; /* init index array to current position */ } ex_iqsort(side_set_elem_list, ss_elem_ndx,tot_num_ss_elem); } /* Allocate space for the element block ids */ if (!(elem_blk_ids= malloc(num_elem_blks*ids_size))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for element block ids for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } if (ex_get_elem_blk_ids(exoid, elem_blk_ids) == -1) { sprintf(errmsg, "Error: failed to get element block ids in file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_MSG); err_stat = EX_FATAL; goto cleanup; } /* Allocate space for the element block params */ if (!(elem_blk_parms= malloc(num_elem_blks*sizeof(struct elem_blk_parm)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for element block params for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } elem_ctr = 0; for (i=0; i<num_elem_blks; i++) { ex_block block; if (ids_size == sizeof(int64_t)) { block.id = ((int64_t*)elem_blk_ids)[i]; } else { block.id = ((int*)elem_blk_ids)[i]; } block.type = EX_ELEM_BLOCK; /* read in an element block parameter */ if ((ex_get_block_param (exoid, &block)) == -1) { sprintf(errmsg, "Error: failed to get element block %"PRId64" parameters in file id %d", block.id, exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_MSG); err_stat = EX_FATAL; goto cleanup; } elem_blk_parms[i].num_elem_in_blk = block.num_entry; elem_blk_parms[i].num_nodes_per_elem = block.num_nodes_per_entry; elem_blk_parms[i].num_attr = block.num_attribute; elem_blk_parms[i].elem_blk_id = block.id; for (m=0; m < strlen(block.topology); m++) { elem_blk_parms[i].elem_type[m] = toupper(block.topology[m]); } elem_blk_parms[i].elem_type[m] = '\0'; if (strncmp(elem_blk_parms[i].elem_type,"CIRCLE",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_CIRCLE; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side[0] = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"SPHERE",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_SPHERE; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side[0] = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"QUAD",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_QUAD; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side[0] = 2; else if (elem_blk_parms[i].num_nodes_per_elem == 5) elem_blk_parms[i].num_nodes_per_side[0] = 2; else elem_blk_parms[i].num_nodes_per_side[0] = 3; } else if (strncmp(elem_blk_parms[i].elem_type,"TRIANGLE",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_TRIANGLE; /* set default side set node stride */ if (ndim == 2) /* 2d TRIs */ { if (elem_blk_parms[i].num_nodes_per_elem == 3) elem_blk_parms[i].num_nodes_per_side[0] = 2; else elem_blk_parms[i].num_nodes_per_side[0] = 3; } else if (ndim == 3) /* 3d TRIs */ { if (elem_blk_parms[i].num_nodes_per_elem == 3) elem_blk_parms[i].num_nodes_per_side[0] = 3; else elem_blk_parms[i].num_nodes_per_side[0] = 6; } } else if (strncmp(elem_blk_parms[i].elem_type,"SHELL",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_SHELL; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) /* KLUDGE for 2D Shells*/ elem_blk_parms[i].num_nodes_per_side[0] = 2; else if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side[0] = 4; else elem_blk_parms[i].num_nodes_per_side[0] = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"HEX",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_HEX; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 8) /* 8-node bricks */ elem_blk_parms[i].num_nodes_per_side[0] = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 9) /* 9-node bricks */ elem_blk_parms[i].num_nodes_per_side[0] = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 12) /* HEXSHELLS */ elem_blk_parms[i].num_nodes_per_side[0] = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 27) /* 27-node bricks */ elem_blk_parms[i].num_nodes_per_side[0] = 9; else elem_blk_parms[i].num_nodes_per_side[0] = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"TETRA",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_TETRA; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side[0] = 3; else if (elem_blk_parms[i].num_nodes_per_elem == 8) elem_blk_parms[i].num_nodes_per_side[0] = 4; else elem_blk_parms[i].num_nodes_per_side[0] = 6; } else if (strncmp(elem_blk_parms[i].elem_type,"WEDGE",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_WEDGE; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 6) elem_blk_parms[i].num_nodes_per_side[0] = 4; else elem_blk_parms[i].num_nodes_per_side[0] = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"PYRAMID",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_PYRAMID; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 5) elem_blk_parms[i].num_nodes_per_side[0] = 4; else elem_blk_parms[i].num_nodes_per_side[0] = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"BEAM",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_BEAM; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) elem_blk_parms[i].num_nodes_per_side[0] = 2; else elem_blk_parms[i].num_nodes_per_side[0] = 3; } else if ( (strncmp(elem_blk_parms[i].elem_type,"TRUSS",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"BAR",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"EDGE",3) == 0) ) { elem_blk_parms[i].elem_type_val = EX_EL_TRUSS; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) elem_blk_parms[i].num_nodes_per_side[0] = 2; else elem_blk_parms[i].num_nodes_per_side[0] = 3; } else if (strncmp(elem_blk_parms[i].elem_type,"NULL",3) == 0) { elem_blk_parms[i].elem_type_val = EX_EL_NULL_ELEMENT; elem_blk_parms[i].num_nodes_per_side[0] = 0; elem_blk_parms[i].num_elem_in_blk = 0; } else { /* unsupported element type; no problem if no sides specified for this element block */ elem_blk_parms[i].elem_type_val = EX_EL_UNK; elem_blk_parms[i].num_nodes_per_side[0] = 0; } elem_blk_parms[i].elem_blk_id = block.id; /* save id */ elem_ctr += elem_blk_parms[i].num_elem_in_blk; elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */ } /* Allocate space for the ss element to element block parameter index array */ if (!(ss_parm_ndx=malloc(tot_num_ss_elem*int_size))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem parms index for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } /* Allocate space for the ss element to node list index array */ if (!(ss_elem_node_ndx=malloc(tot_num_ss_elem*int_size))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem to node index for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } /* Build side set element to node list index and side set element parameter index. */ node_ctr = 0; for (i=0; i<tot_num_ss_elem; i++) { if (ex_int64_status(exoid) & EX_BULK_INT64_API) { elem = ((int64_t*)side_set_elem_list)[i]; side = ((int64_t*)side_set_side_list)[i]; } else { elem = ((int*)side_set_elem_list)[i]; side = ((int*)side_set_side_list)[i]; } for (j=0; j<num_elem_blks; j++) { if (elem_blk_parms[j].elem_type_val != EX_EL_NULL_ELEMENT) if (elem <= elem_blk_parms[j].elem_ctr) break; } if (j >= num_elem_blks) { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid element number %"PRId64" found in side set %"PRId64" in file %d", elem, side_set_id, exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_MSG); err_stat = EX_FATAL; goto cleanup; } if (int_size == sizeof(int64_t)) { ((int64_t*)ss_parm_ndx)[i] = j; /* assign parameter block index */ ((int64_t*)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */ } else { ((int*)ss_parm_ndx)[i] = j; /* assign parameter block index */ ((int*)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */ } /* Update node_ctr (which points to next node in chain */ /* WEDGEs with 3 node sides (side 4 or 5) are special cases */ if (elem_blk_parms[j].elem_type_val == EX_EL_WEDGE && (side == 4 || side == 5)) { if (elem_blk_parms[j].num_nodes_per_elem == 6) node_ctr += 3; /* 3 node side */ else node_ctr += 6; /* 6 node side */ } /* PYRAMIDSs with 3 node sides (sides 1,2,3,4) are also special */ else if (elem_blk_parms[j].elem_type_val == EX_EL_PYRAMID && (side < 5)) { if (elem_blk_parms[j].num_nodes_per_elem == 5) node_ctr += 3; /* 3 node side */ else node_ctr += 6; /* 6 node side */ } /* side numbers 3,4,5,6 for SHELLs are also special */ else if (elem_blk_parms[j].elem_type_val == EX_EL_SHELL && (side > 2 )) { if (elem_blk_parms[j].num_nodes_per_elem == 4) node_ctr += 2; /* 2 node side */ else node_ctr += 3; /* 3 node side */ } /* side numbers 3,4,5 for 3d TRIs are also special */ else if (elem_blk_parms[j].elem_type_val == EX_EL_TRIANGLE && ndim == 3 && side > 2 ) { if (elem_blk_parms[j].num_nodes_per_elem == 3) /* 3-node TRI */ node_ctr += 2; /* 2 node side */ else /* 6-node TRI */ node_ctr += 3; /* 3 node side */ } else /* all other element types */ node_ctr += elem_blk_parms[j].num_nodes_per_side[0]; } /* All setup, ready to go ... */ elem_ctr=0; for (j=0; j < tot_num_ss_elem; j++) { int64_t elem_ndx; size_t parm_ndx; if (ex_int64_status(exoid) & EX_BULK_INT64_API) { elem_ndx = ((int64_t*)ss_elem_ndx)[j]; elem = ((int64_t*)side_set_elem_list)[elem_ndx]; side = ((int64_t*)side_set_side_list)[elem_ndx]; parm_ndx = ((int64_t*)ss_parm_ndx)[elem_ndx]; } else { elem_ndx = ((int*)ss_elem_ndx)[j]; elem = ((int*)side_set_elem_list)[elem_ndx]; side = ((int*)side_set_side_list)[elem_ndx]; parm_ndx = ((int*)ss_parm_ndx)[elem_ndx]; } if (elem > elem_ctr) { /* release connectivity array space and get next one */ if (elem_ctr > 0) { safe_free(connect); } /* Allocate space for the connectivity array for new element block */ if (!(connect=malloc(elem_blk_parms[parm_ndx].num_elem_in_blk* elem_blk_parms[parm_ndx].num_nodes_per_elem* int_size))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for connectivity array for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } /* get connectivity array */ if (ex_get_elem_conn(exoid, elem_blk_parms[parm_ndx].elem_blk_id, connect) == -1) { sprintf(errmsg, "Error: failed to allocate space for connectivity array for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } elem_ctr = elem_blk_parms[parm_ndx].elem_ctr; } /* For each side in side set, use the appropriate lookup table to determine the nodes from the connect array. */ elem_num = elem-1;/* element number 0-based*/ /* calculate the relative element number position in it's block*/ elem_num_pos = elem_num - (elem_blk_parms[parm_ndx].elem_ctr - elem_blk_parms[parm_ndx].num_elem_in_blk); /* calculate the beginning of the node list for this element by using the ss_elem_node_ndx index into the side_sets_node_index and adding the element number position * number of nodes per elem */ num_nodes_per_elem = elem_blk_parms[parm_ndx].num_nodes_per_elem; connect_offset = num_nodes_per_elem*elem_num_pos; side_num = side-1; if (int_size == sizeof(int64_t)) { node_pos = ((int64_t*)ss_elem_node_ndx)[elem_ndx]; } else { node_pos = ((int*)ss_elem_node_ndx)[elem_ndx]; } switch (elem_blk_parms[parm_ndx].elem_type_val) { case EX_EL_CIRCLE: case EX_EL_SPHERE: { /* Note: no side-node lookup table is used for this simple case */ get_nodes(exoid, side_set_node_list, node_pos, connect, connect_offset); set_count(exoid, side_set_node_cnt_list, elem_ndx, 1); /* 1 node object */ break; } case EX_EL_TRUSS: case EX_EL_BEAM: { /* Note: no side-node lookup table is used for this simple case */ for (i=0; i < num_nodes_per_elem; i++) { get_nodes(exoid, side_set_node_list, node_pos+i, connect, connect_offset+i); } set_count(exoid, side_set_node_cnt_list, elem_ndx, num_nodes_per_elem); break; } case EX_EL_TRIANGLE: { if (side_num+1 < 1 || side_num+1 > 5) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid triangle edge number %"ST_ZU" in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } if (ndim == 2) /* 2d TRIs */ { get_nodes(exoid, side_set_node_list, node_pos, connect, connect_offset+tri_table[side_num][0]-1); get_nodes(exoid, side_set_node_list, node_pos+1, connect, connect_offset+tri_table[side_num][1]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */ if (num_nodes_per_elem > 3) /* 6-node TRI */ { get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+tri_table[side_num][2]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ } } else if (ndim == 3) /* 3d TRIs */ { get_nodes(exoid, side_set_node_list, node_pos, connect, connect_offset+tri3_table[side_num][0]-1); get_nodes(exoid, side_set_node_list, node_pos+1, connect, connect_offset+tri3_table[side_num][1]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */ if (side_num+1 <= 2) /* 3- or 6-node face */ { if (num_nodes_per_elem == 3) /* 3-node face */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+tri3_table[side_num][2]-1); } else /* 6-node face */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node object */ get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+tri3_table[side_num][2]-1); get_nodes(exoid, side_set_node_list, node_pos+3, connect, connect_offset+tri3_table[side_num][3]-1); get_nodes(exoid, side_set_node_list, node_pos+4, connect, connect_offset+tri3_table[side_num][4]-1); get_nodes(exoid, side_set_node_list, node_pos+5, connect, connect_offset+tri3_table[side_num][5]-1); } } else /* 2- or 3-node edge */ { if (num_nodes_per_elem > 3) /* 3-node edge */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+tri3_table[side_num][2]-1); } } } break; } case EX_EL_QUAD: { if (side_num+1 < 1 || side_num+1 > 4) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid quad edge number %"ST_ZU" in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos+0, connect, connect_offset+quad_table[side_num][0]-1); get_nodes(exoid, side_set_node_list, node_pos+1, connect, connect_offset+quad_table[side_num][1]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */ if (num_nodes_per_elem > 5) { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+quad_table[side_num][2]-1); } break; } case EX_EL_SHELL: { if (side_num+1 < 1 || side_num+1 > 6) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid shell face number %"ST_ZU" in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos+0, connect, connect_offset+shell_table[side_num][0]-1); get_nodes(exoid, side_set_node_list, node_pos+1, connect, connect_offset+shell_table[side_num][1]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */ if (num_nodes_per_elem > 2) /*** KLUDGE for 2D shells ***/ { if (side_num+1 <= 2) /* 4-node face */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */ get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+shell_table[side_num][2]-1); get_nodes(exoid, side_set_node_list, node_pos+3, connect, connect_offset+shell_table[side_num][3]-1); } } if (num_nodes_per_elem == 8) { if (side_num+1 <= 2) /* 8-node face */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node object */ get_nodes(exoid, side_set_node_list, node_pos+4, connect, connect_offset+shell_table[side_num][4]-1); get_nodes(exoid, side_set_node_list, node_pos+5, connect, connect_offset+shell_table[side_num][5]-1); get_nodes(exoid, side_set_node_list, node_pos+6, connect, connect_offset+shell_table[side_num][6]-1); get_nodes(exoid, side_set_node_list, node_pos+7, connect, connect_offset+shell_table[side_num][7]-1); } else { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node edge */ get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+shell_table[side_num][2]-1); } } break; } case EX_EL_TETRA: { if (side_num+1 < 1 || side_num+1 > 4) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid tetra face number %"ST_ZU" in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos+0, connect, connect_offset+tetra_table[side_num][0]-1); get_nodes(exoid, side_set_node_list, node_pos+1, connect, connect_offset+tetra_table[side_num][1]-1); get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+tetra_table[side_num][2]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ if (num_nodes_per_elem == 8) { set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */ get_nodes(exoid, side_set_node_list, node_pos+3, connect, connect_offset+tetra_table[side_num][3]-1); } else if (num_nodes_per_elem > 8) { set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node object */ get_nodes(exoid, side_set_node_list, node_pos+3, connect, connect_offset+tetra_table[side_num][3]-1); get_nodes(exoid, side_set_node_list, node_pos+4, connect, connect_offset+tetra_table[side_num][4]-1); get_nodes(exoid, side_set_node_list, node_pos+5, connect, connect_offset+tetra_table[side_num][5]-1); } break; } case EX_EL_WEDGE: { if (side_num+1 < 1 || side_num+1 > 5) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid wedge face number %"ST_ZU" in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+wedge_table[side_num][0]-1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+wedge_table[side_num][1]-1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+wedge_table[side_num][2]-1); if (wedge_table[side_num][3] == 0) { /* degenerate side? */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node side */ } else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+wedge_table[side_num][3]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node side */ } if (num_nodes_per_elem > 6) { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+wedge_table[side_num][4]-1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+wedge_table[side_num][5]-1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+wedge_table[side_num][6]-1); if (wedge_table[side_num][7] == 0) /* degenerate side? */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 7); /* 6 node side */ else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+wedge_table[side_num][7]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node side */ } } break; } case EX_EL_PYRAMID: { if (side_num+1 < 1 || side_num+1 > 5) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid pyramid face number %"ST_ZU" in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+pyramid_table[side_num][0]-1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+pyramid_table[side_num][1]-1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+pyramid_table[side_num][2]-1); if (pyramid_table[side_num][3] == 0) { /* degenerate side? */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node side */ } else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+pyramid_table[side_num][3]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node side */ } if (num_nodes_per_elem > 5) { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+pyramid_table[side_num][4]-1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+pyramid_table[side_num][5]-1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+pyramid_table[side_num][6]-1); if (pyramid_table[side_num][7] == 0) /* degenerate side? */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 7); /* 6 node side */ else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset+pyramid_table[side_num][7]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node side */ } } break; } case EX_EL_HEX: { if (side_num+1 < 1 || side_num+1 > 6) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid hex face number %"ST_ZU" in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); err_stat = EX_FATAL; goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos+0, connect, connect_offset+hex_table[side_num][0]-1); get_nodes(exoid, side_set_node_list, node_pos+1, connect, connect_offset+hex_table[side_num][1]-1); get_nodes(exoid, side_set_node_list, node_pos+2, connect, connect_offset+hex_table[side_num][2]-1); get_nodes(exoid, side_set_node_list, node_pos+3, connect, connect_offset+hex_table[side_num][3]-1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */ if (num_nodes_per_elem > 12) /* more nodes than HEXSHELL */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node object */ get_nodes(exoid, side_set_node_list, node_pos+4, connect, connect_offset+hex_table[side_num][4]-1); get_nodes(exoid, side_set_node_list, node_pos+5, connect, connect_offset+hex_table[side_num][5]-1); get_nodes(exoid, side_set_node_list, node_pos+6, connect, connect_offset+hex_table[side_num][6]-1); get_nodes(exoid, side_set_node_list, node_pos+7, connect, connect_offset+hex_table[side_num][7]-1); } if (num_nodes_per_elem == 27) /* 27-node brick */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node object */ get_nodes(exoid, side_set_node_list, node_pos+8, connect, connect_offset+hex_table[side_num][8]-1); } break; } default: { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: %s is an unsupported element type", elem_blk_parms[parm_ndx].elem_type); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } } } /* All done: release connectivity array space, element block ids array, element block parameters array, and side set element index array */ cleanup: safe_free(connect); safe_free(ss_parm_ndx); safe_free(elem_blk_ids); safe_free(elem_blk_parms); safe_free(ss_elem_ndx); safe_free(ss_elem_node_ndx); safe_free(side_set_side_list); safe_free(side_set_elem_list); return(err_stat); }
int ex_get_side_set_node_list(int exoid, ex_entity_id side_set_id, void_int *side_set_node_cnt_list, void_int *side_set_node_list) { size_t i, j; int64_t elem, side; int64_t num_side_sets, num_elem_blks, num_df, ndim; int64_t tot_num_elem = 0, tot_num_ss_elem = 0, elem_num = 0; size_t connect_offset, side_num, node_pos; void_int *elem_blk_ids = NULL; void_int *connect = NULL; void_int *ss_elem_ndx = NULL; void_int *ss_elem_node_ndx = NULL; void_int *ss_parm_ndx = NULL; void_int *side_set_elem_list = NULL; void_int *side_set_side_list = NULL; size_t elem_ctr, node_ctr, elem_num_pos; size_t num_nodes_per_elem; int int_size, ids_size; int err_stat = EX_NOERR; int status; struct elem_blk_parm *elem_blk_parms = NULL; /* side to node translation tables - These tables are used to look up the side number based on the first and second node in the side/face list. The side node order is found in the original Exodus document, SAND87-2997. The element node order is found in the ExodusII document, SAND92-2137. These tables were generated by following the right-hand rule for determining the outward normal. */ /* triangle */ static int tri_table[3][3] = { {1, 2, 4}, /* side 1 */ {2, 3, 5}, /* side 2 */ {3, 1, 6} /* side 3 */ }; /* triangle 3d */ static int tri3_table[5][7] = { {1, 2, 3, 4, 5, 6, 7}, /* side 1 (face) */ {3, 2, 1, 6, 5, 4, 7}, /* side 2 (face) */ {1, 2, 4, 0, 0, 0, 0}, /* side 3 (edge) */ {2, 3, 5, 0, 0, 0, 0}, /* side 4 (edge) */ {3, 1, 6, 0, 0, 0, 0} /* side 5 (edge) */ }; /* quad */ static int quad_table[4][3] = { {1, 2, 5}, /* side 1 */ {2, 3, 6}, /* side 2 */ {3, 4, 7}, /* side 3 */ {4, 1, 8} /* side 4 */ }; /* shell */ static int shell_table[6][9] = { {1, 2, 3, 4, 5, 6, 7, 8, 9}, /* side 1 (face) */ {1, 4, 3, 2, 8, 7, 6, 5, 9}, /* side 2 (face) */ {1, 2, 5, 0, 0, 0, 0, 0, 0}, /* side 3 (edge) */ {2, 3, 6, 0, 0, 0, 0, 0, 0}, /* side 4 (edge) */ {3, 4, 7, 0, 0, 0, 0, 0, 0}, /* side 5 (edge) */ {4, 1, 8, 0, 0, 0, 0, 0, 0} /* side 6 (edge) */ }; /* tetra */ static int tetra_table[4][7] = { {1, 2, 4, 5, 9, 8, 14}, /* Side 1 nodes */ {2, 3, 4, 6, 10, 9, 12}, /* Side 2 nodes */ {1, 4, 3, 8, 10, 7, 13}, /* Side 3 nodes */ {1, 3, 2, 7, 6, 5, 11} /* Side 4 nodes */ }; /* wedge */ /* wedge 6 or 7 */ static int wedge6_table[5][4] = { {1, 2, 5, 4}, /* Side 1 nodes -- quad */ {2, 3, 6, 5}, /* Side 2 nodes -- quad */ {1, 4, 6, 3}, /* Side 3 nodes -- quad */ {1, 3, 2, 0}, /* Side 4 nodes -- triangle */ {4, 5, 6, 0} /* Side 5 nodes -- triangle */ }; /* wedge 15 or 16 */ static int wedge15_table[5][8] = { {1, 2, 5, 4, 7, 11, 13, 10}, /* Side 1 nodes -- quad */ {2, 3, 6, 5, 8, 12, 14, 11}, /* Side 2 nodes -- quad */ {1, 4, 6, 3, 10, 15, 12, 9}, /* Side 3 nodes -- quad */ {1, 3, 2, 9, 8, 7, 0, 0}, /* Side 4 nodes -- triangle */ {4, 5, 6, 13, 14, 15, 0, 0} /* Side 5 nodes -- triangle */ }; /* wedge 20 */ static int wedge20_table[5][9] = { {1, 2, 5, 4, 7, 11, 13, 10, 20}, /* Side 1 nodes -- quad */ {2, 3, 6, 5, 8, 12, 14, 11, 18}, /* Side 2 nodes -- quad */ {1, 4, 6, 3, 10, 15, 12, 9, 19}, /* Side 3 nodes -- quad */ {1, 3, 2, 9, 8, 7, 16, 0, 0}, /* Side 4 nodes -- triangle */ {4, 5, 6, 13, 14, 15, 17, 0, 0} /* Side 5 nodes -- triangle */ }; /* wedge 21 */ static int wedge21_table[5][9] = { {1, 2, 5, 4, 7, 11, 13, 10, 21}, /* Side 1 nodes -- quad */ {2, 3, 6, 5, 8, 12, 14, 11, 19}, /* Side 2 nodes -- quad */ {1, 4, 6, 3, 10, 15, 12, 9, 20}, /* Side 3 nodes -- quad */ {1, 3, 2, 9, 8, 7, 17, 0, 0}, /* Side 4 nodes -- triangle */ {4, 5, 6, 13, 14, 15, 18, 0, 0} /* Side 5 nodes -- triangle */ }; /* wedge 18 */ static int wedge18_table[5][9] = { {1, 2, 5, 4, 7, 11, 13, 10, 16}, /* Side 1 nodes -- quad */ {2, 3, 6, 5, 8, 12, 14, 11, 17}, /* Side 2 nodes -- quad */ {1, 4, 6, 3, 10, 15, 12, 9, 18}, /* Side 3 nodes -- quad */ {1, 3, 2, 9, 8, 7, 0, 0, 0}, /* Side 4 nodes -- triangle */ {4, 5, 6, 13, 14, 15, 0, 0, 0} /* Side 5 nodes -- triangle */ }; /* hex */ static int hex_table[6][9] = { {1, 2, 6, 5, 9, 14, 17, 13, 26}, /* side 1 */ {2, 3, 7, 6, 10, 15, 18, 14, 25}, /* side 2 */ {3, 4, 8, 7, 11, 16, 19, 15, 27}, /* side 3 */ {1, 5, 8, 4, 13, 20, 16, 12, 24}, /* side 4 */ {1, 4, 3, 2, 12, 11, 10, 9, 22}, /* side 5 */ {5, 6, 7, 8, 17, 18, 19, 20, 23} /* side 6 */ }; /* pyramid */ static int pyramid_table[5][9] = { {1, 2, 5, 0, 6, 11, 10, 0, 15}, /* side 1 (tri) */ {2, 3, 5, 0, 7, 12, 11, 0, 16}, /* side 2 (tri) */ {3, 4, 5, 0, 8, 13, 12, 0, 17}, /* side 3 (tri) */ {1, 5, 4, 0, 10, 13, 9, 0, 18}, /* side 4 (tri) */ {1, 4, 3, 2, 9, 8, 7, 6, 14} /* side 5 (quad) */ }; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* first check if any side sets are specified */ /* inquire how many side sets have been stored */ num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS); if (num_side_sets < 0) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of side sets in file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); return (EX_FATAL); } if (num_side_sets == 0) { snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no side sets defined in file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, EX_WARN); return (EX_WARN); } /* Lookup index of side set id in VAR_SS_IDS array */ ex_id_lkup(exoid, EX_SIDE_SET, side_set_id); if (exerrval != 0) { if (exerrval == EX_NULLENTITY) { snprintf(errmsg, MAX_ERR_LENGTH, "Warning: side set %" PRId64 " is NULL in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list", errmsg, EX_NULLENTITY); return (EX_WARN); } snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate side set %" PRId64 " in VAR_SS_IDS array in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); return (EX_FATAL); } num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK); if (num_elem_blks < 0) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of element blocks in file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); return (EX_FATAL); } tot_num_elem = ex_inquire_int(exoid, EX_INQ_ELEM); if (tot_num_elem < 0) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get total number of elements in file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); return (EX_FATAL); } /* get the dimensionality of the coordinates; this is necessary to distinguish between 2d TRIs and 3d TRIs */ ndim = ex_inquire_int(exoid, EX_INQ_DIM); if (ndim < 0) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get dimensionality in file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); return (EX_FATAL); } int_size = sizeof(int); if (ex_int64_status(exoid) & EX_BULK_INT64_API) { int_size = sizeof(int64_t); } ids_size = sizeof(int); if (ex_int64_status(exoid) & EX_IDS_INT64_API) { ids_size = sizeof(int64_t); } /* First determine the # of elements in the side set*/ if (int_size == sizeof(int64_t)) { status = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &tot_num_ss_elem, &num_df); } else { int tot, df; status = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &tot, &df); tot_num_ss_elem = tot; num_df = df; } if (status != EX_NOERR) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of elements in side set %" PRId64 " in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); return (EX_FATAL); } /* Allocate space for the side set element list */ if (!(side_set_elem_list = malloc(tot_num_ss_elem * int_size))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set element list " "for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); return (EX_FATAL); } /* Allocate space for the side set side list */ if (!(side_set_side_list = malloc(tot_num_ss_elem * int_size))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set side list for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } if (ex_get_set(exoid, EX_SIDE_SET, side_set_id, side_set_elem_list, side_set_side_list) == -1) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get side set %" PRId64 " in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } /* Allocate space for the ss element index array */ if (!(ss_elem_ndx = malloc(tot_num_ss_elem * int_size))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem sort " "array for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } /* Sort side set element list into index array - non-destructive */ if (int_size == sizeof(int64_t)) { /* Sort side set element list into index array - non-destructive */ int64_t *elems = (int64_t *)ss_elem_ndx; for (i = 0; i < tot_num_ss_elem; i++) { elems[i] = i; /* init index array to current position */ } ex_iqsort64(side_set_elem_list, ss_elem_ndx, tot_num_ss_elem); } else { /* Sort side set element list into index array - non-destructive */ int *elems = (int *)ss_elem_ndx; for (i = 0; i < tot_num_ss_elem; i++) { elems[i] = i; /* init index array to current position */ } ex_iqsort(side_set_elem_list, ss_elem_ndx, tot_num_ss_elem); } /* Allocate space for the element block ids */ if (!(elem_blk_ids = malloc(num_elem_blks * ids_size))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block ids for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids) == -1) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element block ids in file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, EX_MSG); err_stat = EX_FATAL; goto cleanup; } /* Allocate space for the element block params */ if (!(elem_blk_parms = malloc(num_elem_blks * sizeof(struct elem_blk_parm)))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block params " "for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } elem_ctr = 0; for (i = 0; i < num_elem_blks; i++) { ex_entity_id id; if (ids_size == sizeof(int64_t)) { id = ((int64_t *)elem_blk_ids)[i]; } else { id = ((int *)elem_blk_ids)[i]; } err_stat = ex_int_get_block_param(exoid, id, ndim, &elem_blk_parms[i]); if (err_stat != EX_NOERR) { goto cleanup; } elem_ctr += elem_blk_parms[i].num_elem_in_blk; elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */ } /* Allocate space for the ss element to element block parameter index array */ if (!(ss_parm_ndx = malloc(tot_num_ss_elem * int_size))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem parms " "index for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } /* Allocate space for the ss element to node list index array */ if (!(ss_elem_node_ndx = malloc(tot_num_ss_elem * int_size))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem to node " "index for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } /* Build side set element to node list index and side set element parameter index. */ node_ctr = 0; for (i = 0; i < tot_num_ss_elem; i++) { if (ex_int64_status(exoid) & EX_BULK_INT64_API) { elem = ((int64_t *)side_set_elem_list)[i]; side = ((int64_t *)side_set_side_list)[i]; } else { elem = ((int *)side_set_elem_list)[i]; side = ((int *)side_set_side_list)[i]; } for (j = 0; j < num_elem_blks; j++) { if (elem_blk_parms[j].elem_type_val != EX_EL_NULL_ELEMENT) { if (elem <= elem_blk_parms[j].elem_ctr) { break; } } } if (j >= num_elem_blks) { exerrval = EX_BADPARAM; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Invalid element number %" PRId64 " found in side set %" PRId64 " in file %d", elem, side_set_id, exoid); ex_err("ex_get_side_set_node_list", errmsg, EX_MSG); err_stat = EX_FATAL; goto cleanup; } if (int_size == sizeof(int64_t)) { ((int64_t *)ss_parm_ndx)[i] = j; /* assign parameter block index */ ((int64_t *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */ } else { ((int *)ss_parm_ndx)[i] = j; /* assign parameter block index */ ((int *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */ } /* Update node_ctr (which points to next node in chain */ node_ctr += elem_blk_parms[j].num_nodes_per_side[side - 1]; } /* All setup, ready to go ... */ elem_ctr = 0; for (j = 0; j < tot_num_ss_elem; j++) { int64_t elem_ndx; size_t parm_ndx; if (ex_int64_status(exoid) & EX_BULK_INT64_API) { elem_ndx = ((int64_t *)ss_elem_ndx)[j]; elem = ((int64_t *)side_set_elem_list)[elem_ndx]; side = ((int64_t *)side_set_side_list)[elem_ndx]; parm_ndx = ((int64_t *)ss_parm_ndx)[elem_ndx]; } else { elem_ndx = ((int *)ss_elem_ndx)[j]; elem = ((int *)side_set_elem_list)[elem_ndx]; side = ((int *)side_set_side_list)[elem_ndx]; parm_ndx = ((int *)ss_parm_ndx)[elem_ndx]; } if (elem > elem_ctr) { /* release connectivity array space and get next one */ if (elem_ctr > 0) { free(connect); } /* Allocate space for the connectivity array for new element block */ if (!(connect = malloc(elem_blk_parms[parm_ndx].num_elem_in_blk * elem_blk_parms[parm_ndx].num_nodes_per_elem * int_size))) { exerrval = EX_MEMFAIL; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for connectivity " "array for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } /* get connectivity array */ if (ex_get_conn(exoid, EX_ELEM_BLOCK, elem_blk_parms[parm_ndx].elem_blk_id, connect, NULL, NULL) == -1) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for connectivity " "array for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } elem_ctr = elem_blk_parms[parm_ndx].elem_ctr; } if (connect == NULL) { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal error -- connect pointer is NULL for file id %d", exoid); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } /* For each side in side set, use the appropriate lookup table to determine the nodes from the connect array. */ elem_num = elem - 1; /* element number 0-based*/ /* calculate the relative element number position in it's block*/ elem_num_pos = elem_num - (elem_blk_parms[parm_ndx].elem_ctr - elem_blk_parms[parm_ndx].num_elem_in_blk); /* calculate the beginning of the node list for this element by using the ss_elem_node_ndx index into the side_sets_node_index and adding the element number position * number of nodes per elem */ num_nodes_per_elem = elem_blk_parms[parm_ndx].num_nodes_per_elem; connect_offset = num_nodes_per_elem * elem_num_pos; side_num = side - 1; if (int_size == sizeof(int64_t)) { node_pos = ((int64_t *)ss_elem_node_ndx)[elem_ndx]; } else { node_pos = ((int *)ss_elem_node_ndx)[elem_ndx]; } switch (elem_blk_parms[parm_ndx].elem_type_val) { case EX_EL_CIRCLE: case EX_EL_SPHERE: { /* Note: no side-node lookup table is used for this simple case */ get_nodes(exoid, side_set_node_list, node_pos, connect, connect_offset); set_count(exoid, side_set_node_cnt_list, elem_ndx, 1); /* 1 node object */ break; } case EX_EL_TRUSS: case EX_EL_BEAM: { /* Note: no side-node lookup table is used for this simple case */ for (i = 0; i < num_nodes_per_elem; i++) { get_nodes(exoid, side_set_node_list, node_pos + i, connect, connect_offset + i); } set_count(exoid, side_set_node_cnt_list, elem_ndx, num_nodes_per_elem); break; } case EX_EL_TRIANGLE: { if (ndim == 2) { /* 2d TRIs */ if (check_valid_side(side_num, 3, "triangle", exoid) != EX_NOERR) { goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos, connect, connect_offset + tri_table[side_num][0] - 1); get_nodes(exoid, side_set_node_list, node_pos + 1, connect, connect_offset + tri_table[side_num][1] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */ if (num_nodes_per_elem > 3) /* 6-node TRI */ { get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + tri_table[side_num][2] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ } } else if (ndim == 3) { /* 3d TRIs */ if (check_valid_side(side_num, 5, "triangle", exoid) != EX_NOERR) { goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos, connect, connect_offset + tri3_table[side_num][0] - 1); get_nodes(exoid, side_set_node_list, node_pos + 1, connect, connect_offset + tri3_table[side_num][1] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */ if (side_num + 1 <= 2) /* 3, 4, 6, 7-node face */ { if (num_nodes_per_elem == 3) /* 3-node face */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + tri3_table[side_num][2] - 1); } else if (num_nodes_per_elem == 4) /* 4-node face */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + tri3_table[side_num][2] - 1); get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + 4 - 1); /* Center node of 4-noded face */ } else if (num_nodes_per_elem == 6) /* 6-node face */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node object */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + tri3_table[side_num][2] - 1); get_nodes(exoid, side_set_node_list, node_pos + 3, connect, connect_offset + tri3_table[side_num][3] - 1); get_nodes(exoid, side_set_node_list, node_pos + 4, connect, connect_offset + tri3_table[side_num][4] - 1); get_nodes(exoid, side_set_node_list, node_pos + 5, connect, connect_offset + tri3_table[side_num][5] - 1); } else if (num_nodes_per_elem == 7) /* 7-node face */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 7); /* 7 node object */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + tri3_table[side_num][2] - 1); get_nodes(exoid, side_set_node_list, node_pos + 3, connect, connect_offset + tri3_table[side_num][3] - 1); get_nodes(exoid, side_set_node_list, node_pos + 4, connect, connect_offset + tri3_table[side_num][4] - 1); get_nodes(exoid, side_set_node_list, node_pos + 5, connect, connect_offset + tri3_table[side_num][5] - 1); get_nodes(exoid, side_set_node_list, node_pos + 6, connect, connect_offset + tri3_table[side_num][6] - 1); } else { snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: %d is an unsupported number of nodes for the triangle element type", (int)num_nodes_per_elem); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } } else /* 2- or 3-node edge */ { if (num_nodes_per_elem > 3) /* 3-node edge */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + tri3_table[side_num][2] - 1); } } } break; } case EX_EL_QUAD: { if (check_valid_side(side_num, 4, "quad", exoid) != EX_NOERR) { goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos + 0, connect, connect_offset + quad_table[side_num][0] - 1); get_nodes(exoid, side_set_node_list, node_pos + 1, connect, connect_offset + quad_table[side_num][1] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */ if (num_nodes_per_elem > 5) { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + quad_table[side_num][2] - 1); } break; } case EX_EL_SHELL: { if (check_valid_side(side_num, 6, "shell", exoid) != EX_NOERR) { goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos + 0, connect, connect_offset + shell_table[side_num][0] - 1); get_nodes(exoid, side_set_node_list, node_pos + 1, connect, connect_offset + shell_table[side_num][1] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */ if (num_nodes_per_elem > 2) { /*** KLUGE for 2D shells ***/ if (side_num + 1 <= 2) { /* 4-node face */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + shell_table[side_num][2] - 1); get_nodes(exoid, side_set_node_list, node_pos + 3, connect, connect_offset + shell_table[side_num][3] - 1); } } if (num_nodes_per_elem == 8) { if (side_num + 1 <= 2) { /* 8-node face */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node object */ get_nodes(exoid, side_set_node_list, node_pos + 4, connect, connect_offset + shell_table[side_num][4] - 1); get_nodes(exoid, side_set_node_list, node_pos + 5, connect, connect_offset + shell_table[side_num][5] - 1); get_nodes(exoid, side_set_node_list, node_pos + 6, connect, connect_offset + shell_table[side_num][6] - 1); get_nodes(exoid, side_set_node_list, node_pos + 7, connect, connect_offset + shell_table[side_num][7] - 1); } else { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node edge */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + shell_table[side_num][2] - 1); } } if (num_nodes_per_elem == 9) { if (side_num + 1 <= 2) { /* 9-node face */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node object */ get_nodes(exoid, side_set_node_list, node_pos + 4, connect, connect_offset + shell_table[side_num][4] - 1); get_nodes(exoid, side_set_node_list, node_pos + 5, connect, connect_offset + shell_table[side_num][5] - 1); get_nodes(exoid, side_set_node_list, node_pos + 6, connect, connect_offset + shell_table[side_num][6] - 1); get_nodes(exoid, side_set_node_list, node_pos + 7, connect, connect_offset + shell_table[side_num][7] - 1); get_nodes(exoid, side_set_node_list, node_pos + 8, connect, connect_offset + shell_table[side_num][8] - 1); } else { set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node edge */ get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + shell_table[side_num][2] - 1); } } break; } case EX_EL_TETRA: { if (check_valid_side(side_num, 4, "tetra", exoid) != EX_NOERR) { goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos + 0, connect, connect_offset + tetra_table[side_num][0] - 1); get_nodes(exoid, side_set_node_list, node_pos + 1, connect, connect_offset + tetra_table[side_num][1] - 1); get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + tetra_table[side_num][2] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */ if (num_nodes_per_elem == 8) { set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */ get_nodes(exoid, side_set_node_list, node_pos + 3, connect, connect_offset + tetra_table[side_num][3] - 1); } else if (num_nodes_per_elem > 8) { set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node object */ get_nodes(exoid, side_set_node_list, node_pos + 3, connect, connect_offset + tetra_table[side_num][3] - 1); get_nodes(exoid, side_set_node_list, node_pos + 4, connect, connect_offset + tetra_table[side_num][4] - 1); get_nodes(exoid, side_set_node_list, node_pos + 5, connect, connect_offset + tetra_table[side_num][5] - 1); } break; } case EX_EL_WEDGE: { int node_off = 0; if (check_valid_side(side_num, 5, "wedge", exoid) != EX_NOERR) { goto cleanup; } if (num_nodes_per_elem == 6 || num_nodes_per_elem == 7) { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge6_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge6_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge6_table[side_num][node_off++] - 1); if (side_num == 3 || side_num == 4) { /* This is one of the triangular faces */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node side */ assert(node_off == 3); } else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge6_table[side_num][node_off++] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node side */ assert(node_off == 4); } } else if (num_nodes_per_elem == 15 || num_nodes_per_elem == 16) { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge15_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge15_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge15_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge15_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge15_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge15_table[side_num][node_off++] - 1); if (side_num == 3 || side_num == 4) { /* This is one of the triangular faces */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node side */ assert(node_off == 6); } else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge15_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge15_table[side_num][node_off++] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node side */ assert(node_off == 8); } } else if (num_nodes_per_elem == 20) { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); if (side_num == 3 || side_num == 4) { /* This is one of the triangular faces */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 7); /* 7 node side */ assert(node_off == 7); } else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge20_table[side_num][node_off++] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node side */ assert(node_off == 9); } } else if (num_nodes_per_elem == 21) { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); if (side_num == 3 || side_num == 4) { /* This is one of the triangular faces */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 7); /* 7 node side */ } else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge21_table[side_num][node_off++] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node side */ } } else if (num_nodes_per_elem == 18) { /* Wedge 18 - 9-node quad faces (0,1,2) and 6-node tri faces (3,4) */ /* All faces (quad or tri) have at least 6 nodes */ /* This gets nodes 1-6 */ get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); if (side_num == 3 || side_num == 4) { set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node side */ assert(node_off == 6); } else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + wedge18_table[side_num][node_off++] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node side */ assert(node_off == 9); } } break; } case EX_EL_PYRAMID: { /* * node count: 5 -- 4-node quad, 3-node tri * 13 8 6 * 14 9 6 * 18 9 7 * 19 9 7 + volume center node. */ if (check_valid_side(side_num, 5, "pyramid", exoid) != EX_NOERR) { goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][0] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][1] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][2] - 1); if (pyramid_table[side_num][3] == 0) { /* degenerate side? */ set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node side */ } else { get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][3] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node side */ } if (num_nodes_per_elem > 5) { /* This gets the mid-edge nodes for three edges */ get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][4] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][5] - 1); get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][6] - 1); if (side_num == 4) { int face_node_count = num_nodes_per_elem >= 14 ? 9 : 8; set_count(exoid, side_set_node_cnt_list, elem_ndx, face_node_count); /* Get the last mid-edge node if this is quad face topology */ get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][7] - 1); if (num_nodes_per_elem >= 14) { /* Get the mid-face node for the quad */ get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][8] - 1); } } else { /* Triangular faces... */ int face_node_count = num_nodes_per_elem >= 18 ? 7 : 6; set_count(exoid, side_set_node_cnt_list, elem_ndx, face_node_count); if (num_nodes_per_elem >= 18) { /* Get the mid-face node for the tri */ get_nodes(exoid, side_set_node_list, node_pos++, connect, connect_offset + pyramid_table[side_num][8] - 1); } } } break; } case EX_EL_HEX: { if (check_valid_side(side_num, 6, "hex", exoid) != EX_NOERR) { goto cleanup; } get_nodes(exoid, side_set_node_list, node_pos + 0, connect, connect_offset + hex_table[side_num][0] - 1); get_nodes(exoid, side_set_node_list, node_pos + 1, connect, connect_offset + hex_table[side_num][1] - 1); get_nodes(exoid, side_set_node_list, node_pos + 2, connect, connect_offset + hex_table[side_num][2] - 1); get_nodes(exoid, side_set_node_list, node_pos + 3, connect, connect_offset + hex_table[side_num][3] - 1); set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */ if (num_nodes_per_elem > 12) /* more nodes than HEXSHELL */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node object */ get_nodes(exoid, side_set_node_list, node_pos + 4, connect, connect_offset + hex_table[side_num][4] - 1); get_nodes(exoid, side_set_node_list, node_pos + 5, connect, connect_offset + hex_table[side_num][5] - 1); get_nodes(exoid, side_set_node_list, node_pos + 6, connect, connect_offset + hex_table[side_num][6] - 1); get_nodes(exoid, side_set_node_list, node_pos + 7, connect, connect_offset + hex_table[side_num][7] - 1); } if (num_nodes_per_elem == 27) /* 27-node brick */ { set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node object */ get_nodes(exoid, side_set_node_list, node_pos + 8, connect, connect_offset + hex_table[side_num][8] - 1); } break; } default: { exerrval = EX_BADPARAM; snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: %s is an unsupported element type", elem_blk_parms[parm_ndx].elem_type); ex_err("ex_get_side_set_node_list", errmsg, exerrval); err_stat = EX_FATAL; goto cleanup; } } } /* All done: release connectivity array space, element block ids array, element block parameters array, and side set element index array */ cleanup: free(connect); free(ss_parm_ndx); free(elem_blk_ids); free(elem_blk_parms); free(ss_elem_ndx); free(ss_elem_node_ndx); free(side_set_side_list); free(side_set_elem_list); return (err_stat); }
void FreeList::reset(uint hint) { set_count(0); set_head(NULL); set_tail(NULL); set_hint(hint); }