lref_t run() { if (DEBUG_FLAG(DF_NO_STARTUP)) return NIL; return vmtrap(TRAP_RUN0, VMT_MANDATORY_TRAP, 0); }
void kinsol_errorHandler(int error_code, const char* module, const char* function, char* msg, void* user_data) { if(DEBUG_FLAG(LOG_INIT)) { WARNING3("[module] %s | [function] %s | [error_code] %d", module, function, error_code); WARNING_AL1("%s", msg); } }
void main() { CubitMessage::instance()->output_debug_information(1, 10, 2); CubitMessage::instance()->output_debug_information(12); CubitMessage::instance()->set_debug_file(5, "Debug_Test.file"); DEBUG_FLAG(5, CUBIT_TRUE); PRINT_DEBUG_5("This is a test\n"); CubitMessage::instance()->output_debug_information(5,5); }
int CubitMessage::is_debug_flag_set( int flag ) { if( DEBUG_FLAG( flag )) { currentDebugFlag = flag; return CUBIT_TRUE; } return CUBIT_FALSE; }
CABodies::CABodies(RefEntity* new_attrib_owner) : CubitAttrib(new_attrib_owner) { if (DEBUG_FLAG(138)) { PRINT_DEBUG_138( "Creating BODIES attribute for %s %d\n", (attribOwnerEntity ? attribOwnerEntity->class_name() : "(none)"), (attribOwnerEntity ? attribOwnerEntity->id() : 0)); } }
CABodies::CABodies(RefEntity* new_attrib_owner, CubitSimpleAttrib *csa_ptr) : CubitAttrib(new_attrib_owner) { assert ( csa_ptr != NULL ); if (DEBUG_FLAG(138)) { PRINT_DEBUG_138( "Creating BODIES attribute from CSA for %s %d\n", (attribOwnerEntity ? attribOwnerEntity->class_name() : "(none)"), (attribOwnerEntity ? attribOwnerEntity->id() : 0)); } std::vector<int> i_list = csa_ptr->int_data_list(); // first, the ints if (i_list.size() > 0) { m_interface = i_list[0]; // is interface if (i_list.size() > 1) { m_uniqueID = i_list[1]; // unique ID if(i_list.size() > 2) { // shared bodies int num_list = i_list[2]; for (int i = 0; i < num_list; i++) m_sharedBodies.append(i_list[3+i]); // shared procs int new_start = 3 + num_list; if(i_list.size() > new_start + 1) { num_list = i_list[new_start]; for (int i = 1; i <= num_list; i++) m_sharedProcs.append(i_list[new_start + i]); // ghost procs new_start += num_list+1; if(i_list.size() > new_start + 1) { num_list = i_list[new_start]; for (int i = 1; i <= num_list; i++) m_ghostProcs.append(i_list[new_start + i]); } } } } } }
CubitStatus CABodies::update() { if (hasUpdated) return CUBIT_SUCCESS; if (DEBUG_FLAG(138)) { PRINT_DEBUG_138( "Updating BODIES attribute for %s %d\n", attribOwnerEntity->class_name(), attribOwnerEntity->id()); } // set the updated flag hasUpdated = CUBIT_TRUE; // if the owner has a body list, save it, otherwise delete this one TDParallel *td_par = (TDParallel *) attrib_owner()->get_TD(&TDParallel::is_parallel); if (td_par == NULL) { delete_attrib(CUBIT_TRUE); } else { m_interface = td_par->is_interface(); m_uniqueID = td_par->get_unique_id(); int size = td_par->get_shared_body_list()->size(); td_par->get_shared_body_list()->reset(); m_sharedBodies.clean_out(); for (int i = 0; i < size; i++) { m_sharedBodies.append(td_par->get_shared_body_list()->get_and_step()); } size = td_par->get_shared_proc_list()->size(); td_par->get_shared_proc_list()->reset(); m_sharedProcs.clean_out(); for (int i = 0; i < size; i++) { m_sharedProcs.append(td_par->get_shared_proc_list()->get_and_step()); } size = td_par->get_ghost_proc_list()->size(); td_par->get_ghost_proc_list()->reset(); m_ghostProcs.clean_out(); for (int i = 0; i < size; i++) { m_ghostProcs.append(td_par->get_ghost_proc_list()->get_and_step()); } if (delete_attrib() == CUBIT_TRUE) delete_attrib(CUBIT_FALSE); } return CUBIT_SUCCESS; }
int AppUtil::shutdown() { // When the user is done, print out additional info if requested if (DEBUG_FLAG(3)) report_resource_usage(); // Return the number of errors in the session int ret_val = ( CubitMessage::instance()->error_count() ); if ( ret_val > 0 ) { PRINT_ERROR("Errors found during CUBIT session.\n"); } // Delete the singletons CubitMessage::delete_instance(); SettingHandler::delete_instance(); mAppStarted = CUBIT_FALSE; return ret_val; }
size_t debug_port_write_chars(lref_t port, const _TCHAR *buf, size_t count) { UNREFERENCED(port); assert(PORTP(port)); _TCHAR block[DEBUG_PORT_BLOCK_SIZE + 1]; size_t buf_loc = 0; size_t block_loc = 0; size_t len = count; /* Filter nulls out of the input string, and ensure that the * buffer we pass to OutputDebugString has as terminating * null. */ while (len > 0) { for (block_loc = 0; (block_loc < DEBUG_PORT_BLOCK_SIZE) && (len > 0); block_loc++, buf_loc++, len--) { if (buf[buf_loc] == '\0') block[block_loc] = '~'; else block[block_loc] = buf[buf_loc]; } block[block_loc] = '\0'; if (DEBUG_FLAG(DF_DEBUGGER_TO_ODS)) sys_output_debug_string(block); else fputs(block, stderr); } return len; }
static void fast_read(lref_t reader, lref_t * retval, bool allow_loader_ops /* = false */ ) { lref_t *fasl_table_entry = NULL; *retval = NIL; if (!FASL_READER_P(reader)) vmerror_wrong_type_n(1, reader); assert(NULLP(FASL_READER_STREAM(reader)->table) || VECTORP(FASL_READER_STREAM(reader)->table)); /* The core of this function is wrapped in a giant while loop to remove * tail recursive calls. Some opcodes don't directly return anything: * they just tail recursively read the next opcode after performing their * action via side effect. */ bool current_read_complete = false; while (!current_read_complete) { /* Assume we're going to complete the read unless we find out otherwise.. */ current_read_complete = true; size_t opcode_location = PORT_BYTES_READ(FASL_READER_PORT(reader)); enum fasl_opcode_t opcode = fast_read_opcode(reader); fixnum_t index = 0; lref_t name; if (DEBUG_FLAG(DF_FASL_SHOW_OPCODES)) { const _TCHAR *opcode_name = fasl_opcode_name(opcode); dscwritef(DF_FASL_SHOW_OPCODES, (_T("; DEBUG: fasl-opcode@~cx :~cS\n"), opcode_location, opcode_name ? opcode_name : _T("<INVALID>"))); } switch (opcode) { case FASL_OP_NIL: *retval = NIL; break; case FASL_OP_TRUE: *retval = boolcons(true); break; case FASL_OP_FALSE: *retval = boolcons(false); break; case FASL_OP_CHARACTER: fast_read_character(reader, retval); break; case FASL_OP_LIST: fast_read_list(reader, false, retval); break; case FASL_OP_LISTD: fast_read_list(reader, true, retval); break; case FASL_OP_FIX8: fast_read_fixnum_int8(reader, retval); break; case FASL_OP_FIX16: fast_read_fixnum_int16(reader, retval); break; case FASL_OP_FIX32: fast_read_fixnum_int32(reader, retval); break; case FASL_OP_FIX64: fast_read_fixnum_int64(reader, retval); break; case FASL_OP_FLOAT: fast_read_flonum(reader, false, retval); break; case FASL_OP_COMPLEX: fast_read_flonum(reader, true, retval); break; case FASL_OP_STRING: fast_read_string(reader, retval); break; case FASL_OP_PACKAGE: fast_read_package(reader, retval); break; case FASL_OP_VECTOR: fast_read_vector(reader, retval); break; case FASL_OP_HASH: fast_read_hash(reader, retval); break; case FASL_OP_CLOSURE: fast_read_closure(reader, retval); break; case FASL_OP_MACRO: fast_read_macro(reader, retval); break; case FASL_OP_SYMBOL: fast_read_symbol(reader, retval); break; case FASL_OP_SUBR: fast_read_subr(reader, retval); break; case FASL_OP_STRUCTURE: fast_read_structure(reader, retval); break; case FASL_OP_STRUCTURE_LAYOUT: fast_read_structure_layout(reader, retval); break; case FASL_OP_FAST_OP_0: fast_read_fast_op(0, false, reader, retval); break; case FASL_OP_FAST_OP_1: fast_read_fast_op(1, false, reader, retval); break; case FASL_OP_FAST_OP_2: fast_read_fast_op(2, false, reader, retval); break; case FASL_OP_FAST_OP_0N: fast_read_fast_op(0, true, reader, retval); break; case FASL_OP_FAST_OP_1N: fast_read_fast_op(1, true, reader, retval); break; case FASL_OP_FAST_OP_2N: fast_read_fast_op(2, true, reader, retval); break; case FASL_OP_NOP_1: case FASL_OP_NOP_2: case FASL_OP_NOP_3: current_read_complete = false; break; case FASL_OP_COMMENT_1: case FASL_OP_COMMENT_2: fast_read_to_newline(reader); current_read_complete = false; break; case FASL_OP_RESET_READER_DEFS: FASL_READER_STREAM(reader)->table = NIL; current_read_complete = false; break; case FASL_OP_READER_DEFINITION: index = fast_read_table_index(reader); fasl_table_entry = &(FASL_READER_STREAM(reader)->table->as.vector.data[index]); fast_read(reader, fasl_table_entry, allow_loader_ops); /* This should throw if the FASL table was resized * during the call to read. */ assert(fasl_table_entry == &(FASL_READER_STREAM(reader)->table->as.vector.data[index])); *retval = *fasl_table_entry; break; case FASL_OP_READER_REFERENCE: index = fast_read_table_index(reader); *retval = FASL_READER_STREAM(reader)->table->as.vector.data[index]; break; case FASL_OP_EOF: *retval = lmake_eof(); break; case FASL_OP_LOADER_DEFINEQ: case FASL_OP_LOADER_DEFINEA0: if (!allow_loader_ops) vmerror_fast_read(_T("loader definitions not allowed outside loader"), reader, NIL); fast_read_loader_definition(reader, opcode); current_read_complete = false; break; case FASL_OP_LOADER_APPLY0: case FASL_OP_LOADER_APPLYN: if (!allow_loader_ops) vmerror_fast_read(_T("loader function applications not allowed outside loader"), reader, NIL); fast_read_loader_application(reader, opcode); break; case FASL_OP_BEGIN_LOAD_UNIT: if (!allow_loader_ops) vmerror_fast_read(_T("load units are not allowed outside loader"), reader, NIL); fast_read(reader, &name, allow_loader_ops); dscwritef(DF_SHOW_FAST_LOAD_UNITS, ("; DEBUG: FASL entering unit ~s\n", name)); break; case FASL_OP_END_LOAD_UNIT: if (!allow_loader_ops) vmerror_fast_read(_T("load units are not allowed outside loader"), reader, NIL); fast_read(reader, &name, allow_loader_ops); dscwritef(DF_SHOW_FAST_LOAD_UNITS, ("; DEBUG: FASL leaving unit ~s\n", name)); break; case FASL_OP_LOADER_PUSH: fast_loader_stack_push(reader, FASL_READER_STREAM(reader)->accum); break; case FASL_OP_LOADER_DROP: fast_loader_stack_pop(reader); break; default: vmerror_fast_read("invalid opcode", reader, fixcons(opcode)); } } }
void initTracing (void) { #ifdef THREADED_RTS initMutex(&trace_utx); #endif #ifdef DEBUG #define DEBUG_FLAG(name, class) \ class = RtsFlags.DebugFlags.name ? 1 : 0; DEBUG_FLAG(scheduler, DEBUG_sched); DEBUG_FLAG(interpreter, DEBUG_interp); DEBUG_FLAG(weak, DEBUG_weak); DEBUG_FLAG(gccafs, DEBUG_gccafs); DEBUG_FLAG(gc, DEBUG_gc); DEBUG_FLAG(block_alloc, DEBUG_block_alloc); DEBUG_FLAG(sanity, DEBUG_sanity); DEBUG_FLAG(stable, DEBUG_stable); DEBUG_FLAG(stm, DEBUG_stm); DEBUG_FLAG(prof, DEBUG_prof); DEBUG_FLAG(linker, DEBUG_linker); DEBUG_FLAG(squeeze, DEBUG_squeeze); DEBUG_FLAG(hpc, DEBUG_hpc); DEBUG_FLAG(sparks, DEBUG_sparks); #endif // -Ds turns on scheduler tracing too TRACE_sched = RtsFlags.TraceFlags.scheduler || RtsFlags.DebugFlags.scheduler; // -Dg turns on gc tracing too TRACE_gc = RtsFlags.TraceFlags.gc || RtsFlags.DebugFlags.gc; TRACE_spark_sampled = RtsFlags.TraceFlags.sparks_sampled; // -Dr turns on full spark tracing TRACE_spark_full = RtsFlags.TraceFlags.sparks_full || RtsFlags.DebugFlags.sparks; TRACE_user = RtsFlags.TraceFlags.user; eventlog_enabled = RtsFlags.TraceFlags.tracing == TRACE_EVENTLOG; /* Note: we can have any of the TRACE_* flags turned on even when eventlog_enabled is off. In the DEBUG way we may be tracing to stderr. */ if (eventlog_enabled) { initEventLogging(); } }
bool is_debug_flag_set(enum debug_flag_t flag) { return DEBUG_FLAG(flag); }
CubitStatus CABodies::actuate() { CubitStatus status = CUBIT_SUCCESS; if (hasActuated == CUBIT_TRUE) return CUBIT_SUCCESS; if (DEBUG_FLAG(138)) { PRINT_DEBUG_138( "Actuating BODIES attribute for %s %d\n", attribOwnerEntity->class_name(), attribOwnerEntity->id()); } // create a TDParallel for the entity, if it doesn't already exist TDParallel *par = (TDParallel *) attrib_owner()->get_TD(&TDParallel::is_parallel); if (par != NULL) { if (par->is_interface() != m_interface) { PRINT_ERROR("TDParallel interface check is failed for %s %d.\n", attrib_owner()->class_name(), attrib_owner()->id()); return CUBIT_FAILURE; } // check to make sure it's the same body list par->get_shared_body_list()->reset(); m_sharedBodies.reset(); int size = par->get_shared_body_list()->size(); for (int i = 0; i < size; i++) { if (par->get_shared_body_list()->get_and_step() != m_sharedBodies.get_and_step()) { PRINT_ERROR("Different body found for %s %d.\n", attrib_owner()->class_name(), attrib_owner()->id()); return CUBIT_FAILURE; } } par->get_shared_proc_list()->reset(); m_sharedProcs.reset(); size = par->get_shared_proc_list()->size(); for (int i = 0; i < size; i++) { if (par->get_shared_proc_list()->get_and_step() != m_sharedProcs.get_and_step()) { PRINT_ERROR("Different processor found for %s %d.\n", attrib_owner()->class_name(), attrib_owner()->id()); return CUBIT_FAILURE; } } par->get_ghost_proc_list()->reset(); m_ghostProcs.reset(); size = par->get_ghost_proc_list()->size(); for (int i = 0; i < size; i++) { if (par->get_ghost_proc_list()->get_and_step() != m_ghostProcs.get_and_step()) { PRINT_ERROR("Different ghost processor found for %s %d.\n", attrib_owner()->class_name(), attrib_owner()->id()); return CUBIT_FAILURE; } } if ((int)par->get_unique_id() != m_uniqueID) { PRINT_ERROR("Different unique ID found for %s %d.\n", attrib_owner()->class_name(), attrib_owner()->id()); return CUBIT_FAILURE; } } else { // else make a new one par = new TDParallel(attrib_owner(), &m_sharedBodies, &m_sharedProcs, &m_ghostProcs, m_uniqueID, m_interface); } delete_attrib(CUBIT_TRUE); hasActuated = CUBIT_TRUE; return status; }
CubitStatus RefEntityName::add_refentity_name(RefEntity *entity, CubitString &name, bool update_attribs, bool check_name_validity) { if (name == "") return CUBIT_FAILURE; CubitString in_name = name; bool warn_name_change = false; if (check_name_validity) { if (clean(name)) { // Assign the invalid name anyway, then continue on and // assign the modified name. add_refentity_name(entity, in_name, false, false); warn_name_change = true; } } if (nameEntityList.move_to(name)) { RefEntity *old_entity = nameEntityList.get()->value(); if (old_entity == entity) { // Tried to assign same name to entity if ( DEBUG_FLAG(92) ) { PRINT_INFO("Entity name '%s' already assigned to %s %d\n", name.c_str(), entity->class_name(), entity->id()); return CUBIT_FAILURE; } return CUBIT_SUCCESS; } else { // Tried to assign existing name to another entity if ( DEBUG_FLAG(92) ) PRINT_WARNING("Entity name '%s' for %s %d is already used by %s %d\n", name.c_str(), entity->class_name(), entity->id(), old_entity->class_name(), old_entity->id()); if (get_fix_duplicate_names()) { if (generate_unique_name(name)) { if (warn_name_change) { PRINT_WARNING("Entity name '%s' can't be used in commands.\n" " Additional name '%s' assigned.\n", in_name.c_str(), name.c_str()); } if ( DEBUG_FLAG(92) ) PRINT_WARNING("\t%s %d name changed to '%s'\n", entity->class_name(), entity->id(), name.c_str()); return add_refentity_name(entity, name, update_attribs, false); } } return CUBIT_FAILURE; } } if (warn_name_change) { PRINT_WARNING("Entity name '%s' can't be used in commands.\n" " Additional name '%s' assigned.\n", in_name.c_str(), name.c_str()); } RefEntityNameMap *entity_name = new RefEntityNameMap(name, entity); nameEntityList.insert(entity_name); if (update_attribs == CUBIT_TRUE) { // now tell the entity to update its name attribute CubitAttrib *attrib = entity->get_cubit_attrib(CA_ENTITY_NAME); // force update by resetting update flag attrib->has_updated(CUBIT_FALSE); attrib->update(); } return CUBIT_SUCCESS; }
CubitStatus CAMergePartner::actuate_list(DLIList<RefEntity*> entity_list) { // given a list of ref entities (usually all entities of a given type), // actuate the camp's on those entities RefEntity *ref_ent, *keeper; DLIList<CubitAttrib*> ca_list; DLIList<TopologyBridge*> bridge_list(entity_list.size()); SDLCAMergePartnerList sorted_camp_list; int i; for(i = entity_list.size(); i > 0; i--) { ref_ent = entity_list.get_and_step(); ca_list.clean_out(); ref_ent->find_cubit_attrib_type(CA_MERGE_PARTNER, ca_list); assert(ca_list.size() < 2); // There should only be one // merge partner per entity if(ca_list.size() > 0) { CAMergePartner* attrib = dynamic_cast<CAMergePartner*>(ca_list.get()); sorted_camp_list.append( attrib ); TopologyEntity* te = dynamic_cast<TopologyEntity*>(ref_ent); TopologyBridge* bridge = te->bridge_manager()->topology_bridge(); bridge_list.append(bridge); } } sorted_camp_list.sort(); sorted_camp_list.reset(); if (DEBUG_FLAG(90)) { for (i = sorted_camp_list.size(); i > 0; i--) { CAMergePartner *camp_ptr = sorted_camp_list.get_and_step(); ref_ent = camp_ptr->attrib_owner(); PRINT_DEBUG_90("%s %d, unique id = %d\n", ref_ent->class_name(), ref_ent->id(), camp_ptr->merge_id()); } } // now go through all the camp's for the entity list; peel off // camp's with the same id, and merge the associated entities together while (sorted_camp_list.size() > 0) { DLIList<RefEntity*> refent_list; DLIList<CubitAttrib*> camp_list; keeper = NULL; // get the next list of entities with the same camp id sorted_camp_list.last(); CAMergePartner *camp_ptr = sorted_camp_list.remove(); sorted_camp_list.back(); camp_list.append(camp_ptr); int current_id = camp_ptr->merge_id(); while (sorted_camp_list.size() > 0 && sorted_camp_list.get()->merge_id() == current_id) { camp_list.append(sorted_camp_list.remove()); sorted_camp_list.back(); } if (camp_list.size() == 1) continue; CubitBoolean has_actuated = camp_list.get()->has_actuated(); // check the has actuated flag; if one is set, they all should be; // also, compile list of ref entities while we're at it for (current_id = camp_list.size(); current_id > 0; current_id--) { ref_ent = camp_list.get()->attrib_owner(); refent_list.append(ref_ent); if (!keeper || ref_ent->id() < keeper->id()) keeper = ref_ent; assert(camp_list.get()->has_actuated() == has_actuated); camp_list.step(); } // if they have already actuated, go on to next ones if (has_actuated == CUBIT_TRUE) continue; // otherwise merge if(refent_list.size() > 1) MergeTool::instance()->force_merge(refent_list); // remove the cubit attribute from the surviving parent keeper->remove_cubit_attrib(CA_MERGE_PARTNER); } // loop over existing camp's return CUBIT_SUCCESS; }
lref_t debug_print_object(lref_t obj, lref_t port, bool machine_readable) { _TCHAR buf[STACK_STRBUF_LEN]; if (DEBUG_FLAG(DF_PRINT_ADDRESSES)) scwritef("#@~c&=", port, obj); lref_t tmp; size_t ii; lref_t slots; const _TCHAR *fast_op_name; switch (TYPE(obj)) { case TC_NIL: WRITE_TEXT_CONSTANT(port, _T("()")); break; case TC_BOOLEAN: if (TRUEP(obj)) WRITE_TEXT_CONSTANT(port, _T("#t")); else WRITE_TEXT_CONSTANT(port, _T("#f")); break; case TC_CONS: write_char(port, _T('(')); debug_print_object(lcar(obj), port, machine_readable); for (tmp = lcdr(obj); CONSP(tmp); tmp = lcdr(tmp)) { write_char(port, _T(' ')); debug_print_object(lcar(tmp), port, machine_readable); } if (!NULLP(tmp)) { WRITE_TEXT_CONSTANT(port, _T(" . ")); debug_print_object(tmp, port, machine_readable); } write_char(port, _T(')')); break; case TC_FIXNUM: _sntprintf(buf, STACK_STRBUF_LEN, _T("%" SCAN_PRIiFIXNUM), FIXNM(obj)); write_text(port, buf, _tcslen(buf)); break; case TC_FLONUM: debug_print_flonum(obj, port, machine_readable); break; case TC_CHARACTER: if (machine_readable) { if (CHARV(obj) < CHARNAMECOUNT) scwritef(_T("#\\~cs"), port, charnames[(size_t) CHARV(obj)]); else if (CHARV(obj) >= CHAREXTENDED - 1) scwritef(_T("#\\<~cd>"), port, (int) CHARV(obj)); else scwritef(_T("#\\~cc"), port, (int) CHARV(obj)); } else scwritef(_T("~cc"), port, (int) CHARV(obj)); break; case TC_SYMBOL: if (NULLP(SYMBOL_HOME(obj))) { if (DEBUG_FLAG(DF_PRINT_FOR_DIFF)) scwritef("#:<uninterned-symbol>", port); else scwritef("#:~a@~c&", port, SYMBOL_PNAME(obj), obj); } else if (SYMBOL_HOME(obj) == interp.control_fields[VMCTRL_PACKAGE_KEYWORD]) scwritef(":~a", port, SYMBOL_PNAME(obj)); else { /* With only a minimal c-level package implementation, we * just assume every symbol is private. */ scwritef("~a::~a", port, SYMBOL_HOME(obj)->as.package.name, SYMBOL_PNAME(obj)); } break; case TC_VECTOR: WRITE_TEXT_CONSTANT(port, _T("[")); for (ii = 0; ii < obj->as.vector.dim; ii++) { debug_print_object(obj->as.vector.data[ii], port, true); if (ii + 1 < obj->as.vector.dim) write_char(port, _T(' ')); } write_char(port, _T(']')); break; case TC_STRUCTURE: WRITE_TEXT_CONSTANT(port, _T("#S(")); debug_print_object(CAR(STRUCTURE_LAYOUT(obj)), port, true); for (ii = 0, slots = CAR(CDR(STRUCTURE_LAYOUT(obj))); ii < STRUCTURE_DIM(obj); ii++, slots = CDR(slots)) { WRITE_TEXT_CONSTANT(port, _T(" ")); debug_print_object(CAR(CAR(slots)), port, true); WRITE_TEXT_CONSTANT(port, _T(" ")); debug_print_object(STRUCTURE_ELEM(obj, ii), port, true); } WRITE_TEXT_CONSTANT(port, _T(")")); break; case TC_STRING: debug_print_string(obj, port, machine_readable); break; case TC_HASH: debug_print_hash(obj, port, machine_readable); break; case TC_PACKAGE: scwritef("~u ~a", port, (lref_t) obj, obj->as.package.name); break; case TC_SUBR: scwritef("~u,~cd:~a", port, (lref_t) obj, SUBR_TYPE(obj), SUBR_NAME(obj)); break; case TC_CLOSURE: if (DEBUG_FLAG(DF_PRINT_CLOSURE_CODE)) scwritef("~u\n\tcode:~s\n\tenv:~s\n\tp-list:~s", port, (lref_t) obj, CLOSURE_CODE(obj), CLOSURE_ENV(obj), CLOSURE_PROPERTY_LIST(obj)); else scwritef("~u", port, (lref_t) obj); break; case TC_VALUES_TUPLE: scwritef("~u ~s", port, (lref_t) obj, obj->as.values_tuple.values); break; case TC_MACRO: if (DEBUG_FLAG(DF_PRINT_CLOSURE_CODE)) scwritef("~u ~s", port, (lref_t) obj, obj->as.macro.transformer); else scwritef("~u", port, (lref_t) obj); break; case TC_END_OF_FILE: scwritef("~u", port, (lref_t) obj); break; case TC_PORT: scwritef(_T("~u~cs~cs~cs ~cs ~s"), port, obj, PORT_INPUTP(obj) ? " (input)" : "", PORT_OUTPUTP(obj) ? " (output)" : "", BINARY_PORTP(obj) ? " (binary)" : "", PORT_CLASS(obj)->name, PORT_PINFO(obj)->port_name); break; case TC_FAST_OP: fast_op_name = fast_op_opcode_name(obj->header.opcode); if (fast_op_name) scwritef("#<FOP@~c&:~cs ~s ~s => ~s>", port, (lref_t) obj, fast_op_name, obj->as.fast_op.arg1, obj->as.fast_op.arg2, obj->as.fast_op.next); else scwritef("#<FOP@~c&:~cd ~s ~s => ~s>", port, (lref_t) obj, obj->header.opcode, obj->as.fast_op.arg1, obj->as.fast_op.arg2, obj->as.fast_op.next); break; case TC_FASL_READER: scwritef(_T("~u~s"), port, obj, FASL_READER_PORT(obj)); break; case TC_UNBOUND_MARKER: scwritef("#<UNBOUND-MARKER>", port); break; case TC_FREE_CELL: scwritef("#<FREE CELL -- Forget a call to gc_mark? ~c&>", port, obj); break; default: scwritef("#<INVALID OBJECT - UNKNOWN TYPE ~c&>", port, obj); } return port; }
//------------------------------------------------------------------------- // Purpose : facet_surface: facets the surface. // // Special Notes : // // Creator : David White // // Creation Date : 03/01/02 //------------------------------------------------------------------------- CubitStatus Faceter::facet_surface(DLIList <CubitFacet*> &results, DLIList <CubitPoint*> &point_list) { if ( DEBUG_FLAG(129) ) { GfxDebug::clear(); GfxDebug::draw_ref_face_edges(thisRefFacePtr); GfxDebug::flush(); int debug = 0; if ( debug ) { GfxDebug::mouse_xforms(); GfxDebug::flush(); } } if ( thisRefFacePtr->number_of_Loops() > 1 ) return CUBIT_FAILURE; //Get the ordered boundary loops. int ii, jj; DLIList <DLIList<CubitPoint*>*> boundary_point_loops; DLIList <CubitPoint*> *tmp_list_ptr; CubitStatus stat = get_boundary_points( boundary_point_loops ); if ( stat != CUBIT_SUCCESS ) { //clean up the data... for ( ii = boundary_point_loops.size(); ii > 0; ii-- ) { tmp_list_ptr = boundary_point_loops.pop(); for ( jj = tmp_list_ptr->size(); jj > 0; jj-- ) delete tmp_list_ptr->pop(); delete tmp_list_ptr; } return stat; } //Set up the gridsearch. double ratio = gridCellScale, cell_size = 0.0; max_min_edge_ratio(boundary_point_loops, ratio, cell_size); if (ratio <= gridCellScale) { ratio = gridCellScale; } //Get all of the points into a single list. for ( ii = boundary_point_loops.size(); ii > 0; ii-- ) { tmp_list_ptr = boundary_point_loops.get_and_step(); for ( jj = tmp_list_ptr->size(); jj > 0; jj-- ) { globalPointList->append(tmp_list_ptr->get_and_step()); } } gridSearchPtr = new PointGridSearch(*globalPointList, cell_size, ratio); //fill in the grid... for ( ii = globalPointList->size(); ii > 0; ii-- ) gridSearchPtr->add_point(globalPointList->get_and_step()); //Now start faceting. stat = facet_loop( boundary_point_loops.get(), results ); //clean up the data... for ( ii = boundary_point_loops.size(); ii > 0; ii-- ) delete boundary_point_loops.pop(); if ( stat != CUBIT_SUCCESS ) { //clean the data and return.. for ( ii = results.size(); ii > 0; ii-- ) delete results.pop(); for ( ii = globalPointList->size(); ii > 0; ii-- ) delete globalPointList->pop(); return stat; } //Didn't add any points... point_list += *globalPointList; return CUBIT_SUCCESS; }
CubitStatus RefEntityName::add_refentity_name(RefEntity *entity, DLIList<CubitString> &names, bool update_attribs, bool check_name_validity) { names.reset(); //int num_new_names = names.size(); DLIList<CubitString> new_names; for (int i=0; i<names.size(); i++) { CubitString name = names[i]; CubitString in_name = name; CubitBoolean warn_name_change = CUBIT_FALSE; // first, clean the name if (check_name_validity) { if (clean(name)) { // assign original name anyway, then // continue on and assign modified name. add_refentity_name(entity, in_name, false, false); warn_name_change = CUBIT_TRUE; } } // now, check for valid name CubitBoolean name_valid = CUBIT_FALSE; if (name == "") { // blank name entered - do nothing } else if (nameEntityList.move_to(name) && nameEntityList.get()->value() == entity) { // Tried to assign same name to entity if ( DEBUG_FLAG(92) ) { // check to see if it's the same as this entity's default name, // if so, it probably came in on an attribute, and we don't need // to hear about it; otherwise, write the warning CubitString def_name; entity->generate_default_name(def_name); if (name != def_name) PRINT_INFO("Entity name '%s' already assigned to %s %d\n", name.c_str(), entity->class_name(), entity->id()); } } else if (nameEntityList.move_to(name) && nameEntityList.get()->value() != entity) { // Tried to assign existing name to another entity PRINT_DEBUG_92( "Entity name '%s' for %s %d is already used by %s %d\n", name.c_str(), entity->class_name(), entity->id(), nameEntityList.get()->value()->class_name(), nameEntityList.get()->value()->id()); // either we fix it and keep it, or we don't and get rid of it name_valid = CUBIT_FALSE; if (get_fix_duplicate_names()) { if (generate_unique_name(name)) { PRINT_DEBUG_92( "\t%s %d name changed to '%s'\n", entity->class_name(), entity->id(), name.c_str()); if(warn_name_change) { PRINT_WARNING("Entity name '%s' can't be used in commands.\n" " Additional name '%s' assigned.\n", in_name.c_str(), name.c_str()); } name_valid = CUBIT_TRUE; } } } else { if(warn_name_change) { PRINT_WARNING("Entity name '%s' can't be used in commands.\n" " Additional name '%s' assigned.\n", in_name.c_str(), name.c_str()); } // else the name must be valid name_valid = CUBIT_TRUE; } if (name_valid == CUBIT_TRUE) { // name is valid if (name != in_name) // name was changed; change in name list too names[i] = name; // save this name to later new_names.append(names[i]); } } if (new_names.size() > 0) { // there are some valid, new names; add them, then update attribute new_names.reset(); CubitString name; for (int i = new_names.size(); i > 0; i--) { name = new_names.get_and_step(); if (nameEntityList.move_to(name) && nameEntityList.get()->value() == entity) { PRINT_DEBUG_92("Already have name %s for %s %d.\n", name.c_str(), entity->class_name(), entity->id()); } else { nameEntityList.insert(new RefEntityNameMap(name, entity)); } } if (update_attribs == CUBIT_TRUE) { // now tell the entity to update its name attribute CubitAttrib *attrib = entity->get_cubit_attrib(CA_ENTITY_NAME); // force update by resetting update flag attrib->has_updated(CUBIT_FALSE); attrib->update(); } } return CUBIT_SUCCESS; }
void initTracing (void) { #ifdef THREADED_RTS initMutex(&trace_utx); #endif DEBUG_FLAG(scheduler, DEBUG_sched); DEBUG_FLAG(interpreter, DEBUG_interp); DEBUG_FLAG(weak, DEBUG_weak); DEBUG_FLAG(gccafs, DEBUG_gccafs); DEBUG_FLAG(gc, DEBUG_gc); DEBUG_FLAG(block_alloc, DEBUG_block_alloc); DEBUG_FLAG(sanity, DEBUG_sanity); DEBUG_FLAG(stable, DEBUG_stable); DEBUG_FLAG(stm, DEBUG_stm); DEBUG_FLAG(prof, DEBUG_prof); DEBUG_FLAG(gran, DEBUG_gran); DEBUG_FLAG(par, DEBUG_par); DEBUG_FLAG(linker, DEBUG_linker); DEBUG_FLAG(squeeze, DEBUG_squeeze); DEBUG_FLAG(hpc, DEBUG_hpc); PAR_FLAG(verbose, PAR_DEBUG_verbose); PAR_FLAG(bq, PAR_DEBUG_bq); PAR_FLAG(schedule, PAR_DEBUG_schedule); PAR_FLAG(free, PAR_DEBUG_free); PAR_FLAG(resume, PAR_DEBUG_resume); PAR_FLAG(weight, PAR_DEBUG_weight); PAR_FLAG(fetch, PAR_DEBUG_fetch); PAR_FLAG(fish, PAR_DEBUG_fish); PAR_FLAG(tables, PAR_DEBUG_tables); PAR_FLAG(packet, PAR_DEBUG_packet); PAR_FLAG(pack, PAR_DEBUG_pack); PAR_FLAG(paranoia, PAR_DEBUG_paranoia); GRAN_FLAG(event_trace, GRAN_DEBUG_event_trace); GRAN_FLAG(event_stats, GRAN_DEBUG_event_stats); GRAN_FLAG(bq, GRAN_DEBUG_bq); GRAN_FLAG(pack, GRAN_DEBUG_pack); GRAN_FLAG(checkSparkQ, GRAN_DEBUG_checkSparkQ); GRAN_FLAG(thunkStealing, GRAN_DEBUG_thunkStealing); GRAN_FLAG(randomSteal, GRAN_DEBUG_randomSteal); GRAN_FLAG(findWork, GRAN_DEBUG_findWork); GRAN_FLAG(unused, GRAN_DEBUG_unused); GRAN_FLAG(pri, GRAN_DEBUG_pri); GRAN_FLAG(checkLight, GRAN_DEBUG_checkLight); GRAN_FLAG(sortedQ, GRAN_DEBUG_sortedQ); GRAN_FLAG(blockOnFetch, GRAN_DEBUG_blockOnFetch); GRAN_FLAG(packBuffer, GRAN_DEBUG_packBuffer); GRAN_FLAG(blockedOnFetch_sanity, GRAN_DEBUG_BOF_sanity); TRACE_FLAG(sched, TRACE_sched); }
/*! \fn ipopt_jac_g * * \param [in] [n] * \param [in] [x] * \param [in] [new_x] * \param [in] [m] * \param [in] [nele_jac] * \param [out] [iRow] * \param [out] [jCol] * \param [out] [values] * \param [ref] [user_data] * * \author lochel */ static Bool ipopt_jac_g(int n, double *x, Bool new_x, int m, int nele_jac, int *iRow, int *jCol, double *values, void *user_data) { IPOPT_DATA *ipopt_data = (IPOPT_DATA*)user_data; if(values == NULL) { int i, j; int idx = 0; if(ipopt_data->useSymbolic == 1) { /* * SPARSE * */ DEBUG_INFO(LOG_INIT, "ipopt using symbolic sparse jacobian G"); if(DEBUG_FLAG(LOG_INIT)) { DEBUG_INFO(LOG_INIT, "sparsity pattern"); for(i=0; i<n; ++i) { printf(" | | column %3d: [ ", i+1); for(j=0; idx<ipopt_data->data->simulationInfo.analyticJacobians[INDEX_JAC_G].sparsePattern.leadindex[i]; ++j) { if(j+1 == ipopt_data->data->simulationInfo.analyticJacobians[INDEX_JAC_G].sparsePattern.index[idx]) { idx++; printf("*"); } else printf("0"); } for(; j<m; ++j) printf("0"); printf("]\n"); } printf("\n"); } idx = 0; for(i=0; i<n; ++i) { for(j=0; idx<ipopt_data->data->simulationInfo.analyticJacobians[INDEX_JAC_G].sparsePattern.leadindex[i]; ++j) { if(j+1 == ipopt_data->data->simulationInfo.analyticJacobians[INDEX_JAC_G].sparsePattern.index[idx]) { jCol[idx] = i; iRow[idx] = j; idx++; } } } } else { /* * DENSE * */ DEBUG_INFO(LOG_INIT, "ipopt using numeric dense jacobian G"); idx = 0; for(i=0; i<n; ++i) { for(j=0; j<m; ++j) { jCol[idx] = i; iRow[idx] = j; idx++; } } } assert(idx == nele_jac); } else { /* return the values of the jacobian of the constraints */ DEBUG_INFO(LOG_INIT, "ipopt jacobian G"); if(ipopt_data->useSymbolic == 1) { functionJacG_sparse(ipopt_data->data, values); if(DEBUG_FLAG(LOG_INIT)) { int i, j; int idx = 0; for(i=0; i<n; ++i) { printf(" | | column %3d: [ ", i+1); for(j=0; idx<ipopt_data->data->simulationInfo.analyticJacobians[INDEX_JAC_G].sparsePattern.leadindex[i]; ++j) { if(j+1 == ipopt_data->data->simulationInfo.analyticJacobians[INDEX_JAC_G].sparsePattern.index[idx]) { printf("%10.5g ", values[idx]); idx++; } else printf("%10.5g ", 0.0); } for(; j<m; ++j) printf("%10.5g ", 0.0); printf("]\n"); } printf("\n"); } } else { int i, j; int idx = 0; double h = 1e-6; double hh; double *gp = (double*)malloc(m * sizeof(double)); double *gn = (double*)malloc(m * sizeof(double)); for(i=0; i<n; ++i) { hh = (abs(x[i]) > 1e-3) ? h*abs(x[i]) : h; x[i] += hh; ipopt_g(n, x, new_x, m, gp, user_data); x[i] -= 2.0*hh; ipopt_g(n, x, new_x, m, gn, user_data); x[i] += hh; for(j=0; j<m; ++j) { values[idx] = (gp[j]-gn[j])/(2.0*hh); idx++; } } free(gp); free(gn); if(DEBUG_FLAG(LOG_INIT)) { int i, j; for(i=0; i<n; ++i) { for(j=0; j<m; ++j) printf("%10.5g ", values[j*n+i]); printf("\n"); } } } } return TRUE; }
/* A C function to do Lisp-style Formatted I/O ****************** * * ~s - write the lisp object * ~a - display the lisp object * REVISIT: remove scvwritef ~u in favor of some kind of print_unreadable_object call * ~u - display the lisp object in unprintable fashion (ie. <type@addr...> * * ~cs - display the C string * ~cS - display the C string/arglist with a recursive call to scvwritef * ~cd - display the C integer * ~cf - display the C flonum * ~c& - display the C pointer * ~cc - display the C character * ~cC - display the C integer as an octal character constant * ~cB - display the C integer as a byte * * Prefixing a format code with a #\! (ie. ~!L) causes the corresponding * value to be returned from the function as a Lisp object. */ lref_t scvwritef(const _TCHAR * format_str, lref_t port, va_list arglist) { char ch; if (NULLP(port)) port = CURRENT_OUTPUT_PORT(); assert(PORTP(port)); _TCHAR buf[STACK_STRBUF_LEN]; lref_t lisp_arg_value = NULL; _TCHAR *str_arg_value = NULL; _TCHAR char_arg_value = _T('\0'); long int long_arg_value = 0; unsigned long int ulong_arg_value = 0; flonum_t flonum_arg_value = 0.0; lref_t unprintable_object = NIL; lref_t return_value = NIL; for (;;) { ch = *format_str; if (ch == '\0') break; bool return_next_value = false; format_str++; if (ch != '~') { write_char(port, ch); continue; } ch = *format_str; format_str++; if (ch == '!') { ch = *format_str; format_str++; return_next_value = true; } switch (ch) { case 's': lisp_arg_value = va_arg(arglist, lref_t); if (return_next_value) return_value = lisp_arg_value; debug_print_object(lisp_arg_value, port, true); break; case 'a': lisp_arg_value = va_arg(arglist, lref_t); if (return_next_value) return_value = lisp_arg_value; debug_print_object(lisp_arg_value, port, false); break; case 'u': unprintable_object = va_arg(arglist, lref_t); if (return_next_value) return_value = unprintable_object; if (DEBUG_FLAG(DF_PRINT_FOR_DIFF)) scwritef("#<~cs@(no-addr)", port, typecode_name(TYPE(unprintable_object))); else scwritef("#<~cs@~c&", port, typecode_name(TYPE(unprintable_object)), unprintable_object); break; case '~': write_char(port, '~'); break; case 'c': /* C object prefix */ ch = *format_str; /* read the next format character */ format_str++; switch (ch) { case 's': str_arg_value = va_arg(arglist, _TCHAR *); if (return_next_value) return_value = strconsbuf(str_arg_value); if (str_arg_value) write_text(port, str_arg_value, _tcslen(str_arg_value)); else WRITE_TEXT_CONSTANT(port, _T("<null>")); break; case 'S': str_arg_value = va_arg(arglist, _TCHAR *); if (return_next_value) return_value = scvwritef(str_arg_value, port, arglist); else scvwritef(str_arg_value, port, arglist); break; case 'd': long_arg_value = va_arg(arglist, long int); if (return_next_value) return_value = fixcons(long_arg_value); _sntprintf(buf, STACK_STRBUF_LEN, _T("%d"), (int) long_arg_value); write_text(port, buf, _tcslen(buf)); break; case 'x': long_arg_value = va_arg(arglist, long int); if (return_next_value) return_value = fixcons(long_arg_value); _sntprintf(buf, STACK_STRBUF_LEN, _T("%08lx"), long_arg_value); write_text(port, buf, _tcslen(buf)); break; case 'f': flonum_arg_value = va_arg(arglist, flonum_t); if (return_next_value) return_value = flocons(flonum_arg_value); _sntprintf(buf, STACK_STRBUF_LEN, _T("%f"), flonum_arg_value); write_text(port, buf, _tcslen(buf)); break; case '&': _sntprintf(buf, STACK_STRBUF_LEN, _T("%p"), (void *) va_arg(arglist, void *)); if (return_next_value) return_value = strconsbuf(buf); write_text(port, buf, _tcslen(buf)); break; case 'c': ulong_arg_value = va_arg(arglist, unsigned long int); if (return_next_value) return_value = fixcons(ulong_arg_value); char_arg_value = (_TCHAR) ulong_arg_value; write_text(port, &char_arg_value, 1); break; case 'C': ulong_arg_value = va_arg(arglist, unsigned long int); if (return_next_value) return_value = fixcons(ulong_arg_value); _sntprintf(buf, STACK_STRBUF_LEN, _T("%03o"), (uint32_t) ulong_arg_value); write_text(port, buf, _tcslen(buf)); break; case 'B': ulong_arg_value = va_arg(arglist, unsigned long int); if (return_next_value) return_value = fixcons(ulong_arg_value); _sntprintf(buf, STACK_STRBUF_LEN, _T("0x%02x"), (uint32_t) ulong_arg_value); write_text(port, buf, _tcslen(buf)); break; default: panic(_T("Invalid C object format character in scwritef")); break; }; break; default: panic(_T("Invalid format character in scwritef")); break; } return_next_value = false; } va_end(arglist); if (!NULLP(unprintable_object)) scwritef(">", port); return return_value; }
/*! \fn ipopt_initialization * * This function is used if ipopt is choosen for initialization. * * \param [ref] [data] * \param [ref] [initData] * \param [in] [useScaling] * * \author lochel */ int ipopt_initialization(DATA *data, INIT_DATA *initData, int useScaling) { int n = initData->nz; /* number of variables */ int m = (initData->nInitResiduals > initData->nz) ? 0 : initData->nInitResiduals; /* number of constraints */ double* x_L = NULL; /* lower bounds on x */ double* x_U = NULL; /* upper bounds on x */ double* g_L = NULL; /* lower bounds on g */ double* g_U = NULL; /* upper bounds on g */ double* x = NULL; /* starting point and solution vector */ double* mult_g = NULL; /* constraint multipliers at the solution */ double* mult_x_L = NULL; /* lower bound multipliers at the solution */ double* mult_x_U = NULL; /* upper bound multipliers at the solution */ double obj; /* objective value */ int i; /* generic counter */ int nele_jac = n*m; /* number of nonzeros in the Jacobian of the constraints */ int nele_hess = 0; /* number of nonzeros in the Hessian of the Lagrangian (lower or upper triangual part only) */ IpoptProblem nlp = NULL; /* ipopt-problem */ enum ApplicationReturnStatus status; /* solve return code */ IPOPT_DATA ipopt_data; ipopt_data.data = data; ipopt_data.initData = initData; ipopt_data.useScaling = useScaling; ipopt_data.useSymbolic = (initialAnalyticJacobianG(data) == 0 ? 1 : 0); if(ipopt_data.useSymbolic == 1) { nele_jac = data->simulationInfo.analyticJacobians[INDEX_JAC_G].sparsePattern.leadindex[n-1]; // sparse DEBUG_INFO1(LOG_INIT, "number of zeros in the Jacobian of the constraints (jac_g): %d", n*m-nele_jac); DEBUG_INFO1(LOG_INIT, "number of nonzeros in the Jacobian of the constraints (jac_g): %d", nele_jac); } /* allocate space for the variable bounds */ x_L = (double*)malloc(n * sizeof(double)); x_U = (double*)malloc(n * sizeof(double)); /* allocate space for the constraint bounds */ g_L = (double*)malloc(m * sizeof(double)); g_U = (double*)malloc(m * sizeof(double)); /* allocate space for the initial point */ x = (double*)malloc(n * sizeof(double)); /* set values of optimization variable bounds */ for(i=0; i<n; ++i) { x[i] = initData->start[i]; x_L[i] = initData->min[i]; x_U[i] = initData->max[i]; } /* set values of constraint bounds */ for(i=0; i<m; ++i) { g_L[i] = 0.0; g_U[i] = 0.0; } /* create the IpoptProblem */ nlp = CreateIpoptProblem( n, /* Number of optimization variables */ x_L, /* Lower bounds on variables */ x_U, /* Upper bounds on variables */ m, /* Number of constraints */ g_L, /* Lower bounds on constraints */ g_U, /* Upper bounds on constraints */ nele_jac, /* Number of non-zero elements in constraint Jacobian */ nele_hess, /* Number of non-zero elements in Hessian of Lagrangian */ 0, /* indexing style for iRow & jCol; 0 for C style, 1 for Fortran style */ &ipopt_f, /* Callback function for evaluating objective function */ &ipopt_g, /* Callback function for evaluating constraint functions */ &ipopt_grad_f, /* Callback function for evaluating gradient of objective function */ &ipopt_jac_g, /* Callback function for evaluating Jacobian of constraint functions */ &ipopt_h); /* Callback function for evaluating Hessian of Lagrangian function */ ASSERT(nlp, "creating of ipopt problem has failed"); /* We can free the memory now - the values for the bounds have been copied internally in CreateIpoptProblem */ free(x_L); free(x_U); free(g_L); free(g_U); /* Set some options. Note the following ones are only examples, they might not be suitable for your problem. */ AddIpoptNumOption(nlp, "tol", 1e-7); AddIpoptIntOption(nlp, "print_level", DEBUG_FLAG(LOG_INIT) ? 5 : 0); AddIpoptIntOption(nlp, "max_iter", 5000); AddIpoptStrOption(nlp, "mu_strategy", "adaptive"); AddIpoptStrOption(nlp, "hessian_approximation", "limited-memory"); /* allocate space to store the bound multipliers at the solution */ mult_g = (double*)malloc(m*sizeof(double)); mult_x_L = (double*)malloc(n*sizeof(double)); mult_x_U = (double*)malloc(n*sizeof(double)); /* solve the problem */ status = IpoptSolve( nlp, /* Problem that is to be optimized */ x, /* Input: Starting point; Output: Optimal solution */ NULL, /* Values of constraint at final point */ &obj, /* Final value of objective function */ mult_g, /* Final multipliers for constraints */ mult_x_L, /* Final multipliers for lower variable bounds */ mult_x_U, /* Final multipliers for upper variable bounds */ &ipopt_data); /* Pointer to user data */ setZ(initData, x); /* free allocated memory */ FreeIpoptProblem(nlp); free(x); free(mult_g); free(mult_x_L); free(mult_x_U); /* debug output */ DEBUG_INFO1(LOG_INIT, "ending with funcValue = %g", obj); DEBUG_INFO_AL(LOG_INIT, "| unfixed variables"); for(i=0; i<initData->nz; i++) DEBUG_INFO_AL4(LOG_INIT, "| | [%ld] %s = %g [scaled: %g]", i+1, initData->name[i], initData->z[i], initData->zScaled[i]); DEBUG_INFO_AL(LOG_INIT, "| residuals (> 0.001)"); for(i=0; i<data->modelData.nInitResiduals; i++) if(fabs(initData->initialResiduals[i]) > 1e-3) DEBUG_INFO_AL3(LOG_INIT, "| | [%ld] %g [scaled: %g]", i+1, initData->initialResiduals[i], (initData->residualScalingCoefficients[i] != 0.0) ? initData->initialResiduals[i]/initData->residualScalingCoefficients[i] : 0.0); if(status != Solve_Succeeded && status != Solved_To_Acceptable_Level) THROW("ipopt failed. see last warning. use [-lv LOG_INIT] for more output."); return (int)status; }
// The main midsurface function // lower_tol, upper_tol and preview are optional CubitStatus AutoMidsurfaceTool::midsurface( DLIList<Body*> &body_list_in, DLIList<BodySM*> &body_list_out, DLIList<Body*> &old_bodies_midsurfaced, DLIList<double> &thickness_out, double lower_limit, double upper_limit, CubitBoolean delete_midsurfaced, CubitBoolean preview) { if(lower_limit == CUBIT_DBL_MAX)// no limit set lower_limit = -CUBIT_DBL_MAX; double lower_tol = CUBIT_DBL_MAX; double upper_tol = CUBIT_DBL_MAX; const double auto_thickness_margin = 0.05; // if the user wants to automatically find the search // thickness then this var give the search margin around the // guess ProgressTool* prog_tool = 0; if(body_list_in.size()>5) prog_tool = AppUtil::instance()->progress_tool(); // At lease one body must be provided if(body_list_in.size() < 1) { PRINT_ERROR( "No bodies given for midsurfacing\n" ); return CUBIT_FAILURE; } // The surfaceOverlapTool is persistent so we need to save the // max_gap and such to restore them at the end or if we error out // save current settings double max_gap_save = SurfaceOverlapTool::instance()->get_gap_max(); double min_gap_save = SurfaceOverlapTool::instance()->get_gap_min(); int normal_type = SurfaceOverlapTool::instance()->get_normal_type(); CubitBoolean cubit_bool_save = SurfaceOverlapTool::instance()->get_check_within_bodies(); CubitBoolean skip_facing_surfaces = SurfaceOverlapTool::instance()->get_skip_facing_surfaces(); // we want to only find overlap within a body SurfaceOverlapTool::instance()->set_check_within_bodies(CUBIT_TRUE); // 1=any, 2=opposite, 3=same - we want to find only the overlaps that normals // pointing in the opposite directions SurfaceOverlapTool::instance()->set_normal_type(2); // Don't pickup surfaces that face each other SurfaceOverlapTool::instance()->set_skip_facing_surfaces(CUBIT_TRUE); // list of bodies that fail to midsurface DLIList<Body*> failing_bodies; GeometryModifyEngine* gme = 0; GeometryQueryEngine* gqe = 0; // loop over every body and try to create midsurface(s) int i = 0; CubitStatus return_status = CUBIT_FAILURE; if(prog_tool) prog_tool->start(0,body_list_in.size()); for(i = body_list_in.size();i--;) { if(prog_tool) prog_tool->step(); Body* cur_body = body_list_in[i]; if(!cur_body) continue; BodySM* body_sm = cur_body->get_body_sm_ptr(); if(!body_sm) continue; if(cur_body->is_sheet_body()) { PRINT_INFO("Body %d is a sheet body.\n",cur_body->id()); continue; } // Grab the geometrymodify and geometryquery engines to use later gqe = cur_body->get_geometry_query_engine(); gme = GeometryModifyTool::instance()->get_engine(body_sm); if(!gqe || !gme) continue; // Here are the steps to finding/creating the midsurface // 1. If the user did not give a thickness range to search then // make an educated guess at the proper thickness range. The assumption // is that the midsurface is a square and the thickness is constant. // The resulting equation is a third order polynomial that is solved using // a few newton iterations. The initial thickness guess is Volume/Area // 2. Using the given search distances use the SurfaceOverlapTool to find // surface pairs. // 3. If there is only one surface pair then use the existing midsurface commands // 4. Find if the surface pairs represent two surface patches // 5. If there are only two surface patches try to offset one of the patches // 6. (this step is commented out for now) - If 5 fails or there are more than // two surface patches then try the following: // - Use the manual midsurface creation function to create midsurfaces for each // pair of surfaces. // - Unite all of the created midsurfaces together // - remove any surfaces that have a curve touching a surface pair // - Regularize the resulting body // 7. Done { PRINT_DEBUG_198("AUTOMATICALLY calculating search range\n"); DLIList<RefVolume*> vol_list; cur_body->ref_volumes(vol_list); double total_vol = 0; double total_vol_bb = 0; for(int vol_cnt = 0; vol_cnt < vol_list.size(); vol_cnt++) { CubitVector cg; double temp_volume; vol_list[vol_cnt]->mass_properties(cg,temp_volume); CubitBox vol_bb = vol_list[vol_cnt]->bounding_box(); total_vol += temp_volume; total_vol_bb += vol_bb.x_range()*vol_bb.y_range()*vol_bb.z_range(); } if(total_vol<0 || total_vol > total_vol_bb) { PRINT_INFO("Could not midsurface Body %d - try healing the body.\n",cur_body->id()); failing_bodies.append(cur_body); continue; } PRINT_DEBUG_198("Volume of %f\n",total_vol); DLIList<RefFace*> face_list; cur_body->ref_faces(face_list); double total_surf = 0; for(int surf_cnt = 0; surf_cnt < face_list.size(); surf_cnt++) total_surf += face_list[surf_cnt]->area(); PRINT_DEBUG_198("Area of %f\n",total_surf); double t_g = total_vol/(total_surf/2.0); double initial_guess = t_g; PRINT_DEBUG_198("Initial guess of thickness %f\n",t_g); // use a newton solver to get a more accurate estimate the thickness of the volume for(int n_i = 0;n_i<100;n_i++) { double tol_newton = GEOMETRY_RESABS; double t_gn = t_g + tol_newton; double f_prime = ((2.0*total_vol + sqrt(total_vol*t_g*t_g*t_g)*4.0 - total_surf*t_g) -(2.0*total_vol + sqrt(total_vol*t_gn*t_gn*t_gn)*4.0 - total_surf*t_gn))/ (t_g-t_gn); // avoid divide by zero if(fabs(f_prime)<tol_newton) break; double t_old = t_g; t_g = t_g - (2.0*total_vol + sqrt(total_vol*t_g*t_g*t_g)*4.0 - total_surf*t_g)/f_prime; PRINT_DEBUG_198("Guess %d Thickness %f\n",n_i,t_g); if(fabs(t_g-t_old)<tol_newton) { PRINT_DEBUG_198("Converged with thickness of %f in %d steps\n",t_g,n_i); break; } if(t_g<0.0) { PRINT_DEBUG_198("thickness less than zero setting back to initial guess\n"); t_g = fabs(initial_guess); break; } } upper_tol = t_g + t_g*auto_thickness_margin; lower_tol = t_g - t_g*auto_thickness_margin; upper_tol = upper_tol <= upper_limit?upper_tol:upper_limit; lower_tol = lower_tol >= lower_limit?lower_tol:lower_limit; PRINT_DEBUG_198("Guessing a thickness of %f to %f\n",lower_tol,upper_tol); } // set the lower and upper search distances SurfaceOverlapTool::instance()->set_gap_max(upper_tol); SurfaceOverlapTool::instance()->set_gap_min(lower_tol); DLIList<RefFace*> ref_face_list,list1,list2; DLIList<RefEntity*> faces_to_draw; cur_body->ref_faces(ref_face_list); // find the surface pairs SurfaceOverlapTool::instance()->find_overlapping_surfaces(ref_face_list,list1,list2,faces_to_draw); int tweak_iters = 4; for(int tweak = 0;tweak<tweak_iters;tweak++) { // if we didn't find anything then the part may be long and selender so grow the search thickness if(list1.size()==0 && list2.size() == 0) { if(tweak == tweak_iters-1 && lower_limit != -CUBIT_DBL_MAX && upper_limit != CUBIT_DBL_MAX) { // on the last try use the user defined limits lower_tol = lower_limit; upper_tol = upper_limit; } else { lower_tol = (upper_tol + lower_tol)/2.0; upper_tol += lower_tol*auto_thickness_margin*2; upper_tol = upper_tol <= upper_limit?upper_tol:upper_limit; lower_tol = lower_tol >= lower_limit?lower_tol:lower_limit; } PRINT_DEBUG_198("Guessing again with thickness of %f to %f\n",lower_tol,upper_tol); SurfaceOverlapTool::instance()->set_gap_max(upper_tol); SurfaceOverlapTool::instance()->set_gap_min(lower_tol); SurfaceOverlapTool::instance()->find_overlapping_surfaces(ref_face_list,list1,list2,faces_to_draw); } DLIList<RefFace*> check_list; check_list += list1; check_list += list2; if(check_list.size() == 0 ) continue; // make sure the pairs will match the solid within 10% or so if(!check_surf_pairs(lower_tol,upper_tol,check_list,cur_body)) { list1.clean_out(); list2.clean_out(); continue; } break; } if(list1.size() != list2.size()) { PRINT_INFO("Could not find workable surface pairs for Body %d - try using the Sheet Offset command. \n",cur_body->id()); failing_bodies.append(cur_body); continue; } else if(list1.size() == 0 || list2.size() == 0) { PRINT_INFO("No surface pairs found for Body %d - try changing the search range\n",cur_body->id()); failing_bodies.append(cur_body); continue; } // get the first pair and see if there are only two patches DLIList<RefFace*> red_faces; red_faces.append(list1[0]); DLIList<RefFace*> yellow_faces; yellow_faces.append(list2[0]); DLIList<RefFace*> paired_faces; paired_faces += list1; paired_faces += list2; paired_faces.uniquify_unordered(); // red surfaces while(1) { int start_cnt = red_faces.size(); DLIList<RefEdge*> red_edges; int j = 0; for(j =0;j<red_faces.size();j++) red_faces[j]->ref_edges(red_edges); red_edges.uniquify_unordered(); for(j =0;j<red_edges.size();j++) red_edges[j]->ref_faces(red_faces); red_faces.uniquify_unordered(); red_faces.intersect_unordered(paired_faces); if(start_cnt == red_faces.size()) break; } // yellow surfaces while(1) { int start_cnt = yellow_faces.size(); DLIList<RefEdge*> yellow_edges; int j = 0; for(j =0;j<yellow_faces.size();j++) yellow_faces[j]->ref_edges(yellow_edges); yellow_edges.uniquify_unordered(); for(j =0;j<yellow_edges.size();j++) yellow_edges[j]->ref_faces(yellow_faces); yellow_faces.uniquify_unordered(); yellow_faces.intersect_unordered(paired_faces); if(start_cnt == yellow_faces.size()) break; } DLIList<BodySM*> results; bool midsurface_done = false; if(DEBUG_FLAG(198)) { int j = 0; PRINT_INFO("Trying surface offset to create the mid_surface\n"); PRINT_INFO("Red surface "); for(j = 0;j < red_faces.size();j++) { GfxDebug::draw_ref_face(red_faces[j],CUBIT_RED); PRINT_INFO("%d ",red_faces[j]->id()); } PRINT_INFO("\nYellow surface "); for(j = 0;j < yellow_faces.size();j++) { GfxDebug::draw_ref_face(yellow_faces[j],CUBIT_YELLOW); PRINT_INFO("%d ",yellow_faces[j]->id()); } PRINT_INFO("\n"); } // first check to see if we can use the simple midsurface functions if(red_faces.size() == 1 && yellow_faces.size() == 1 && paired_faces.size() == red_faces.size() + yellow_faces.size()) { RefFace* face_1 = red_faces[0]; RefFace* face_2 = yellow_faces[0]; midsurface_done = false; if(face_1->geometry_type() == face_2->geometry_type()) { Surface* surf_1 = face_1->get_surface_ptr(); Surface* surf_2 = face_2->get_surface_ptr(); BodySM* result_body; // grab the distance between surfaces CubitVector temp_vec0; CubitVector temp_vec1; double temp_dist = 0; gqe->entity_entity_distance( face_1->get_surface_ptr(), face_2->get_surface_ptr(), temp_vec0,temp_vec1,temp_dist); switch(face_1->geometry_type()) { case CONE_SURFACE_TYPE: if(gme->get_conic_mid_surface(surf_1,surf_2,body_sm,result_body) == CUBIT_SUCCESS) { midsurface_done = true; results.append(result_body); thickness_out.append(fabs(temp_dist)); } break; case PLANE_SURFACE_TYPE: if(get_planar_mid_surface(face_1,face_2,body_sm,result_body,gme) == CUBIT_SUCCESS) { midsurface_done = true; results.append(result_body); thickness_out.append(fabs(temp_dist)); } break; case SPHERE_SURFACE_TYPE: if(gme->get_spheric_mid_surface(surf_1,surf_2,body_sm,result_body) == CUBIT_SUCCESS) { midsurface_done = true; results.append(result_body); thickness_out.append(fabs(temp_dist)); } break; case TORUS_SURFACE_TYPE: if(gme->get_toric_mid_surface(surf_1,surf_2,body_sm,result_body) == CUBIT_SUCCESS) { midsurface_done = true; results.append(result_body); thickness_out.append(fabs(temp_dist)); } break; case CYLINDER_SURFACE_TYPE: if(gme->get_conic_mid_surface(surf_1,surf_2,body_sm,result_body) == CUBIT_SUCCESS) { midsurface_done = true; results.append(result_body); thickness_out.append(fabs(temp_dist)); } break; default: break; } } } if(!midsurface_done && paired_faces.size() == red_faces.size() + yellow_faces.size()) // just do the offset { int j = 0; DLIList<double> offset_distances; for(j = 0;j<list1.size();j++) { CubitVector temp_vec0; CubitVector temp_vec1; double temp_dist = 0; if(!gqe->entity_entity_distance( list1[j]->get_surface_ptr(), list2[j]->get_surface_ptr(), temp_vec0,temp_vec1,temp_dist)) { break; } offset_distances.append(-temp_dist*.5); } DLIList<Surface*> red_surfs; for(j = 0;j<red_faces.size();j++) red_surfs.append(red_faces[j]->get_surface_ptr()); DLIList<Surface*> yellow_surfs; for(j = 0;j<yellow_faces.size();j++) yellow_surfs.append(yellow_faces[j]->get_surface_ptr()); // all of the surfaces are offset the same distance double offset_distance = offset_distances[0]; bool old_error_flag = GET_ERROR_FLAG(); SET_ERROR_FLAG(false); // don't throw any gme errors if( gme->create_offset_sheet(red_surfs,offset_distance, NULL,NULL,results)) { midsurface_done = true; for(j = 0;j<results.size();j++) // for every body add a thickness thickness_out.append(fabs(offset_distance*2.)); } else if( gme->create_offset_sheet(yellow_surfs,offset_distance, NULL,NULL,results)) // try the other direction { midsurface_done = true; for(j = 0;j<results.size();j++) // for every body add a thickness thickness_out.append(fabs(offset_distance*2.)); } else { PRINT_INFO("Could not create midsurface for Body %d - try using the surface offset command\n",cur_body->id()); failing_bodies.append(cur_body); } SET_ERROR_FLAG(old_error_flag); // turn errors back on } if(!midsurface_done && paired_faces.size() != red_faces.size() + yellow_faces.size()) { PRINT_INFO("Could not find workable surface pairs for Body %d - try changing the search range or \n" " using the Sheet Offset command.\n",cur_body->id()); } /*if(!midsurface_done) { if(DEBUG_FLAG(198)) PRINT_INFO("Trying the extend, unite, and trim method\n"); // okay now remove duplicate pairs and unsupported pairs DLIList<Surface*> surf_list1; DLIList<Surface*> surf_list2; bool delete_and_exit = false; for(int j = 0;j<list1.size();j++) { RefFace* face_1 = list1[j]; RefFace* face_2 = list2[j]; if(DEBUG_FLAG(198)) { PRINT_INFO("Red surface "); GfxDebug::draw_ref_face(face_1,CUBIT_RED); PRINT_INFO("%d ",face_1->id()); PRINT_INFO("\nYellow surface "); GfxDebug::draw_ref_face(face_2,CUBIT_YELLOW); PRINT_INFO("%d ",face_2->id()); PRINT_INFO("\n"); } if(face_1->geometry_type() != face_2->geometry_type()) continue; Surface* surf_1 = face_1->get_surface_ptr(); surf_list1.append(surf_1); Surface* surf_2 = face_2->get_surface_ptr(); surf_list2.append(surf_2); BodySM* result_body; switch(face_1->geometry_type()) { case CONE_SURFACE_TYPE: if(gme->get_conic_mid_surface(surf_1,surf_2,body_sm,result_body) == CUBIT_SUCCESS) results.append(result_body); else delete_and_exit = true; break; case PLANE_SURFACE_TYPE: if(get_planar_mid_surface(face_1,face_2,body_sm,result_body,gme) == CUBIT_SUCCESS) results.append(result_body); else delete_and_exit = true; break; case SPHERE_SURFACE_TYPE: if(gme->get_spheric_mid_surface(surf_1,surf_2,body_sm,result_body) == CUBIT_SUCCESS) results.append(result_body); else delete_and_exit = true; break; case TORUS_SURFACE_TYPE: if(gme->get_toric_mid_surface(surf_1,surf_2,body_sm,result_body) == CUBIT_SUCCESS) results.append(result_body); else delete_and_exit = true; break; case CYLINDER_SURFACE_TYPE: if(gme->get_conic_mid_surface(surf_1,surf_2,body_sm,result_body) == CUBIT_SUCCESS) results.append(result_body); else delete_and_exit = true; break; default: delete_and_exit = true; break; } if(delete_and_exit) { PRINT_WARNING("Failed to pair surface %d with surface %d\n",face_1->id(),face_2->id()); break; } } if(delete_and_exit) { failing_bodies.append(cur_body); gqe->delete_solid_model_entities(results); continue; } DLIList<BodySM*> unite_results; if(results.size()>1) { bool reg_result = GeometryModifyTool::instance()->boolean_regularize(); GeometryModifyTool::instance()->boolean_regularize(true); if(gme->unite(results,unite_results)== CUBIT_SUCCESS) { // if the unite works just add them to the result list results = unite_results; } else { // clean up the created surfaces and move on to the next // body failing_bodies.append(cur_body); gqe->delete_solid_model_entities(results); GeometryModifyTool::instance()->boolean_regularize(reg_result); continue; } GeometryModifyTool::instance()->boolean_regularize(reg_result); } // trim the hanging surfaces DLIList<Surface*> paired_surfs; paired_surfs += surf_list1; paired_surfs += surf_list2; DLIList<Curve*> all_curves; int k = 0; for(k = 0;k<results.size();k++) results[k]->curves(all_curves); all_curves.uniquify_unordered(); DLIList<Surface*> remove_surfs; for(k = 0;k<all_curves.size();k++) for(int m = 0;m<paired_surfs.size();m++) if(curve_in_surface(all_curves[k],paired_surfs[m])) all_curves[k]->surfaces(remove_surfs); remove_surfs.uniquify_unordered(); body_list_out += results; DLIList<BodySM*> tweak_results; if(gme->tweak_remove(remove_surfs,tweak_results,CUBIT_FALSE)) { results = tweak_results; } else { // clean up the created surfaces and move on to the next // body failing_bodies.append(cur_body); gqe->delete_solid_model_entities(results); continue; } DLIList<BodySM*> regularize_results; // regularize the results for(k = 0;k < results.size();k++) { BodySM* new_body = 0; if(gme->regularize_body(results[k],new_body)) regularize_results.append(new_body); else if(DEBUG_FLAG(198)) PRINT_INFO("Regularize failure\n"); } results = regularize_results; }*/ if(!midsurface_done) { failing_bodies.append(cur_body); continue; } old_bodies_midsurfaced.append(cur_body); if(delete_midsurfaced && !preview) GeometryQueryTool::instance()->delete_Body(cur_body); return_status = CUBIT_SUCCESS; body_list_out += results; } if(prog_tool) prog_tool->end(); PRINT_INFO("Successfully midsurface %d of %d bodies\n",body_list_out.size(),body_list_in.size()); if(preview) { for(int k = 0;k<body_list_out.size();k++) { DLIList<Surface*> preview_surfaces; body_list_out[k]->surfaces(preview_surfaces); for(int p = 0;p<preview_surfaces.size();p++) GfxPreview::draw_surface_facets_shaded(preview_surfaces[p],CUBIT_BLUE); } GfxPreview::flush(); if(gqe) gqe->delete_solid_model_entities(body_list_out); body_list_out.clean_out(); } if(failing_bodies.size() > 0) { PRINT_INFO("\n"); PRINT_INFO("Failed to midsurface Body "); for(i = 0;i<failing_bodies.size();i++) PRINT_INFO("%d ",failing_bodies[i]->id()); PRINT_INFO("\n"); } if(DEBUG_FLAG(198)) GfxDebug::flush(); SurfaceOverlapTool::instance()->set_check_within_bodies(cubit_bool_save); SurfaceOverlapTool::instance()->set_gap_max(max_gap_save); SurfaceOverlapTool::instance()->set_normal_type(normal_type); SurfaceOverlapTool::instance()->set_gap_min(min_gap_save); SurfaceOverlapTool::instance()->set_skip_facing_surfaces(skip_facing_surfaces); return return_status; }