int main(int argc, char* argv[]) { // Choose a Butcher's table or define your own. ButcherTable bt(butcher_table_type); // Load the mesh. Mesh mesh; H2DReader mloader; mloader.load("cathedral.mesh", &mesh); // Perform initial mesh refinements. for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(); mesh.refine_towards_boundary(BDY_AIR, INIT_REF_NUM_BDY); mesh.refine_towards_boundary(BDY_GROUND, INIT_REF_NUM_BDY); // Enter boundary markers. BCTypes bc_types; bc_types.add_bc_dirichlet(Hermes::vector<std::string>(BDY_GROUND)); bc_types.add_bc_newton(BDY_AIR); // Enter Dirichlet boundary values. BCValues bc_values; bc_values.add_const(BDY_GROUND, TEMP_INIT); // Initialize an H1 space with default shapeset. H1Space space(&mesh, &bc_types, &bc_values, P_INIT); int ndof = Space::get_num_dofs(&space); info("ndof = %d.", ndof); // Previous time level solution (initialized by the external temperature). Solution u_prev_time(&mesh, TEMP_INIT); // Initialize weak formulation. WeakForm wf; wf.add_matrix_form(callback(stac_jacobian)); wf.add_vector_form(callback(stac_residual)); wf.add_matrix_form_surf(callback(bilinear_form_surf), BDY_AIR); wf.add_vector_form_surf(callback(linear_form_surf), BDY_AIR); // Project the initial condition on the FE space to obtain initial solution coefficient vector. info("Projecting initial condition to translate initial condition into a vector."); scalar* coeff_vec = new scalar[ndof]; OGProjection::project_global(&space, &u_prev_time, coeff_vec, matrix_solver); // Initialize the FE problem. bool is_linear = false; DiscreteProblem dp(&wf, &space, is_linear); // Initialize views. ScalarView Tview("Temperature", new WinGeom(0, 0, 450, 600)); //Tview.set_min_max_range(0,20); Tview.fix_scale_width(30); // Time stepping loop: double current_time = 0.0; int ts = 1; do { // Perform one Runge-Kutta time step according to the selected Butcher's table. info("Runge-Kutta time step (t = %g, tau = %g, stages: %d).", current_time, time_step, bt.get_size()); bool verbose = true; bool is_linear = true; if (!rk_time_step(current_time, time_step, &bt, coeff_vec, &dp, matrix_solver, verbose, is_linear)) { error("Runge-Kutta time step failed, try to decrease time step size."); } // Convert coeff_vec into a new time level solution. Solution::vector_to_solution(coeff_vec, &space, &u_prev_time); // Update time. current_time += time_step; // Show the new time level solution. char title[100]; sprintf(title, "Time %3.2f, exterior temperature %3.5f", current_time, temp_ext(current_time)); Tview.set_title(title); Tview.show(&u_prev_time); // Increase counter of time steps. ts++; } while (current_time < T_FINAL); // Cleanup. delete [] coeff_vec; // Wait for the view to be closed. View::wait(); return 0; }
void address_map_bank_device::device_start() { m_program = &space(AS_PROGRAM); save_item(NAME(m_offset)); }
int main(int argc, char* argv[]) { // Load the mesh. Hermes::Hermes2D::Mesh mesh; Hermes::Hermes2D::MeshReaderH2D mloader; mloader.load("domain.mesh", &mesh); // Perform initial mesh refinements (optional). for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(); // Initialize the weak formulation. CustomWeakFormPoissonNewton wf("Aluminum", new Hermes::Hermes1DFunction<double>(LAMBDA_AL), "Copper", new Hermes::Hermes1DFunction<double>(LAMBDA_CU), new Hermes::Hermes2DFunction<double>(-VOLUME_HEAT_SRC), "Outer", ALPHA, T_EXTERIOR); // Initialize boundary conditions. CustomDirichletCondition bc_essential(Hermes::vector<std::string>("Bottom", "Inner", "Left"), BDY_A_PARAM, BDY_B_PARAM, BDY_C_PARAM); Hermes::Hermes2D::EssentialBCs<double> bcs(&bc_essential); // Create an H1 space with default shapeset. Hermes::Hermes2D::H1Space<double> space(&mesh, &bcs, P_INIT); int ndof = space.get_num_dofs(); info("ndof = %d", ndof); // Initialize the FE problem. Hermes::Hermes2D::DiscreteProblem<double> dp(&wf, &space); // Initial coefficient vector for the Newton's method. double* coeff_vec = new double[ndof]; memset(coeff_vec, 0, ndof*sizeof(double)); // Initialize the Newton solver. Hermes::Hermes2D::NewtonSolver<double> newton(&dp, matrix_solver_type); // Perform Newton's iteration and translate the resulting coefficient vector into a Solution. Hermes::Hermes2D::Solution<double> sln; if (!newton.solve(coeff_vec)) error("Newton's iteration failed."); else Hermes::Hermes2D::Solution<double>::vector_to_solution(newton.get_sln_vector(), &space, &sln); // VTK output. if (VTK_VISUALIZATION) { // Output solution in VTK format. Hermes::Hermes2D::Views::Linearizer lin(&sln); bool mode_3D = true; lin.save_solution_vtk("sln.vtk", "Temperature", mode_3D); info("Solution in VTK format saved to file %s.", "sln.vtk"); // Output mesh and element orders in VTK format. Hermes::Hermes2D::Views::Orderizer ord; ord.save_orders_vtk(&space, "ord.vtk"); info("Element orders in VTK format saved to file %s.", "ord.vtk"); } // Visualize the solution. if (HERMES_VISUALIZATION) { Hermes::Hermes2D::Views::ScalarView view("Solution", new Hermes::Hermes2D::Views::WinGeom(0, 0, 440, 350)); view.show(&sln, Hermes::Hermes2D::Views::HERMES_EPS_VERYHIGH); Hermes::Hermes2D::Views::View::wait(); } // Clean up. delete [] coeff_vec; return 0; }
void intelfsh_device::write_full(UINT32 address, UINT32 data) { //logerror( "intelflash_write( %u : %08x, %08x )\n", m_flash_mode, address, data ); address += m_bank << 16; switch( m_flash_mode ) { case FM_NORMAL: case FM_READSTATUS: case FM_READID: case FM_READAMDID3: switch( data & 0xff ) { case 0xf0: case 0xff: // reset chip mode m_flash_mode = FM_NORMAL; break; case 0x90: // read ID m_flash_mode = FM_READID; break; case 0x40: case 0x10: // program m_flash_mode = FM_WRITEPART1; break; case 0x50: // clear status reg m_status = 0x80; m_flash_mode = FM_READSTATUS; break; case 0x20: // block erase m_flash_mode = FM_CLEARPART1; break; case 0x60: // set master lock m_flash_mode = FM_SETMASTER; break; case 0x70: // read status m_flash_mode = FM_READSTATUS; break; case 0xaa: // AMD ID select part 1 if( ( address & 0xfff ) == 0x555 ) { m_flash_mode = FM_READAMDID1; } else if( ( address & 0xfff ) == 0xaaa ) { m_flash_mode = FM_READAMDID1; } break; default: logerror( "Unknown flash mode byte %x\n", data & 0xff ); break; } break; case FM_READAMDID1: if( ( address & 0xffff ) == 0x2aa && ( data & 0xff ) == 0x55 ) { m_flash_mode = FM_READAMDID2; } else if( ( address & 0xffff ) == 0x2aaa && ( data & 0xff ) == 0x55 ) { m_flash_mode = FM_READAMDID2; } else if( ( address & 0xfff ) == 0x555 && ( data & 0xff ) == 0x55 ) { m_flash_mode = FM_READAMDID2; } // for AMD 29F080 address bits A11-A19 don't care, for TMS 29F040 address bits A15-A18 don't care else if( ( address & m_addrmask ) == ( 0xaaaa & m_addrmask ) && ( data & 0xff ) == 0x55 && m_addrmask ) { m_flash_mode = FM_READAMDID2; } else { logerror( "unexpected %08x=%02x in FM_READAMDID1\n", address, data & 0xff ); m_flash_mode = FM_NORMAL; } break; case FM_READAMDID2: if( ( address & 0xffff ) == 0x555 && ( data & 0xff ) == 0x90 ) { m_flash_mode = FM_READAMDID3; } else if( ( address & 0xffff ) == 0x5555 && ( data & 0xff ) == 0x90 ) { m_flash_mode = FM_READAMDID3; } else if( ( address & 0xfff ) == 0xaaa && ( data & 0xff ) == 0x90 ) { m_flash_mode = FM_READAMDID3; } else if( ( address & 0xffff ) == 0x555 && ( data & 0xff ) == 0x80 ) { m_flash_mode = FM_ERASEAMD1; } else if( ( address & 0xffff ) == 0x5555 && ( data & 0xff ) == 0x80 ) { m_flash_mode = FM_ERASEAMD1; } else if( ( address & 0xfff ) == 0xaaa && ( data & 0xff ) == 0x80 ) { m_flash_mode = FM_ERASEAMD1; } else if( ( address & 0xffff ) == 0x555 && ( data & 0xff ) == 0xa0 ) { m_flash_mode = FM_BYTEPROGRAM; } else if( ( address & 0xffff ) == 0x5555 && ( data & 0xff ) == 0xa0 ) { if (m_type == FLASH_ATMEL_29C010) { m_flash_mode = FM_WRITEPAGEATMEL; m_byte_count = 0; } else { m_flash_mode = FM_BYTEPROGRAM; } } else if( ( address & 0xfff ) == 0xaaa && ( data & 0xff ) == 0xa0 ) { m_flash_mode = FM_BYTEPROGRAM; } else if( ( address & 0xffff ) == 0x555 && ( data & 0xff ) == 0xf0 ) { m_flash_mode = FM_NORMAL; } else if( ( address & 0xffff ) == 0x5555 && ( data & 0xff ) == 0xf0 ) { m_flash_mode = FM_NORMAL; } else if( ( address & 0xfff ) == 0xaaa && ( data & 0xff ) == 0xf0 ) { m_flash_mode = FM_NORMAL; } else if( ( address & 0xffff ) == 0x5555 && ( data & 0xff ) == 0xb0 && m_maker_id == 0x62 && m_device_id == 0x13 ) { m_flash_mode = FM_BANKSELECT; } // for AMD 29F080 address bits A11-A19 don't care, for TMS 29F040 address bits A15-A18 don't care else if(( address & m_addrmask ) == ( 0x5555 & m_addrmask ) && ( data & 0xff ) == 0x80 && m_addrmask ) { m_flash_mode = FM_ERASEAMD1; } else if(( address & m_addrmask ) == ( 0x5555 & m_addrmask ) && ( data & 0xff ) == 0x90 && m_addrmask ) { m_flash_mode = FM_READAMDID3; } else if(( address & m_addrmask ) == ( 0x5555 & m_addrmask ) && ( data & 0xff ) == 0xa0 && m_addrmask ) { m_flash_mode = FM_BYTEPROGRAM; } else if(( address & m_addrmask ) == ( 0x5555 & m_addrmask ) && ( data & 0xff ) == 0xf0 && m_addrmask ) { m_flash_mode = FM_NORMAL; } else { logerror( "unexpected %08x=%02x in FM_READAMDID2\n", address, data & 0xff ); m_flash_mode = FM_NORMAL; } break; case FM_ERASEAMD1: if( ( address & 0xfff ) == 0x555 && ( data & 0xff ) == 0xaa ) { m_flash_mode = FM_ERASEAMD2; } else if( ( address & 0xfff ) == 0xaaa && ( data & 0xff ) == 0xaa ) { m_flash_mode = FM_ERASEAMD2; } else { logerror( "unexpected %08x=%02x in FM_ERASEAMD1\n", address, data & 0xff ); } break; case FM_ERASEAMD2: if( ( address & 0xffff ) == 0x2aa && ( data & 0xff ) == 0x55 ) { m_flash_mode = FM_ERASEAMD3; } else if( ( address & 0xffff ) == 0x2aaa && ( data & 0xff ) == 0x55 ) { m_flash_mode = FM_ERASEAMD3; } else if( ( address & 0xfff ) == 0x555 && ( data & 0xff ) == 0x55 ) { m_flash_mode = FM_ERASEAMD3; } else { logerror( "unexpected %08x=%02x in FM_ERASEAMD2\n", address, data & 0xff ); } break; case FM_ERASEAMD3: if( (( address & 0xfff ) == 0x555 && ( data & 0xff ) == 0x10 ) || (( address & 0xfff ) == 0xaaa && ( data & 0xff ) == 0x10 ) ) { // chip erase for (offs_t offs = 0; offs < m_size; offs++) space(AS_PROGRAM).write_byte(offs, 0xff); m_status = 1 << 3; m_flash_mode = FM_ERASEAMD4; if (m_sector_is_4k) { m_timer->adjust( attotime::from_seconds( 1 ) ); } else if(m_sector_is_16k) { m_timer->adjust( attotime::from_seconds( 4 ) ); } else { m_timer->adjust( attotime::from_seconds( 16 ) ); } } else if( ( data & 0xff ) == 0x30 ) { // sector erase // clear the 4k/64k block containing the current address to all 0xffs UINT32 base = address * ((m_bits == 16) ? 2 : 1); if (m_sector_is_4k) { for (offs_t offs = 0; offs < 4 * 1024; offs++) space(AS_PROGRAM).write_byte((base & ~0xfff) + offs, 0xff); m_erase_sector = address & ((m_bits == 16) ? ~0x7ff : ~0xfff); m_timer->adjust( attotime::from_msec( 125 ) ); } else if(m_sector_is_16k) { for (offs_t offs = 0; offs < 16 * 1024; offs++) space(AS_PROGRAM).write_byte((base & ~0x3fff) + offs, 0xff); m_erase_sector = address & ((m_bits == 16) ? ~0x1fff : ~0x3fff); m_timer->adjust( attotime::from_msec( 500 ) ); } else if(m_top_boot_sector && address >= (m_size - 64*1024)) { if (address >= (m_size - (16*1024))) { for (offs_t offs = 0; offs < 16 * 1024; offs++) space(AS_PROGRAM).write_byte((base & ~0x3fff) + offs, 0xff); m_erase_sector = address & ((m_bits == 16) ? ~0x1fff : ~0x3fff); m_timer->adjust( attotime::from_msec( 500 ) ); } else if (address >= (m_size - (32*1024))) { for (offs_t offs = 0; offs < 8 * 1024; offs++) space(AS_PROGRAM).write_byte((base & ~0x1fff) + offs, 0xff); m_erase_sector = address & ((m_bits == 16) ? ~0xfff : ~0x1fff); m_timer->adjust( attotime::from_msec( 250 ) ); } else { for (offs_t offs = 0; offs < 32 * 1024; offs++) space(AS_PROGRAM).write_byte((base & ~0x7fff) + offs, 0xff); m_erase_sector = address & ((m_bits == 16) ? ~0x3fff : ~0x7fff); m_timer->adjust( attotime::from_msec( 500 ) ); } } else { for (offs_t offs = 0; offs < 64 * 1024; offs++) space(AS_PROGRAM).write_byte((base & ~0xffff) + offs, 0xff); m_erase_sector = address & ((m_bits == 16) ? ~0x7fff : ~0xffff); m_timer->adjust( attotime::from_seconds( 1 ) ); } m_status = 1 << 3; m_flash_mode = FM_ERASEAMD4; } else { logerror( "unexpected %08x=%02x in FM_ERASEAMD3\n", address, data & 0xff ); } break; case FM_BYTEPROGRAM: switch( m_bits ) { case 8: { space(AS_PROGRAM).write_byte(address, data); } break; default: logerror( "FM_BYTEPROGRAM not supported when m_bits == %d\n", m_bits ); break; } m_flash_mode = FM_NORMAL; break; case FM_WRITEPART1: switch( m_bits ) { case 8: space(AS_PROGRAM).write_byte(address, data); break; case 16: space(AS_PROGRAM).write_word(address * 2, data); break; default: logerror( "FM_WRITEPART1 not supported when m_bits == %d\n", m_bits ); break; } m_status = 0x80; if (m_type == FLASH_SST_28SF040) m_flash_mode = FM_NORMAL; else m_flash_mode = FM_READSTATUS; break; case FM_WRITEPAGEATMEL: switch( m_bits ) { case 8: space(AS_PROGRAM).write_byte(address, data); break; case 16: space(AS_PROGRAM).write_word(address * 2, data); break; default: logerror( "FM_WRITEPAGEATMEL not supported when m_bits == %d\n", m_bits ); break; } m_byte_count++; if (m_byte_count == m_page_size) { m_flash_mode = FM_NORMAL; } break; case FM_CLEARPART1: if( ( data & 0xff ) == 0xd0 ) { if (m_type == FLASH_SST_28SF040) { // clear the 256 bytes block containing the current address to all 0xffs UINT32 base = address * ((m_bits == 16) ? 2 : 1); for (offs_t offs = 0; offs < 256; offs++) space(AS_PROGRAM).write_byte((base & ~0xff) + offs, 0xff); m_timer->adjust( attotime::from_msec( 4 ) ); } else if (m_type == FLASH_INTEL_E28F400B) { // 00000-03fff - 16KB boot block (may be write protected via external pins) // 04000-05fff - 8KB parameter block // 06000-07fff - 8KB parameter block // 08000-1ffff - 96KB main block // 20000-3ffff - 128KB main block // 40000-5ffff - 128KB main block // 60000-7ffff - 128KB main block // erase duration is 0.3s for boot and parameter blocks, and 0.6s for main blocks UINT32 base = (address & 0x3ffff) * 2; int size, duration; if (base < 0x4000) { base = 0; size = 0x4000; duration = 300; } else if (base < 0x8000) { base &= 0x6000; size = 0x2000; duration = 300; } else if (base < 0x20000) { base = 0x8000; size = 0x18000; duration = 600; } else { base &= 0x60000; size = 0x20000; duration = 600; } // clear the block containing the current address to all 0xffffs for (offs_t offs = 0; offs < size / 2; offs += 2) space(AS_PROGRAM).write_word(base | offs, 0xffff); m_timer->adjust( attotime::from_msec( duration ) ); } else { // clear the 64k block containing the current address to all 0xffs UINT32 base = address * ((m_bits == 16) ? 2 : 1); for (offs_t offs = 0; offs < 64 * 1024; offs++) space(AS_PROGRAM).write_byte((base & ~0xffff) + offs, 0xff); m_timer->adjust( attotime::from_seconds( 1 ) ); } m_status = 0x00; m_flash_mode = FM_READSTATUS; break; } else { logerror( "unexpected %02x in FM_CLEARPART1\n", data & 0xff ); } break; case FM_SETMASTER: switch( data & 0xff ) { case 0xf1: m_flash_master_lock = true; break; case 0xd0: m_flash_master_lock = false; break; default: logerror( "unexpected %08x=%02x in FM_SETMASTER:\n", address, data & 0xff ); break; } m_flash_mode = FM_NORMAL; break; case FM_BANKSELECT: m_bank = data & 0xff; m_flash_mode = FM_NORMAL; break; } }
inline void ramdac_device::writebyte(offs_t address, UINT8 data) { space().write_byte(address, data); }
int word(void) { unsigned int c, d, cc; struct argnod *arg = (struct argnod *)locstak(); unsigned char *argp = arg->argval; unsigned char *oldargp; int alpha = 1; unsigned char *pc; wdnum = 0; wdset = 0; while (1) { while (c = nextwc(), space(c)) /* skipc() */ ; if (c == COMCHAR) { while ((c = readwc()) != NL && c != EOF); peekc = c; } else { break; /* out of comment - white space loop */ } } if (!eofmeta(c)) { do { if (c == LITERAL) { oldargp = argp; while ((c = readwc()) && c != LITERAL){ /* * quote each character within * single quotes */ pc = readw(c); if (argp >= brkend) growstak(argp); *argp++='\\'; /* Pick up rest of multibyte character */ if (c == NL) chkpr(); while (c = *pc++) { if (argp >= brkend) growstak(argp); *argp++ = (unsigned char)c; } } if (argp == oldargp) { /* null argument - '' */ /* * Word will be represented by quoted null * in macro.c if necessary */ if (argp >= brkend) growstak(argp); *argp++ = '"'; if (argp >= brkend) growstak(argp); *argp++ = '"'; } } else { if (c == 0) { if (argp >= brkend) growstak(argp); *argp++ = 0; } else { pc = readw(c); while (*pc) { if (argp >= brkend) growstak(argp); *argp++ = *pc++; } } if (c == '\\') { if ((cc = readwc()) == 0) { if (argp >= brkend) growstak(argp); *argp++ = 0; } else { pc = readw(cc); while (*pc) { if (argp >= brkend) growstak(argp); *argp++ = *pc++; } } } if (c == '=') wdset |= alpha; if (!alphanum(c)) alpha = 0; if (qotchar(c)) { d = c; for (;;) { if ((c = nextwc()) == 0) { if (argp >= brkend) growstak(argp); *argp++ = 0; } else { pc = readw(c); while (*pc) { if (argp >= brkend) growstak(argp); *argp++ = *pc++; } } if (c == 0 || c == d) break; if (c == NL) chkpr(); /* * don't interpret quoted * characters */ if (c == '\\') { if ((cc = readwc()) == 0) { if (argp >= brkend) growstak(argp); *argp++ = 0; } else { pc = readw(cc); while (*pc) { if (argp >= brkend) growstak(argp); *argp++ = *pc++; } } } } } } } while ((c = nextwc(), !eofmeta(c))); argp = endstak(argp); if (!letter(arg->argval[0])) wdset = 0; peekn = c | MARK; if (arg->argval[1] == 0 && (d = arg->argval[0], digit(d)) && (c == '>' || c == '<')) { word(); wdnum = d - '0'; }else{ /* check for reserved words */ if (reserv == FALSE || (wdval = syslook(arg->argval, reserved, no_reserved)) == 0) { wdval = 0; } /* set arg for reserved words too */ wdarg = arg; } }else if (dipchar(c)){ if ((d = nextwc()) == c) { wdval = c | SYMREP; if (c == '<') { if ((d = nextwc()) == '-') wdnum |= IOSTRIP; else peekn = d | MARK; } } else { peekn = d | MARK; wdval = c; } } else { if ((wdval = c) == EOF) wdval = EOFSYM; if (iopend && eolchar(c)) { struct ionod *tmp_iopend; tmp_iopend = iopend; iopend = 0; copy(tmp_iopend); } } reserv = FALSE; return (wdval); }
void v60_device::device_start() { m_stall_io = 0; m_irq_line = CLEAR_LINE; m_nmi_line = CLEAR_LINE; for ( int i = 0; i < 68; i++ ) { // Don't set SP (31), PCi (32), PSW (33), SBR (41), SYCW (43), TKCW (44), PIR (45), PSW2 (51) if ( i != 31 && i != 32 && i != 33 && i != 41 && i != 43 && i != 44 && i != 45 && i != 51 ) { m_reg[i] = 0; } } m_flags.CY = 0; m_flags.OV = 0; m_flags.S = 0; m_flags.Z = 0; m_op1 = 0; m_op2 = 0; m_flag1 = 0; m_flag2 = 0; m_instflags = 0; m_lenop1 = 0; m_lenop2 = 0; m_subop = 0; m_bamoffset1 = 0; m_bamoffset2 = 0; m_amflag = 0; m_amout = 0; m_bamoffset = 0; m_amlength1 = 0; m_amlength2 = 0; m_modadd = 0; m_modm = 0; m_modval = 0; m_modval2 = 0; m_modwritevalb = 0; m_modwritevalh = 0; m_modwritevalw = 0; m_moddim = 0; m_program = &space(AS_PROGRAM); m_direct = &m_program->direct(); m_io = &space(AS_IO); save_item(NAME(m_reg)); save_item(NAME(m_irq_line)); save_item(NAME(m_nmi_line)); save_item(NAME(m_PPC)); save_item(NAME(_CY)); save_item(NAME(_OV)); save_item(NAME(_S)); save_item(NAME(_Z)); state_add( V60_R0, "R0", R0).formatstr("%08X"); state_add( V60_R1, "R1", R1).formatstr("%08X"); state_add( V60_R2, "R2", R2).formatstr("%08X"); state_add( V60_R3, "R3", R3).formatstr("%08X"); state_add( V60_R4, "R4", R4).formatstr("%08X"); state_add( V60_R5, "R5", R5).formatstr("%08X"); state_add( V60_R6, "R6", R6).formatstr("%08X"); state_add( V60_R7, "R7", R7).formatstr("%08X"); state_add( V60_R8, "R8", R8).formatstr("%08X"); state_add( V60_R9, "R9", R9).formatstr("%08X"); state_add( V60_R10, "R10", R10).formatstr("%08X"); state_add( V60_R11, "R11", R11).formatstr("%08X"); state_add( V60_R12, "R12", R12).formatstr("%08X"); state_add( V60_R13, "R13", R13).formatstr("%08X"); state_add( V60_R14, "R14", R14).formatstr("%08X"); state_add( V60_R15, "R15", R15).formatstr("%08X"); state_add( V60_R16, "R16", R16).formatstr("%08X"); state_add( V60_R17, "R17", R17).formatstr("%08X"); state_add( V60_R18, "R18", R18).formatstr("%08X"); state_add( V60_R19, "R19", R19).formatstr("%08X"); state_add( V60_R20, "R20", R20).formatstr("%08X"); state_add( V60_R21, "R21", R21).formatstr("%08X"); state_add( V60_R22, "R22", R22).formatstr("%08X"); state_add( V60_R23, "R23", R23).formatstr("%08X"); state_add( V60_R24, "R24", R24).formatstr("%08X"); state_add( V60_R25, "R25", R25).formatstr("%08X"); state_add( V60_R26, "R26", R26).formatstr("%08X"); state_add( V60_R27, "R27", R27).formatstr("%08X"); state_add( V60_R28, "R28", R28).formatstr("%08X"); state_add( V60_AP, "AP", AP).formatstr("%08X"); state_add( V60_FP, "FP", FP).formatstr("%08X"); state_add( V60_SP, "SP", SP).formatstr("%08X"); state_add( V60_PC, "PC", PC).formatstr("%08X"); state_add( V60_PSW, "PSW", m_debugger_temp).callimport().callexport().formatstr("%08X"); state_add( V60_ISP, "ISP", ISP).formatstr("%08X"); state_add( V60_L0SP, "L0SP", L0SP).formatstr("%08X"); state_add( V60_L1SP, "L1SP", L1SP).formatstr("%08X"); state_add( V60_L2SP, "L2SP", L2SP).formatstr("%08X"); state_add( V60_L3SP, "L3SP", L3SP).formatstr("%08X"); state_add( V60_SBR, "SBR", SBR).formatstr("%08X"); state_add( V60_TR, "TR", TR).formatstr("%08X"); state_add( V60_SYCW, "SYCW", SYCW).formatstr("%08X"); state_add( V60_TKCW, "TKCW", TKCW).formatstr("%08X"); state_add( V60_PIR, "PIR", PIR).formatstr("%08X"); state_add( V60_PSW2, "PSW2", PSW2).formatstr("%08X"); state_add( V60_ATBR0, "ATBR0", ATBR0).formatstr("%08X"); state_add( V60_ATLR0, "ATLR0", ATLR0).formatstr("%08X"); state_add( V60_ATBR1, "ATBR1", ATBR1).formatstr("%08X"); state_add( V60_ATLR1, "ATLR1", ATLR1).formatstr("%08X"); state_add( V60_ATBR2, "ATBR2", ATBR2).formatstr("%08X"); state_add( V60_ATLR2, "ATLR2", ATLR2).formatstr("%08X"); state_add( V60_ATBR3, "ATBR3", ATBR3).formatstr("%08X"); state_add( V60_ATLR3, "ATLR3", ATLR3).formatstr("%08X"); state_add( V60_TRMODE, "TRMODE", TRMODE).formatstr("%08X"); state_add( V60_ADTR0, "ADTR0", ADTR0).formatstr("%08X"); state_add( V60_ADTR1, "ADTR1", ADTR1).formatstr("%08X"); state_add( V60_ADTMR0, "ADTMR0", ADTMR0).formatstr("%08X"); state_add( V60_ADTMR1, "ADTMR1", ADTMR1).formatstr("%08X"); state_add( STATE_GENPC, "GENPC", PC).noshow(); state_add( STATE_GENPCBASE, "GENPCBASE", m_PPC ).noshow(); state_add( STATE_GENSP, "GENSP", SP ).noshow(); state_add( STATE_GENFLAGS, "GENFLAGS", m_debugger_temp).noshow(); m_icountptr = &m_icount; }
int main(int argc, char **args) { // Test variable. int success_test = 1; if (argc < 2) error("Not enough parameters."); // Load the mesh. Mesh mesh; H3DReader mloader; if (!mloader.load(args[1], &mesh)) error("Loading mesh file '%s'.", args[1]); // Initialize the space. #if defined NONLIN1 Ord3 order(1, 1, 1); #else Ord3 order(2, 2, 2); #endif H1Space space(&mesh, bc_types, essential_bc_values, order); #if defined NONLIN2 // Do L2 projection of zero function. WeakForm proj_wf; proj_wf.add_matrix_form(biproj_form<double, scalar>, biproj_form<Ord, Ord>, HERMES_SYM); proj_wf.add_vector_form(liproj_form<double, scalar>, liproj_form<Ord, Ord>); bool is_linear = true; DiscreteProblem lp(&proj_wf, &space, is_linear); // Initialize the solver in the case of SOLVER_PETSC or SOLVER_MUMPS. initialize_solution_environment(matrix_solver, argc, args); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix* matrix = create_matrix(matrix_solver); Vector* rhs = create_vector(matrix_solver); Solver* solver_proj = create_linear_solver(matrix_solver, matrix, rhs); // Initialize the preconditioner in the case of SOLVER_AZTECOO. if (matrix_solver == SOLVER_AZTECOO) { ((AztecOOSolver*) solver_proj)->set_solver(iterative_method); ((AztecOOSolver*) solver_proj)->set_precond(preconditioner); // Using default iteration parameters (see solver/aztecoo.h). } // Assemble the linear problem. info("Assembling (ndof: %d).", Space::get_num_dofs(&space)); lp.assemble(matrix, rhs); // Solve the linear system. info("Solving."); if(!solver_proj->solve()); error ("Matrix solver failed.\n"); delete matrix; delete rhs; #endif // Initialize the weak formulation. WeakForm wf(1); wf.add_matrix_form(0, 0, jacobi_form<double, scalar>, jacobi_form<Ord, Ord>, HERMES_UNSYM); wf.add_vector_form(0, resid_form<double, scalar>, resid_form<Ord, Ord>); // Initialize the FE problem. #if defined NONLIN2 is_linear = false; #else bool is_linear = false; #endif DiscreteProblem dp(&wf, &space, is_linear); NoxSolver solver(&dp); #if defined NONLIN2 solver.set_init_sln(solver_proj->get_solution()); delete solver_proj; #endif solver.set_conv_iters(10); info("Solving."); Solution sln(&mesh); if(solver.solve()) Solution::vector_to_solution(solver.get_solution(), &space, &sln); else error ("Matrix solver failed.\n"); Solution ex_sln(&mesh); #ifdef NONLIN1 ex_sln.set_const(100.0); #else ex_sln.set_exact(exact_solution); #endif // Calculate exact error. info("Calculating exact error."); Adapt *adaptivity = new Adapt(&space, HERMES_H1_NORM); bool solutions_for_adapt = false; double err_exact = adaptivity->calc_err_exact(&sln, &ex_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_ABS); if (err_exact > EPS) // Calculated solution is not precise enough. success_test = 0; if (success_test) { info("Success!"); return ERR_SUCCESS; } else { info("Failure!"); return ERR_FAILURE; } }
void SimpleSkeletonGrower::grow_potential(int no_branch) { //overview: maintain a volume to represent the potential energy at each step, //then find the min_element_index and the min_rotate that require the minimum potential energy if(!_surface.is_loaded() || !_root) { printf("SimpleSkeletonGrower::surface error\n"); return; } //find the dimensions of the volume float v_height = -1.0f; osg::Vec3 origin(0.0f, 0.0f, 0.0f); for(unsigned int i=0; i<_surface._surface_pts.size(); i++) { float cur = (_surface._surface_pts[i] - origin).length2(); if(v_height == -1.0f || cur > v_height) v_height = cur; } if(v_height == -1.0f) { printf("SimpleSkeletonGrower::grow_potential():v_height(-1.0f) error\n"); return; } //v_height = sqrt(v_height) * 1.5f; //old v_height = sqrt(v_height) * 2.0f; //new float v_step = v_height / 100.0f; osg::Vec3 corner(-v_height/2.0f, -v_height/2.0f, 0.0f); SimpleVolumeFloat space(v_height, v_height, v_height, v_step, v_step, v_step); float energy_effect = v_step * 18; //negative charges on initial skeleton //bfs std::queue <BDLSkeletonNode *> Queue; Queue.push(_root); while(!Queue.empty()) { BDLSkeletonNode *front = Queue.front(); Queue.pop(); osg::Vec3 cur = Transformer::toVec3(front) - corner; space.add_potential(cur.x(), cur.y(), cur.z(), -3, energy_effect); for(unsigned int i=0; i<front->_children.size(); i++) Queue.push(front->_children[i]); } //positive charges on volume surface for(unsigned int i=0; i<_surface._surface_pts.size(); i++) { osg::Vec3 cur = _surface._surface_pts[i] - corner; space.add_potential(cur.x(), cur.y(), cur.z(), 1, energy_effect*1.5f); } std::vector <LibraryElement> elements = _library._library_element; for(int i=0; i<no_branch; i++) { //pick a tail first //not by minimum generation, but by farest position from surface point BDLSkeletonNode *tail = pick_branch(true); if(!tail) { printf("SimpleSkeletonGrower::grow():converged at %d-th step.\n", i+1); break; } //compute the node-->id dict std::map <BDLSkeletonNode *, int> dict; int id = 0; //bfs on source std::queue <BDLSkeletonNode *> Queue; Queue.push(_root); while(!Queue.empty()) { BDLSkeletonNode *front = Queue.front(); Queue.pop(); dict[front] = id; for(unsigned int j=0; j<front->_children.size(); j++) Queue.push(front->_children[j]); id++; } int tail_id = dict[tail]; //####trial starts#### int min_element_index = -1; int min_rotate = -1; float min_energy = -1.0f; for(unsigned int e=0; e<elements.size(); e++) for(int r=0; r<360; r+=30) { LibraryElement element_trial = elements[e]; if(false) { //copy the original(_root) tree and find the corresponding tail BDLSkeletonNode *copy_root = BDLSkeletonNode::copy_tree(_root); BDLSkeletonNode *copy_tail = NULL; //bfs on target, Queue is now empty at this point id = 0; Queue.push(copy_root); while(!Queue.empty()) { BDLSkeletonNode *front = Queue.front(); Queue.pop(); if(id == tail_id) copy_tail = front; for(unsigned int j=0; j<front->_children.size(); j++) Queue.push(front->_children[j]); id++; } //branch replacement std::vector <BDLSkeletonNode *> subtree_trial = replace_branch(copy_tail, element_trial, r); std::vector <BDLSkeletonNode *> non_pruned_nodes = after_pruned(subtree_trial); //but logically //prune(subtree_trial); //no need to do it actually } std::vector <BDLSkeletonNode *> subtree_trial = replace_branch_unchanged(tail, element_trial, r); std::vector <BDLSkeletonNode *> non_pruned_nodes = after_pruned(subtree_trial); //but logically //compute the potential energy //float energy = non_pruned_nodes.empty() ? 23418715 : compute_potential_energy(subtree_trial, space); float energy = compute_potential_energy(non_pruned_nodes, space); if(energy == 23418715.0f) //to let it grow a little bit randomly even it's completely outside the segmentation { min_element_index = rand()%elements.size(); min_rotate = rand()%360; min_energy = 0.0f; } else if(min_energy == -1.0f || energy > min_energy) //the max in value is the min potential energy for negative charge { min_element_index = e; min_rotate = r; min_energy = energy; } //delete the copied tree //BDLSkeletonNode::delete_this(copy_root); for(unsigned int j=0; j<subtree_trial.size(); j++) delete subtree_trial[j]; } //####trial ends#### //actual replacement if(min_energy != -1.0f) { //printf("tail(%p) min_energy(%f) min_element_index(%d) min_rotate(%d)\n", tail, min_energy, min_element_index, min_rotate); std::vector <BDLSkeletonNode *> subtree = replace_branch(tail, elements[min_element_index], min_rotate); std::vector <BDLSkeletonNode *> update_nodes = after_pruned(subtree); prune(subtree); //prune leniently //update space for(unsigned int j=0; j<update_nodes.size(); j++) { osg::Vec3 cur = Transformer::toVec3(update_nodes[j]) - corner; space.add_potential(cur.x(), cur.y(), cur.z(), -3, energy_effect); //negative charge } } //if(i > no_branch * 0.5f && i < no_branch * 0.75f) if(i > no_branch * 0.75f) { if(!_approaching_done) _close_threshold /= 2.0f; _approaching_done = true; } else if(i >= no_branch * 0.90f) _approaching_done = false; } //aftermath: should be shared for different grow methods //prune strictly on entire tree prune_strictly(_root); if(true) { //printf("backward_grow()\n"); backward_grow(); prune_strictly(_root); } }
static void fplt(FILE *fin) { int c; char s[256]; int xi,yi,x0,y0,x1,y1,r/*,dx,n,i*/; /*int pat[256];*/ openpl(); while((c=getc(fin)) != EOF){ switch(c){ case 'm': xi = getsi(fin); yi = getsi(fin); plot_move(xi,yi); break; case 'l': x0 = getsi(fin); y0 = getsi(fin); x1 = getsi(fin); y1 = getsi(fin); line(x0,y0,x1,y1); break; case 't': getstr(s,fin); label(s); break; case 'e': plot_erase(); break; case 'p': xi = getsi(fin); yi = getsi(fin); point(xi,yi); break; case 'n': xi = getsi(fin); yi = getsi(fin); cont(xi,yi); break; case 's': x0 = getsi(fin); y0 = getsi(fin); x1 = getsi(fin); y1 = getsi(fin); space(x0,y0,x1,y1); break; case 'a': xi = getsi(fin); yi = getsi(fin); x0 = getsi(fin); y0 = getsi(fin); x1 = getsi(fin); y1 = getsi(fin); arc(xi,yi,x0,y0,x1,y1); break; case 'c': xi = getsi(fin); yi = getsi(fin); r = getsi(fin); circle(xi,yi,r); break; case 'f': getstr(s,fin); linemod(s); break; default: fprintf(stderr, "Unknown command %c (%o)\n", c, c); break; } } closepl(); }
void iorm_use(io_desc *iod, mval *pp) { unsigned char c; int4 width, length, blocksize; int4 status; d_rm_struct *rm_ptr; struct RAB *r; struct FAB *f; int p_offset; boolean_t shared_seen = FALSE; error_def(ERR_DEVPARMNEG); error_def(ERR_RMWIDTHPOS); error_def(ERR_RMWIDTHTOOBIG); error_def(ERR_RMNOBIGRECORD); error_def(ERR_RMBIGSHARE); error_def(ERR_MTBLKTOOBIG); error_def(ERR_MTBLKTOOSM); p_offset = 0; rm_ptr = (d_rm_struct *)iod->dev_sp; r = &rm_ptr->r; f = &rm_ptr->f; assert(r->rab$l_fab == f); while (*(pp->str.addr + p_offset) != iop_eol) { assert(*(pp->str.addr + p_offset) < n_iops); switch ((c = *(pp->str.addr + p_offset++))) { case iop_allocation: if (iod->state != dev_open) f->fab$l_alq = *(int4*)(pp->str.addr + p_offset); break; case iop_append: if (iod->state != dev_open) r->rab$l_rop |= RAB$M_EOF; break; case iop_blocksize: if (iod->state != dev_open) { GET_LONG(blocksize, pp->str.addr + p_offset); if (MAX_RMS_ANSI_BLOCK < blocksize) rts_error(VARLSTCNT(1) ERR_MTBLKTOOBIG); else if (MIN_RMS_ANSI_BLOCK > blocksize) rts_error(VARLSTCNT(3) ERR_MTBLKTOOSM, 1, MIN_RMS_ANSI_BLOCK); else f->fab$w_bls = (unsigned short)blocksize; } break; case iop_contiguous: if (iod->state != dev_open) { f->fab$l_fop &= ~FAB$M_CBT; f->fab$l_fop |= FAB$M_CTG; } break; case iop_delete: f->fab$l_fop |= FAB$M_DLT; break; case iop_extension: GET_USHORT(f->fab$w_deq, pp->str.addr + p_offset); break; case iop_exception: iod->error_handler.len = *(pp->str.addr + p_offset); iod->error_handler.addr = pp->str.addr + p_offset + 1; s2pool(&iod->error_handler); break; case iop_fixed: if (iod->state != dev_open) rm_ptr->f.fab$b_rfm = rm_ptr->b_rfm = FAB$C_FIX; break; case iop_length: GET_LONG(length, pp->str.addr + p_offset); if (length < 0) rts_error(VARLSTCNT(1) ERR_DEVPARMNEG); iod->length = length; break; case iop_newversion: if (iod->state != dev_open) { f->fab$l_fop |= FAB$M_MXV; f->fab$l_fop &= ~(FAB$M_CIF | FAB$M_SUP); } break; case iop_nosequential: break; case iop_s_protection: rm_ptr->promask &= ~(0x0F << XAB$V_SYS); rm_ptr->promask |= ((~(unsigned char)*(pp->str.addr + p_offset) & 0x0000000F) << XAB$V_SYS); break; case iop_w_protection: rm_ptr->promask &= ~(0x0F << XAB$V_WLD); rm_ptr->promask |= ((~(unsigned char)*(pp->str.addr + p_offset) & 0x0000000F) << XAB$V_WLD); break; case iop_g_protection: rm_ptr->promask &= ~(0x0F << XAB$V_GRP); rm_ptr->promask |= ((~(unsigned char)*(pp->str.addr + p_offset) & 0x0000000F) << XAB$V_GRP); break; case iop_o_protection: rm_ptr->promask &= ~(0x0F << XAB$V_OWN); rm_ptr->promask |= ((~(unsigned char)*(pp->str.addr + p_offset) & 0x0000000F) << XAB$V_OWN); break; case iop_readonly: if (iod->state != dev_open) f->fab$b_fac = FAB$M_GET; break; case iop_noreadonly: if (iod->state != dev_open) f->fab$b_fac = FAB$M_GET | FAB$M_PUT | FAB$M_TRN; break; case iop_recordsize: if (iod->state != dev_open) { GET_LONG(width, pp->str.addr + p_offset); if (width <= 0) rts_error(VARLSTCNT(1) ERR_RMWIDTHPOS); iod->width = width; if (MAX_RMS_RECORDSIZE >= width) r->rab$w_usz = f->fab$w_mrs = (unsigned short)width; else if (MAX_STRLEN < width) rts_error(VARLSTCNT(1) ERR_RMWIDTHTOOBIG); else if (!rm_ptr->largerecord) rts_error(VARLSTCNT(1) ERR_RMNOBIGRECORD); rm_ptr->l_usz = rm_ptr->l_mrs = width; } break; case iop_shared: if (iod->state != dev_open) shared_seen = TRUE; break; case iop_spool: f->fab$l_fop |= FAB$M_SPL; break; case iop_submit: f->fab$l_fop |= FAB$M_SCF; break; case iop_rfa: break; case iop_space: if (iod->state == dev_open && f->fab$l_dev & DEV$M_SQD) { GET_LONG(r->rab$l_bkt, pp->str.addr + p_offset); if ((status = sys$space(r, 0, 0)) != RMS$_NORMAL) rts_error(VARLSTCNT(1) status); r->rab$l_bkt = 0; } break; case iop_uic: { unsigned char *ch, ct, *end; uic_struct uic; struct XABPRO *xabpro; ch = pp->str.addr + p_offset; ct = *ch++; end = ch + ct; uic.grp = uic.mem = 0; xabpro = malloc(SIZEOF(struct XABPRO)); *xabpro = cc$rms_xabpro; /* g,m are octal - no matter currently since iorm_open overwrites fab xab */ while (*ch != ',' && ch < end) uic.grp = (10 * uic.grp) + (*ch++ - '0'); if (*ch == ',') { while (++ch < end) uic.mem = (10 * uic.mem) + (*ch - '0'); } xabpro->xab$l_uic = *((int4 *)&uic); f->fab$l_xab = xabpro; break; } case iop_width: if (iod->state == dev_open) { GET_LONG(width, pp->str.addr + p_offset); if (width <= 0) rts_error(VARLSTCNT(1) ERR_RMWIDTHPOS); else if (width <= rm_ptr->l_mrs) { iorm_flush(iod); rm_ptr->l_usz = iod->width = width; if (!rm_ptr->largerecord) r->rab$w_usz = (short)width; iod->wrap = TRUE; } } break; case iop_wrap: iod->wrap = TRUE; break; case iop_nowrap: iod->wrap = FALSE; break; case iop_convert: r->rab$l_rop |= RAB$M_CVT; break; case iop_rewind: if (iod->state == dev_open && rm_ptr->f.fab$l_dev & DEV$M_FOD) { if (iod->dollar.zeof && rm_ptr->outbuf_pos > rm_ptr->outbuf) iorm_wteol(1, iod); sys$rewind(r); iod->dollar.zeof = FALSE; iod->dollar.y = 0; iod->dollar.x = 0; rm_ptr->outbuf_pos = rm_ptr->outbuf; rm_ptr->r.rab$l_ctx = FAB$M_GET; } break; case iop_truncate: r->rab$l_rop |= RAB$M_TPT; break; case iop_notruncate: r->rab$l_rop &= ~RAB$M_TPT; break; case iop_bigrecord: if (iod->state != dev_open) rm_ptr->largerecord = TRUE; break; case iop_nobigrecord: if (iod->state != dev_open) { if (MAX_RMS_RECORDSIZE < rm_ptr->l_mrs) rts_error(ERR_RMNOBIGRECORD); rm_ptr->largerecord = FALSE; } break; case iop_rfm: break; default: break; } p_offset += ((IOP_VAR_SIZE == io_params_size[c]) ? (unsigned char)*(pp->str.addr + p_offset) + 1 : io_params_size[c]); } if (shared_seen) { f->fab$b_shr = FAB$M_SHRGET; if (rm_ptr->largerecord) { if (f->fab$b_fac & FAB$M_PUT) { rts_error(VARLSTCNT(1) ERR_RMBIGSHARE); } } else if ((f->fab$b_fac & FAB$M_PUT) == FALSE) f->fab$b_shr |= FAB$M_SHRPUT; } }/* eor */
int main(int argc, char* argv[]) { // Load the mesh. Mesh mesh; H2DReader mloader; mloader.load("domain.mesh", &mesh); mesh.refine_all_elements(); // Enter boundary markers. BCTypes bc_types; bc_types.add_bc_dirichlet(Hermes::vector<int>(BDY_BOTTOM, BDY_OUTER, BDY_LEFT, BDY_INNER)); // Enter Dirichlet boudnary values. BCValues bc_values; bc_values.add_function(Hermes::vector<int>(BDY_BOTTOM, BDY_OUTER, BDY_LEFT, BDY_INNER), essential_bc_values); // Create an H1 space with default shapeset. H1Space space(&mesh, &bc_types, &bc_values, P_INIT); int ndof = Space::get_num_dofs(&space); info("ndof = %d", ndof); // Initialize the weak formulation. WeakForm wf; wf.add_matrix_form(callback(bilinear_form)); wf.add_vector_form(callback(linear_form)); // Testing n_dof and correctness of solution vector // for p_init = 1, 2, ..., 10 int success = 1; Solution sln; for (int p_init = 1; p_init <= 10; p_init++) { printf("********* p_init = %d *********\n", p_init); space.set_uniform_order(p_init); // Initialize the FE problem. bool is_linear = true; DiscreteProblem dp(&wf, &space, is_linear); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix* matrix = create_matrix(matrix_solver); Vector* rhs = create_vector(matrix_solver); Solver* solver = create_linear_solver(matrix_solver, matrix, rhs); // Initialize the solution. Solution sln; // Assemble the stiffness matrix and right-hand side vector. info("Assembling the stiffness matrix and right-hand side vector."); bool rhsonly = false; dp.assemble(matrix, rhs, rhsonly); // Solve the linear system and if successful, obtain the solution. info("Solving the matrix problem."); if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &sln); else error ("Matrix solver failed.\n"); int ndof = Space::get_num_dofs(&space); printf("ndof = %d\n", ndof); double sum = 0; for (int i=0; i < ndof; i++) sum += solver->get_solution()[i]; printf("coefficient sum = %g\n", sum); // Actual test. The values of 'sum' depend on the // current shapeset. If you change the shapeset, // you need to correct these numbers. if (p_init == 1 && fabs(sum - 1.7251) > 1e-3) success = 0; if (p_init == 2 && fabs(sum - 3.79195) > 1e-3) success = 0; if (p_init == 3 && fabs(sum - 3.80206) > 1e-3) success = 0; if (p_init == 4 && fabs(sum - 3.80156) > 1e-3) success = 0; if (p_init == 5 && fabs(sum - 3.80155) > 1e-3) success = 0; if (p_init == 6 && fabs(sum - 3.80154) > 1e-3) success = 0; if (p_init == 7 && fabs(sum - 3.80154) > 1e-3) success = 0; if (p_init == 8 && fabs(sum - 3.80153) > 1e-3) success = 0; if (p_init == 9 && fabs(sum - 3.80152) > 1e-3) success = 0; if (p_init == 10 && fabs(sum - 3.80152) > 1e-3) success = 0; } if (success == 1) { printf("Success!\n"); return ERR_SUCCESS; } else { printf("Failure!\n"); return ERR_FAILURE; } }
inline void hd61830_device::writebyte(offs_t address, UINT8 data) { space()->write_byte(address, data); }
int main(int argc, char* argv[]) { // Choose a Butcher's table or define your own. ButcherTable bt(butcher_table_type); if (bt.is_explicit()) Hermes::Mixins::Loggable::Static::info("Using a %d-stage explicit R-K method.", bt.get_size()); if (bt.is_diagonally_implicit()) Hermes::Mixins::Loggable::Static::info("Using a %d-stage diagonally implicit R-K method.", bt.get_size()); if (bt.is_fully_implicit()) Hermes::Mixins::Loggable::Static::info("Using a %d-stage fully implicit R-K method.", bt.get_size()); // Load the mesh. Mesh mesh; MeshReaderH2D mloader; mloader.load("square.mesh", &mesh); // Initial mesh refinements. for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(); // Convert initial condition into a Solution<std::complex<double> >. CustomInitialCondition psi_time_prev(&mesh); Solution<std::complex<double> > psi_time_new(&mesh); // Initialize the weak formulation. double current_time = 0; CustomWeakFormGPRK wf(h, m, g, omega); // Initialize boundary conditions. DefaultEssentialBCConst<std::complex<double> > bc_essential("Bdy", 0.0); EssentialBCs<std::complex<double> > bcs(&bc_essential); // Create an H1 space with default shapeset. H1Space<std::complex<double> > space(&mesh, &bcs, P_INIT); int ndof = space.get_num_dofs(); Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof); // Initialize the FE problem. DiscreteProblem<std::complex<double> > dp(&wf, &space); // Initialize views. ScalarView sview_real("Solution - real part", new WinGeom(0, 0, 600, 500)); ScalarView sview_imag("Solution - imaginary part", new WinGeom(610, 0, 600, 500)); sview_real.fix_scale_width(80); sview_imag.fix_scale_width(80); // Initialize Runge-Kutta time stepping. RungeKutta<std::complex<double> > runge_kutta(&wf, &space, &bt); // Time stepping: int ts = 1; int nstep = (int)(T_FINAL/time_step + 0.5); for(int ts = 1; ts <= nstep; ts++) { // Perform one Runge-Kutta time step according to the selected Butcher's table. Hermes::Mixins::Loggable::Static::info("Runge-Kutta time step (t = %g s, time step = %g s, stages: %d).", current_time, time_step, bt.get_size()); try { runge_kutta.setTime(current_time); runge_kutta.setTimeStep(time_step); runge_kutta.rk_time_step_newton(&psi_time_prev, &psi_time_new); } catch(Exceptions::Exception& e) { e.printMsg(); throw Hermes::Exceptions::Exception("Runge-Kutta time step failed"); } // Show the new time level solution. char title[100]; sprintf(title, "Solution - real part, Time %3.2f s", current_time); sview_real.set_title(title); sprintf(title, "Solution - imaginary part, Time %3.2f s", current_time); sview_imag.set_title(title); RealFilter real(&psi_time_new); ImagFilter imag(&psi_time_new); sview_real.show(&real); sview_imag.show(&imag); // Copy solution for the new time step. psi_time_prev.copy(&psi_time_new); // Increase current time and time step counter. current_time += time_step; ts++; } // Wait for the view to be closed. View::wait(); return 0; }
OptionalModelObject ReverseTranslator::translateZone( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::Zone ){ LOG(Error, "WorkspaceObject is not IddObjectType: Zone"); return boost::none; } // this function creates a space and a thermal zone, it returns the space. If you want the // thermal zone you can reliably dereference the result of space.thermalZone(). openstudio::model::ThermalZone thermalZone( m_model ); openstudio::model::Space space( m_model ); space.setThermalZone(thermalZone); boost::optional<std::string> idfZoneName; OptionalString s = workspaceObject.name(); if(s){ space.setName(*s); thermalZone.setName(*s + " Thermal Zone"); idfZoneName = *s; } OptionalDouble d = workspaceObject.getDouble(ZoneFields::DirectionofRelativeNorth); if(d){ space.setDirectionofRelativeNorth(*d); } d=workspaceObject.getDouble(ZoneFields::XOrigin); if(d){ space.setXOrigin(*d); } d=workspaceObject.getDouble(ZoneFields::YOrigin); if(d){ space.setYOrigin(*d); } d=workspaceObject.getDouble(ZoneFields::ZOrigin); if(d){ space.setZOrigin(*d); } OptionalInt i = workspaceObject.getInt(ZoneFields::Type); if(i){ // no-op } i = workspaceObject.getInt(ZoneFields::Multiplier); if(i){ thermalZone.setMultiplier(*i); } d = workspaceObject.getDouble(ZoneFields::CeilingHeight); if(d){ thermalZone.setCeilingHeight(*d); } d=workspaceObject.getDouble(ZoneFields::Volume); if(d){ thermalZone.setVolume(*d); } s = workspaceObject.getString(ZoneFields::ZoneInsideConvectionAlgorithm); if(s){ thermalZone.setZoneInsideConvectionAlgorithm(*s); } s = workspaceObject.getString(ZoneFields::ZoneOutsideConvectionAlgorithm); if(s){ thermalZone.setZoneOutsideConvectionAlgorithm(*s); } s = workspaceObject.getString(ZoneFields::PartofTotalFloorArea); if(s){ if(istringEqual("Yes",*s)) { space.setPartofTotalFloorArea(true); } else { space.setPartofTotalFloorArea(false); } } // Thermostat // If the zone in the idf file does not have a name, there is no use in even trying to find a thermostat if( idfZoneName ) { Workspace workspace = workspaceObject.workspace(); std::vector<WorkspaceObject> _zoneControlThermostats; _zoneControlThermostats = workspace.getObjectsByType(IddObjectType::ZoneControl_Thermostat); for( const auto & _zoneControlThermostat : _zoneControlThermostats ) { if( boost::optional<std::string> zoneName = _zoneControlThermostat.getString( ZoneControl_ThermostatFields::ZoneorZoneListName ) ) { bool zoneControlThermostatfound = false; if( zoneName.get() == idfZoneName ) { zoneControlThermostatfound = true; } else if( boost::optional<WorkspaceObject> _zoneList = workspace.getObjectByTypeAndName(IddObjectType::ZoneList,zoneName.get()) ) { std::vector<IdfExtensibleGroup> zoneListGroup = _zoneList->extensibleGroups(); for( const auto & zoneListElem : zoneListGroup ) { boost::optional<std::string> zoneListZoneName = zoneListElem.getString(ZoneListExtensibleFields::ZoneName); if( zoneListZoneName ) { if( zoneListZoneName.get() == idfZoneName ) { zoneControlThermostatfound = true; } break; } } } if( zoneControlThermostatfound ) { std::vector<IdfExtensibleGroup> extensibleGroups = _zoneControlThermostat.extensibleGroups(); for( const auto & extensibleGroup : extensibleGroups ) { boost::optional<std::string> thermostatType = extensibleGroup.getString(ZoneControl_ThermostatExtensibleFields::ControlObjectType); boost::optional<std::string> thermostatName = extensibleGroup.getString(ZoneControl_ThermostatExtensibleFields::ControlName); if( thermostatName && thermostatType ) { boost::optional<WorkspaceObject> _thermostat = workspace.getObjectByTypeAndName(IddObjectType(thermostatType.get()),thermostatName.get()); if( _thermostat ) { boost::optional<ModelObject> thermostat = translateAndMapWorkspaceObject(_thermostat.get()); if( thermostat ) { if( boost::optional<ThermostatSetpointDualSetpoint> thermostatSetpointDualSetpoint = thermostat->optionalCast<ThermostatSetpointDualSetpoint>() ) { thermalZone.setThermostatSetpointDualSetpoint(thermostatSetpointDualSetpoint.get()); } } } } } break; } } } } // Zone Equipment /* if( idfZoneName ) { std::vector<WorkspaceObject> zoneHVACEquipmentConnections; zoneHVACEquipmentConnections = workspaceObject.workspace().getObjectsByType(IddObjectType::ZoneHVAC_EquipmentConnections); for( std::vector<WorkspaceObject>::iterator it = zoneHVACEquipmentConnections.begin(); it != zoneHVACEquipmentConnections.end(); it++ ) { s = it->getString(ZoneHVAC_EquipmentConnectionsFields::ZoneName); if( s && istringEqual(s.get(),idfZoneName.get()) ) { boost::optional<WorkspaceObject> _zoneEquipmentList = it->getTarget(ZoneHVAC_EquipmentConnectionsFields::ZoneConditioningEquipmentListName); if( _zoneEquipmentList ) { translateAndMapWorkspaceObject(_zoneEquipmentList.get()); } break; } } } */ return space; }
int main(int argc, char **args) { // Test variable. int success_test = 1; // Initialize the solver in the case of SOLVER_PETSC or SOLVER_MUMPS. initialize_solution_environment(matrix_solver, argc, args); for (int i = 0; i < 48; i++) { for (int j = 0; j < 48; j++) { info("Config: %d, %d ", i, j); Mesh mesh; for (unsigned int k = 0; k < countof(vtcs); k++) mesh.add_vertex(vtcs[k].x, vtcs[k].y, vtcs[k].z); unsigned int h1[] = { hexs[0][i][0] + 1, hexs[0][i][1] + 1, hexs[0][i][2] + 1, hexs[0][i][3] + 1, hexs[0][i][4] + 1, hexs[0][i][5] + 1, hexs[0][i][6] + 1, hexs[0][i][7] + 1 }; mesh.add_hex(h1); unsigned int h2[] = { hexs[1][j][0] + 1, hexs[1][j][1] + 1, hexs[1][j][2] + 1, hexs[1][j][3] + 1, hexs[1][j][4] + 1, hexs[1][j][5] + 1, hexs[1][j][6] + 1, hexs[1][j][7] + 1 }; mesh.add_hex(h2); // bc for (unsigned int k = 0; k < countof(bnd); k++) { unsigned int facet_idxs[Quad::NUM_VERTICES] = { bnd[k][0] + 1, bnd[k][1] + 1, bnd[k][2] + 1, bnd[k][3] + 1 }; mesh.add_quad_boundary(facet_idxs, bnd[k][4]); } mesh.ugh(); // Initialize the space. H1Space space(&mesh, bc_types, essential_bc_values); #ifdef XM_YN_ZO Ord3 ord(4, 4, 4); #elif defined XM_YN_ZO_2 Ord3 ord(4, 4, 4); #elif defined X2_Y2_Z2 Ord3 ord(2, 2, 2); #endif space.set_uniform_order(ord); // Initialize the weak formulation. WeakForm wf; #ifdef DIRICHLET wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, HERMES_SYM); wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>); #elif defined NEWTON wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, HERMES_SYM); wf.add_matrix_form_surf(bilinear_form_surf<double, scalar>, bilinear_form_surf<Ord, Ord>); wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>); wf.add_vector_form_surf(linear_form_surf<double, scalar>, linear_form_surf<Ord, Ord>); #endif // Initialize the FE problem. bool is_linear = true; DiscreteProblem dp(&wf, &space, is_linear); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix* matrix = create_matrix(matrix_solver); Vector* rhs = create_vector(matrix_solver); Solver* solver = create_linear_solver(matrix_solver, matrix, rhs); // Initialize the preconditioner in the case of SOLVER_AZTECOO. if (matrix_solver == SOLVER_AZTECOO) { ((AztecOOSolver*) solver)->set_solver(iterative_method); ((AztecOOSolver*) solver)->set_precond(preconditioner); // Using default iteration parameters (see solver/aztecoo.h). } // Assemble the linear problem. info("Assembling (ndof: %d).", Space::get_num_dofs(&space)); dp.assemble(matrix, rhs); // Solve the linear system. If successful, obtain the solution. info("Solving."); Solution sln(space.get_mesh()); if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &sln); else error ("Matrix solver failed.\n"); ExactSolution ex_sln(&mesh, exact_solution); // Calculate exact error. info("Calculating exact error."); Adapt *adaptivity = new Adapt(&space, HERMES_H1_NORM); bool solutions_for_adapt = false; double err_exact = adaptivity->calc_err_exact(&sln, &ex_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_ABS); if (err_exact > EPS) { // Calculated solution is not precise enough. success_test = 0; info("failed, error:%g", err_exact); } else info("passed"); // Clean up. delete matrix; delete rhs; delete solver; delete adaptivity; } } // Properly terminate the solver in the case of SOLVER_PETSC or SOLVER_MUMPS. finalize_solution_environment(matrix_solver); if (success_test) { info("Success!"); return ERR_SUCCESS; } else { info("Failure!"); return ERR_FAILURE; } }
int main(int argc, char **args) { // Test variable. int success_test = 1; if (argc < 5) error("Not enough parameters"); // Load the mesh. Mesh mesh; H3DReader mloader; if (!mloader.load(args[1], &mesh)) error("Loading mesh file '%s'\n", args[1]); // Initialize the space according to the // command-line parameters passed. sscanf(args[2], "%d", &m); sscanf(args[3], "%d", &n); sscanf(args[4], "%d", &o); int mx = maxn(4, m, n, o, 4); Ord3 order(mx, mx, mx); H1Space space(&mesh, bc_types, NULL, order); // Initialize the weak formulation. WeakForm wf; wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, HERMES_SYM); wf.add_matrix_form_surf(bilinear_form_surf<double, scalar>, bilinear_form_surf<Ord, Ord>); wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>); wf.add_vector_form_surf(linear_form_surf<double, scalar>, linear_form_surf<Ord, Ord>); // Initialize the FE problem. bool is_linear = true; DiscreteProblem dp(&wf, &space, is_linear); // Initialize the solver in the case of SOLVER_PETSC or SOLVER_MUMPS. initialize_solution_environment(matrix_solver, argc, args); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix* matrix = create_matrix(matrix_solver); Vector* rhs = create_vector(matrix_solver); Solver* solver = create_linear_solver(matrix_solver, matrix, rhs); // Initialize the preconditioner in the case of SOLVER_AZTECOO. if (matrix_solver == SOLVER_AZTECOO) { ((AztecOOSolver*) solver)->set_solver(iterative_method); ((AztecOOSolver*) solver)->set_precond(preconditioner); // Using default iteration parameters (see solver/aztecoo.h). } // Assemble the linear problem. info("Assembling (ndof: %d).", Space::get_num_dofs(&space)); dp.assemble(matrix, rhs); // Solve the linear system. If successful, obtain the solution. info("Solving."); Solution sln(&mesh); if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &sln); else error ("Matrix solver failed.\n"); ExactSolution ex_sln(&mesh, exact_solution); // Calculate exact error. info("Calculating exact error."); Adapt *adaptivity = new Adapt(&space, HERMES_H1_NORM); bool solutions_for_adapt = false; double err_exact = adaptivity->calc_err_exact(&sln, &ex_sln, solutions_for_adapt, HERMES_TOTAL_ERROR_ABS); if (err_exact > EPS) // Calculated solution is not precise enough. success_test = 0; // Clean up. delete matrix; delete rhs; delete solver; delete adaptivity; // Properly terminate the solver in the case of SOLVER_PETSC or SOLVER_MUMPS. finalize_solution_environment(matrix_solver); if (success_test) { info("Success!"); return ERR_SUCCESS; } else { info("Failure!"); return ERR_FAILURE; } }
_FGS(CODE_PROT_OFF); /* Code protect disabled */ /* Extern definitions */ extern fractcomplex sigCmpx[FFT_BLOCK_LENGTH] /* Typically, the input signal to an FFT */ __attribute__ ((section (".ydata, data, ymemory"), /* routine is a complex array containing samples */ aligned (FFT_BLOCK_LENGTH * 2 *2))); /* of an input signal. For this example, */ /* we will provide the input signal in an */ /* array declared in Y-data space. */ /* Global Definitions */ #ifndef FFTTWIDCOEFFS_IN_PROGMEM fractcomplex twiddleFactors[FFT_BLOCK_LENGTH/2] /* Declare Twiddle Factor array in X-space*/ __attribute__ ((section (".xbss, bss, xmemory"), aligned (FFT_BLOCK_LENGTH*2))); #else extern const fractcomplex twiddleFactors[FFT_BLOCK_LENGTH/2] /* Twiddle Factor array in Program memory */ __attribute__ ((space(auto_psv), aligned (FFT_BLOCK_LENGTH*2))); #endif int peakFrequencyBin = 0; /* Declare post-FFT variables to compute the */ unsigned long peakFrequency = 0; /* frequency of the largest spectral component */ int main(void) { int i = 0; fractional *p_real = &sigCmpx[0].real ; fractcomplex *p_cmpx = &sigCmpx[0] ; #ifndef FFTTWIDCOEFFS_IN_PROGMEM /* Generate TwiddleFactor Coefficients */ TwidFactorInit (LOG2_BLOCK_LENGTH, &twiddleFactors[0], 0); /* We need to do this only once at start-up */ #endif
int main(int argc, char **argv) { int res = ERR_SUCCESS; #ifdef WITH_PETSC PetscInitialize(&argc, &argv, (char *) PETSC_NULL, PETSC_NULL); #endif set_verbose(false); if (argc < 3) error("Not enough parameters"); printf("* Loading mesh '%s'\n", argv[1]); Mesh mesh; H3DReader mesh_loader; if (!mesh_loader.load(argv[1], &mesh)) error("Loading mesh file '%s'\n", argv[1]); int o; sscanf(argv[2], "%d", &o); printf(" - Setting uniform order to %d\n", o); printf("* Setting the space up\n"); H1Space space(&mesh, bc_types, essential_bc_values, o); int ndofs = space.assign_dofs(); printf(" - Number of DOFs: %d\n", ndofs); printf("* Calculating a solution\n"); #if defined WITH_UMFPACK UMFPackMatrix mat; UMFPackVector rhs; UMFPackLinearSolver solver(&mat, &rhs); #elif defined WITH_PARDISO PardisoMatrix mat; PardisoVector rhs; PardisoLinearSolver solver(&mat, &rhs); #elif defined WITH_PETSC PetscMatrix mat; PetscVector rhs; PetscLinearSolver solver(&mat, &rhs); #elif defined WITH_MUMPS MumpsMatrix mat; MumpsVector rhs; MumpsSolver solver(&mat, &rhs); #endif WeakForm wf; wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, SYM); wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>); DiscreteProblem dp(&wf, &space, true); // assemble stiffness matrix Timer assemble_timer("Assembling stiffness matrix"); assemble_timer.start(); dp.assemble(&mat, &rhs); assemble_timer.stop(); // solve the stiffness matrix Timer solve_timer("Solving stiffness matrix"); solve_timer.start(); bool solved = solver.solve(); solve_timer.stop(); // output the measured values printf("%s: %s (%lf secs)\n", assemble_timer.get_name(), assemble_timer.get_human_time(), assemble_timer.get_seconds()); printf("%s: %s (%lf secs)\n", solve_timer.get_name(), solve_timer.get_human_time(), solve_timer.get_seconds()); if (solved) { Solution sln(&mesh); sln.set_coeff_vector(&space, solver.get_solution()); ExactSolution ex_sln(&mesh, exact_solution); // norm double h1_sln_norm = h1_norm(&sln); double h1_err_norm = h1_error(&sln, &ex_sln); printf(" - H1 solution norm: % le\n", h1_sln_norm); printf(" - H1 error norm: % le\n", h1_err_norm); double l2_sln_norm = l2_norm(&sln); double l2_err_norm = l2_error(&sln, &ex_sln); printf(" - L2 solution norm: % le\n", l2_sln_norm); printf(" - L2 error norm: % le\n", l2_err_norm); if (h1_err_norm > EPS || l2_err_norm > EPS) { // calculated solution is not enough precise res = ERR_FAILURE; } #if 0 //def OUTPUT_DIR // output const char *of_name = OUTPUT_DIR "/solution.pos"; FILE *ofile = fopen(of_name, "w"); if (ofile != NULL) { ExactSolution ex_sln(&mesh, exact_solution); DiffFilter eh(&sln, &ex_sln); // DiffFilter eh_dx(&mesh, &sln, &ex_sln, FN_DX, FN_DX); // DiffFilter eh_dy(&mesh, &sln, &ex_sln, FN_DY, FN_DY); // DiffFilter eh_dz(&mesh, &sln, &ex_sln, FN_DZ, FN_DZ); GmshOutputEngine output(ofile); output.out(&sln, "Uh"); // output.out(&sln, "Uh dx", FN_DX_0); // output.out(&sln, "Uh dy", FN_DY_0); // output.out(&sln, "Uh dz", FN_DZ_0); output.out(&eh, "Eh"); // output.out(&eh_dx, "Eh dx"); // output.out(&eh_dy, "Eh dy"); // output.out(&eh_dz, "Eh dz"); output.out(&ex_sln, "U"); // output.out(&ex_sln, "U dx", FN_DX_0); // output.out(&ex_sln, "U dy", FN_DY_0); // output.out(&ex_sln, "U dz", FN_DZ_0); fclose(ofile); } else { warning("Can not open '%s' for writing.", of_name); } #endif } #ifdef WITH_PETSC mat.free(); rhs.free(); PetscFinalize(); #endif TRACE_END; return res; }
int main(int argc, char **args) { int res = ERR_SUCCESS; #ifdef WITH_PETSC PetscInitialize(&argc, &args, (char *) PETSC_NULL, PETSC_NULL); #endif set_verbose(false); if (argc < 5) error("Not enough parameters"); sscanf(args[2], "%d", &m); sscanf(args[3], "%d", &n); sscanf(args[4], "%d", &o); printf("* Loading mesh '%s'\n", args[1]); Mesh mesh; H3DReader mesh_loader; if (!mesh_loader.load(args[1], &mesh)) error("Loading mesh file '%s'\n", args[1]); H1ShapesetLobattoHex shapeset; printf("* Setting the space up\n"); int mx = maxn(4, m, n, o, 4); Ord3 order(mx, mx, mx); // Ord3 order(1, 1, 1); printf(" - Setting uniform order to (%d, %d, %d)\n", mx, mx, mx); H1Space space(&mesh, bc_types, NULL, order); int ndofs = space.assign_dofs(); printf(" - Number of DOFs: %d\n", ndofs); printf("* Calculating a solution\n"); #if defined WITH_UMFPACK UMFPackMatrix mat; UMFPackVector rhs; UMFPackLinearSolver solver(&mat, &rhs); #elif defined WITH_PARDISO PardisoMatrix mat; PardisoVector rhs; PardisoLinearSolver solver(&mat, &rhs); #elif defined WITH_PETSC PetscMatrix mat; PetscVector rhs; PetscLinearSolver solver(&mat, &rhs); #elif defined WITH_MUMPS MumpsMatrix mat; MumpsVector rhs; MumpsSolver solver(&mat, &rhs); #endif WeakForm wf; wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<Ord, Ord>, SYM); wf.add_matrix_form_surf(bilinear_form_surf<double, scalar>, bilinear_form_surf<Ord, Ord>); wf.add_vector_form(linear_form<double, scalar>, linear_form<Ord, Ord>); wf.add_vector_form_surf(linear_form_surf<double, scalar>, linear_form_surf<Ord, Ord>); DiscreteProblem dp(&wf, &space, true); // assemble stiffness matrix printf(" - assembling... "); fflush(stdout); Timer assemble_timer; assemble_timer.start(); dp.assemble(&mat, &rhs); assemble_timer.stop(); printf("%s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds()); // solve the stiffness matrix printf(" - solving... "); fflush(stdout); Timer solve_timer; solve_timer.start(); bool solved = solver.solve(); solve_timer.stop(); printf("%s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds()); // mat.dump(stdout, "a"); // rhs.dump(stdout, "b"); if (solved) { Solution sln(&mesh); sln.set_coeff_vector(&space, solver.get_solution()); printf("* Solution:\n"); // double *s = solver.get_solution(); // for (int i = 1; i <= ndofs; i++) { // printf(" x[% 3d] = % lf\n", i, s[i]); // } // norm ExactSolution ex_sln(&mesh, exact_solution); double h1_sln_norm = h1_norm(&sln); double h1_err_norm = h1_error(&sln, &ex_sln); printf(" - H1 solution norm: % le\n", h1_sln_norm); printf(" - H1 error norm: % le\n", h1_err_norm); double l2_sln_norm = l2_norm(&sln); double l2_err_norm = l2_error(&sln, &ex_sln); printf(" - L2 solution norm: % le\n", l2_sln_norm); printf(" - L2 error norm: % le\n", l2_err_norm); if (h1_err_norm > EPS || l2_err_norm > EPS) { // calculated solution is not enough precise res = ERR_FAILURE; } #ifdef OUTPUT_DIR printf("* Output\n"); // output const char *of_name = OUTPUT_DIR "/solution.pos"; FILE *ofile = fopen(of_name, "w"); if (ofile != NULL) { ExactSolution ex_sln(&mesh, exact_solution); // DiffFilter eh(&sln, &ex_sln); // DiffFilter eh_dx(mesh, &sln, &ex_sln, FN_DX, FN_DX); // DiffFilter eh_dy(mesh, &sln, &ex_sln, FN_DY, FN_DY); // DiffFilter eh_dz(mesh, &sln, &ex_sln, FN_DZ, FN_DZ); GmshOutputEngine output(ofile); output.out(&sln, "Uh"); // output.out(&sln, "Uh dx", FN_DX_0); // output.out(&sln, "Uh dy", FN_DY_0); // output.out(&sln, "Uh dz", FN_DZ_0); // output.out(&eh, "Eh"); // output.out(&eh_dx, "Eh dx"); // output.out(&eh_dy, "Eh dy"); // output.out(&eh_dz, "Eh dz"); output.out(&ex_sln, "U"); // output.out(&ex_sln, "U dx", FN_DX_0); // output.out(&ex_sln, "U dy", FN_DY_0); // output.out(&ex_sln, "U dz", FN_DZ_0); fclose(ofile); } else { warning("Can not open '%s' for writing.", of_name); } #endif } else res = ERR_FAILURE; #ifdef WITH_PETSC mat.free(); rhs.free(); PetscFinalize(); #endif return res; }
UINT32 intelfsh_device::read_full(UINT32 address) { UINT32 data = 0; address += m_bank << 16; switch( m_flash_mode ) { default: case FM_NORMAL: switch( m_bits ) { case 8: { data = space(AS_PROGRAM).read_byte(address); } break; case 16: { data = space(AS_PROGRAM).read_word(address * 2); } break; } break; case FM_READSTATUS: data = m_status; break; case FM_READAMDID3: if ((m_maker_id == MFG_FUJITSU && m_device_id == 0x35) || (m_maker_id == MFG_AMD && m_device_id == 0x3b)) { // used in Fujitsu 29DL16X 8bits mode // used in AMD 29LV200 8bits mode switch (address) { case 0: data = m_maker_id; break; case 2: data = m_device_id; break; case 4: data = 0; break; } } else { switch (address) { case 0: data = m_maker_id; break; case 1: data = m_device_id; break; case 2: data = 0; break; } } break; case FM_READID: if (m_maker_id == MFG_INTEL && m_device_id == 0x16) { switch (address) { case 0: data = m_maker_id; break; case 2: data = m_device_id; break; case 4: data = 0; break; } } else { switch (address) { case 0: // maker ID data = m_maker_id; break; case 1: // chip ID data = m_device_id; break; case 2: // block lock config data = 0; // we don't support this yet break; case 3: // master lock config if (m_flash_master_lock) { data = 1; } else { data = 0; } break; } } break; case FM_ERASEAMD4: // reads outside of the erasing sector return normal data if ((address < m_erase_sector) || (address >= m_erase_sector+(64*1024))) { switch( m_bits ) { case 8: { data = space(AS_PROGRAM).read_byte(address); } break; case 16: { data = space(AS_PROGRAM).read_word(address * 2); } break; } } else { m_status ^= ( 1 << 6 ) | ( 1 << 2 ); data = m_status; } break; } //logerror( "intelflash_read( %08x ) %08x\n", address, data ); return data; }
// Process a command on an input line void command() { int cmd = inbuf[1] << 9 | inbuf[2]; int spval; Char *cptr = inbuf + 3; // points past the command if (cmd == 0146151) { // 'fi', set fill mode brkline(); fill = 1; } else if (cmd == 0156146) { // 'nf', disable fill mode brkline(); fill = 0; } else if (cmd == 0152165) { // 'ju', set justify mode justify = 1; } else if (cmd == 0156152) { // 'nj', disable justify mode justify = 0; } else if (cmd == 0142162) // 'br', break current line brkline(); else if (cmd == 0154163) // 'ls' lsval = getval(cptr, 1, 1, HUGE); else if (cmd == 0142160) { // 'bp' if (lineno > 0) space(HUGE); curpag = getval(cptr, curpag + 1, -HUGE, HUGE); newpag = curpag; } else if (cmd == 0163160) { // 'sp' spval = getval(cptr, 1, 0, HUGE); space(spval); } else if (cmd == 0151156) { // 'in', set the indent value inval = getval(cptr, 0, 0, rmval); tival = inval; } else if (cmd == 0162155) // 'rm', set the right margin rmval = getval(cptr, PAGEWIDTH, tival + 1, HUGE); else if (cmd == 0164151) { // 'ti', set a temporary indent brkline(); tival = getval(cptr, 0, 0, rmval); } else if (cmd == 0143145) { // 'ce', centre lines brkline(); ceval = getval(cptr, 1, 0, HUGE); } else if (cmd == 0165154) { // 'ul', underline lines ulval = getval(cptr, 1, 1, HUGE); } else if (cmd == 0142157) { // 'bo', embolden lines boval = getval(cptr, 1, 1, HUGE); } else if (cmd == 0150145) { // 'he' gettl(cptr, header); } else if (cmd == 0146157) { // 'fo' gettl(cptr, footer); } else if (cmd == 0160154) { // 'pl', set page length value plval = getval(cptr, PAGELEN, m1val + m2val + m3val + m4val + 1, HUGE); bottom = plval - m3val - m4val; } else if (cmd == 0164141) // 'ta', set tab values do_ta(cptr); else if (cmd == 0154151) // 'li', set literal count lival = getval(cptr, 1, 0, HUGE); else if (cmd == 0150143) { // 'hc', set hyphenation character // Skip whitespace while (*cptr == ' ' || *cptr == '\t') cptr++; hypchar= *cptr; } }
inline UINT8 ramdac_device::readbyte(offs_t address) { return space().read_byte(address); }
int main(int argc, char **args) { int res = ERR_SUCCESS; #ifdef WITH_PETSC PetscInitialize(&argc, &args, (char *) PETSC_NULL, PETSC_NULL); #endif set_verbose(false); if (argc < 5) error("Not enough parameters"); sscanf(args[2], "%d", &m); sscanf(args[3], "%d", &n); sscanf(args[4], "%d", &o); printf("* Loading mesh '%s'\n", args[1]); Mesh mesh; Mesh3DReader mesh_loader; if (!mesh_loader.load(args[1], &mesh)) error("Loading mesh file '%s'\n", args[1]); // for (int it = 0; it < 8; it++) { // mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ); // mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ); // mesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ); H1ShapesetLobattoHex shapeset; // printf("* Setting the space up\n"); H1Space space(&mesh, &shapeset); space.set_bc_types(bc_types); space.set_essential_bc_values(essential_bc_values); int mx = maxn(4, m, n, o, 4); order3_t order(mx, mx, mx); // order3_t order(3, 3, 4); printf(" - Setting uniform order to (%d, %d, %d)\n", order.x, order.y, order.z); space.set_uniform_order(order); int ndofs = space.assign_dofs(); printf(" - Number of DOFs: %d\n", ndofs); // printf("elems: %d ", mesh.get_num_active_elements()); fflush(stdout); printf("* Calculating a solution\n"); #if defined WITH_UMFPACK UMFPackMatrix mat; UMFPackVector rhs; UMFPackLinearSolver solver(&mat, &rhs); #elif defined WITH_PARDISO PardisoMatrix mat; PardisoVector rhs; PardisoLinearSolver solver(&mat, &rhs); #elif defined WITH_PETSC PetscMatrix mat; PetscVector rhs; PetscLinearSolver solver(&mat, &rhs); #elif defined WITH_MUMPS MumpsMatrix mat; MumpsVector rhs; MumpsSolver solver(&mat, &rhs); #endif WeakForm wf; wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<ord_t, ord_t>, SYM); wf.add_vector_form(linear_form<double, scalar>, linear_form<ord_t, ord_t>); LinearProblem lp(&wf); lp.set_space(&space); // assemble stiffness matrix printf(" - assembling... "); fflush(stdout); Timer assemble_timer; assemble_timer.start(); lp.assemble(&mat, &rhs); assemble_timer.stop(); printf("%s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds()); // solve the stiffness matrix printf(" - solving... "); fflush(stdout); Timer solve_timer; solve_timer.start(); bool solved = solver.solve(); solve_timer.stop(); printf("%s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds()); // mat.dump(stdout, "a"); // rhs.dump(stdout, "b"); if (solved) { Timer sln_pre_tmr; Solution sln(&mesh); sln_pre_tmr.start(); sln.set_fe_solution(&space, solver.get_solution()); sln_pre_tmr.stop(); printf("* Solution:\n"); ExactSolution ex_sln(&mesh, exact_solution); // norm double h1_sln_norm = h1_norm(&sln); double h1_err_norm = h1_error(&sln, &ex_sln); printf(" - H1 solution norm: % le\n", h1_sln_norm); printf(" - H1 error norm: % le\n", h1_err_norm); double l2_sln_norm = l2_norm(&sln); double l2_err_norm = l2_error(&sln, &ex_sln); printf(" - L2 solution norm: % le\n", l2_sln_norm); printf(" - L2 error norm: % le\n", l2_err_norm); if (h1_err_norm > EPS || l2_err_norm > EPS) { // calculated solution is not enough precise res = ERR_FAILURE; } #ifdef OUTPUT_DIR // printf("* Output\n"); // output const char *of_name = OUTPUT_DIR "/solution.pos"; FILE *ofile = fopen(of_name, "w"); if (ofile != NULL) { Timer sln_out_tmr; sln_out_tmr.start(); ExactSolution ex_sln(&mesh, exact_solution); DiffFilter eh(&sln, &ex_sln); // DiffFilter eh_dx(&sln, &ex_sln, FN_DX, FN_DX); // DiffFilter eh_dy(&sln, &ex_sln, FN_DY, FN_DY); // DiffFilter eh_dz(&sln, &ex_sln, FN_DZ, FN_DZ); GmshOutputEngine output(ofile); output.out(&sln, "Uh", FN_VAL_0); // output.out(&sln, "Uh dx", FN_DX_0); // output.out(&sln, "Uh dy", FN_DY_0); // output.out(&sln, "Uh dz", FN_DZ_0); // output.out(&eh, "Eh"); // output.out(&eh_dx, "Eh dx"); // output.out(&eh_dy, "Eh dy"); // output.out(&eh_dz, "Eh dz"); output.out(&ex_sln, "U"); // output.out(&ex_sln, "U dx", FN_DX_0); // output.out(&ex_sln, "U dy", FN_DY_0); // output.out(&ex_sln, "U dz", FN_DZ_0); sln_out_tmr.stop(); // printf(" | %s (%lf secs)", sln_pre_tmr.get_human_time(), sln_pre_tmr.get_seconds()); // printf(" | %s (%lf secs)\n", sln_out_tmr.get_human_time(), sln_out_tmr.get_seconds()); fclose(ofile); } else { warning("Can not open '%s' for writing.", of_name); } #endif } else res = ERR_FAILURE; #ifdef WITH_PETSC mat.free(); rhs.free(); PetscFinalize(); #endif return res; }
int main(int argc, char* argv[]) { // Load the mesh. Mesh mesh; H2DReader mloader; mloader.load(mesh_file, &mesh); // Perform initial mesh refinements (optional). for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(); // Enter boundary markers. BCTypes bc_types; bc_types.add_bc_dirichlet(BDY_MARKER); // Enter zero Dirichlet boundary values. BCValues bc_values; // Create an H1 space with default shapeset. H1Space space(&mesh, &bc_types, &bc_values, P_INIT); int ndof = Space::get_num_dofs(&space); info("ndof = %d", ndof); // Initialize the weak formulation. WeakForm wf; wf.add_matrix_form(callback(bilinear_form)); wf.add_vector_form(callback(linear_form)); // Initialize the FE problem. bool is_linear = true; DiscreteProblem dp(&wf, &space, is_linear); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix* matrix = create_matrix(matrix_solver); Vector* rhs = create_vector(matrix_solver); Solver* solver = create_linear_solver(matrix_solver, matrix, rhs); // Initialize the solution. Solution sln; // Assemble the stiffness matrix and right-hand side vector. info("Assembling the stiffness matrix and right-hand side vector."); dp.assemble(matrix, rhs); // Solve the linear system and if successful, obtain the solution. info("Solving the matrix problem."); if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &sln); else error ("Matrix solver failed.\n"); // Visualize the solution. ScalarView view("Solution", new WinGeom(0, 0, 800, 350)); view.show(&sln); // Wait for the view to be closed. View::wait(); // Clean up. delete solver; delete matrix; delete rhs; return 0; }
int main(int argc, char* argv[]) { // Choose a Butcher's table or define your own. ButcherTable bt(butcher_table_type); if (bt.is_explicit()) Hermes::Mixins::Loggable::Static::info("Using a %d-stage explicit R-K method.", bt.get_size()); if (bt.is_diagonally_implicit()) Hermes::Mixins::Loggable::Static::info("Using a %d-stage diagonally implicit R-K method.", bt.get_size()); if (bt.is_fully_implicit()) Hermes::Mixins::Loggable::Static::info("Using a %d-stage fully implicit R-K method.", bt.get_size()); // Turn off adaptive time stepping if R-K method is not embedded. if (bt.is_embedded() == false && ADAPTIVE_TIME_STEP_ON == true) { Hermes::Mixins::Loggable::Static::warn("R-K method not embedded, turning off adaptive time stepping."); ADAPTIVE_TIME_STEP_ON = false; } // Load the mesh. MeshSharedPtr mesh(new Mesh), basemesh(new Mesh); MeshReaderH2D mloader; mloader.load("square.mesh", basemesh); mesh->copy(basemesh); // Initial mesh refinements. for(int i = 0; i < INIT_REF_NUM; i++) mesh->refine_all_elements(); // Convert initial condition into a Solution<complex>. MeshFunctionSharedPtr<complex> psi_time_prev(new CustomInitialCondition(mesh)); // Initialize the weak formulation. double current_time = 0; // Initialize weak formulation. CustomWeakFormGPRK wf(h, m, g, omega); // Initialize boundary conditions. DefaultEssentialBCConst<complex> bc_essential("Bdy", 0.0); EssentialBCs<complex> bcs(&bc_essential); // Create an H1 space with default shapeset. SpaceSharedPtr<complex> space(new H1Space<complex> (mesh, &bcs, P_INIT)); int ndof = space->get_num_dofs(); Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof); // Initialize the FE problem. DiscreteProblem<complex> dp(&wf, space); // Create a refinement selector. H1ProjBasedSelector<complex> selector(CAND_LIST); // Visualize initial condition. char title[100]; ScalarView sview_real("Initial condition - real part", new WinGeom(0, 0, 600, 500)); ScalarView sview_imag("Initial condition - imaginary part", new WinGeom(610, 0, 600, 500)); sview_real.show_mesh(false); sview_imag.show_mesh(false); sview_real.fix_scale_width(50); sview_imag.fix_scale_width(50); OrderView ord_view("Initial mesh", new WinGeom(445, 0, 440, 350)); ord_view.fix_scale_width(50); ScalarView time_error_view("Temporal error", new WinGeom(0, 400, 440, 350)); time_error_view.fix_scale_width(50); time_error_view.fix_scale_width(60); ScalarView space_error_view("Spatial error", new WinGeom(445, 400, 440, 350)); space_error_view.fix_scale_width(50); MeshFunctionSharedPtr<double> real(new RealFilter(psi_time_prev)); MeshFunctionSharedPtr<double> imag(new ImagFilter(psi_time_prev)); sview_real.show(real); sview_imag.show(imag); ord_view.show(space); // Graph for time step history. SimpleGraph time_step_graph; if (ADAPTIVE_TIME_STEP_ON) Hermes::Mixins::Loggable::Static::info("Time step history will be saved to file time_step_history.dat."); // Time stepping: int num_time_steps = (int)(T_FINAL/time_step + 0.5); for(int ts = 1; ts <= num_time_steps; ts++) // Time stepping loop. double current_time = 0.0; int ts = 1; do { Hermes::Mixins::Loggable::Static::info("Begin time step %d.", ts); // Periodic global derefinement. if (ts > 1 && ts % UNREF_FREQ == 0) { Hermes::Mixins::Loggable::Static::info("Global mesh derefinement."); switch (UNREF_METHOD) { case 1: mesh->copy(basemesh); space->set_uniform_order(P_INIT); break; case 2: space->unrefine_all_mesh_elements(); space->set_uniform_order(P_INIT); break; case 3: space->unrefine_all_mesh_elements(); space->adjust_element_order(-1, -1, P_INIT, P_INIT); break; default: throw Hermes::Exceptions::Exception("Wrong global derefinement method."); } ndof = Space<complex>::get_num_dofs(space); } Hermes::Mixins::Loggable::Static::info("ndof: %d", ndof); // Spatial adaptivity loop. Note: psi_time_prev must not be // changed during spatial adaptivity. MeshFunctionSharedPtr<complex> ref_sln(new Solution<complex>()); MeshFunctionSharedPtr<complex> time_error_fn(new Solution<complex>); bool done = false; int as = 1; double err_est; do { // Construct globally refined reference mesh and setup reference space. Mesh::ReferenceMeshCreator refMeshCreator(mesh); MeshSharedPtr ref_mesh = refMeshCreator.create_ref_mesh(); Space<complex>::ReferenceSpaceCreator refSpaceCreator(space, ref_mesh); SpaceSharedPtr<complex> ref_space = refSpaceCreator.create_ref_space(); // Initialize discrete problem on reference mesh. DiscreteProblem<complex>* ref_dp = new DiscreteProblem<complex>(&wf, ref_space); RungeKutta<complex> runge_kutta(&wf, ref_space, &bt); // Runge-Kutta step on the fine mesh-> Hermes::Mixins::Loggable::Static::info("Runge-Kutta time step on fine mesh (t = %g s, time step = %g s, stages: %d).", current_time, time_step, bt.get_size()); bool verbose = true; try { runge_kutta.set_time(current_time); runge_kutta.set_time_step(time_step); runge_kutta.set_max_allowed_iterations(NEWTON_MAX_ITER); runge_kutta.set_tolerance(NEWTON_TOL_FINE); runge_kutta.rk_time_step_newton(psi_time_prev, ref_sln, time_error_fn); } catch(Exceptions::Exception& e) { e.print_msg(); throw Hermes::Exceptions::Exception("Runge-Kutta time step failed"); } /* If ADAPTIVE_TIME_STEP_ON == true, estimate temporal error. If too large or too small, then adjust it and restart the time step. */ double rel_err_time = 0; if (bt.is_embedded() == true) { Hermes::Mixins::Loggable::Static::info("Calculating temporal error estimate."); // Show temporal error. char title[100]; sprintf(title, "Temporal error est, spatial adaptivity step %d", as); time_error_view.set_title(title); time_error_view.show_mesh(false); MeshFunctionSharedPtr<double> abs_time(new RealFilter(time_error_fn)); MeshFunctionSharedPtr<double> abs_tef(new AbsFilter(abs_time)); time_error_view.show(abs_tef); rel_err_time = Global<complex>::calc_norm(time_error_fn.get(), HERMES_H1_NORM) / Global<complex>::calc_norm(ref_sln.get(), HERMES_H1_NORM) * 100; if (ADAPTIVE_TIME_STEP_ON == false) Hermes::Mixins::Loggable::Static::info("rel_err_time: %g%%", rel_err_time); } if (ADAPTIVE_TIME_STEP_ON) { if (rel_err_time > TIME_ERR_TOL_UPPER) { Hermes::Mixins::Loggable::Static::info("rel_err_time %g%% is above upper limit %g%%", rel_err_time, TIME_ERR_TOL_UPPER); Hermes::Mixins::Loggable::Static::info("Decreasing time step from %g to %g s and restarting time step.", time_step, time_step * TIME_STEP_DEC_RATIO); time_step *= TIME_STEP_DEC_RATIO; delete ref_dp; continue; } else if (rel_err_time < TIME_ERR_TOL_LOWER) { Hermes::Mixins::Loggable::Static::info("rel_err_time = %g%% is below lower limit %g%%", rel_err_time, TIME_ERR_TOL_LOWER); Hermes::Mixins::Loggable::Static::info("Increasing time step from %g to %g s.", time_step, time_step * TIME_STEP_INC_RATIO); time_step *= TIME_STEP_INC_RATIO; delete ref_dp; continue; } else { Hermes::Mixins::Loggable::Static::info("rel_err_time = %g%% is in acceptable interval (%g%%, %g%%)", rel_err_time, TIME_ERR_TOL_LOWER, TIME_ERR_TOL_UPPER); } // Add entry to time step history graph. time_step_graph.add_values(current_time, time_step); time_step_graph.save("time_step_history.dat"); } /* Estimate spatial errors and perform mesh refinement */ Hermes::Mixins::Loggable::Static::info("Spatial adaptivity step %d.", as); // Project the fine mesh solution onto the coarse mesh. MeshFunctionSharedPtr<complex> sln(new Solution<complex>); Hermes::Mixins::Loggable::Static::info("Projecting fine mesh solution on coarse mesh for error estimation."); OGProjection<complex> ogProjection; ogProjection.project_global(space, ref_sln, sln); // Show spatial error. sprintf(title, "Spatial error est, spatial adaptivity step %d", as); MeshFunctionSharedPtr<complex> space_error_fn(new DiffFilter<complex>(Hermes::vector<MeshFunctionSharedPtr<complex> >(ref_sln, sln))); space_error_view.set_title(title); space_error_view.show_mesh(false); MeshFunctionSharedPtr<double> abs_space(new RealFilter(space_error_fn)); MeshFunctionSharedPtr<double> abs_sef(new AbsFilter(abs_space)); space_error_view.show(abs_sef); // Calculate element errors and spatial error estimate. Hermes::Mixins::Loggable::Static::info("Calculating spatial error estimate."); Adapt<complex> adaptivity(space); double err_rel_space = errorCalculator.get_total_error_squared() * 100; // Report results. Hermes::Mixins::Loggable::Static::info("ndof: %d, ref_ndof: %d, err_rel_space: %g%%", Space<complex>::get_num_dofs(space), Space<complex>::get_num_dofs(ref_space), err_rel_space); // If err_est too large, adapt the mesh. if (err_rel_space < SPACE_ERR_TOL) done = true; else { Hermes::Mixins::Loggable::Static::info("Adapting the coarse mesh."); done = adaptivity.adapt(&selector); // Increase the counter of performed adaptivity steps. as++; } // Clean up. delete ref_dp; } while (done == false); // Visualize the solution and mesh-> char title[100]; sprintf(title, "Solution - real part, Time %3.2f s", current_time); sview_real.set_title(title); sprintf(title, "Solution - imaginary part, Time %3.2f s", current_time); sview_imag.set_title(title); MeshFunctionSharedPtr<double> real(new RealFilter(ref_sln)); MeshFunctionSharedPtr<double> imag(new ImagFilter(ref_sln)); sview_real.show(real); sview_imag.show(imag); sprintf(title, "Mesh, time %g s", current_time); ord_view.set_title(title); ord_view.show(space); // Copy last reference solution into psi_time_prev. psi_time_prev->copy(ref_sln); // Increase current time and counter of time steps. current_time += time_step; ts++; } while (current_time < T_FINAL); // Wait for all views to be closed. View::wait(); return 0; }
size_t used_in_bytes() { return space()->used_in_bytes(); }
void View::ResizeChildren() { if( layout == LayoutOverlay ) { // Sort children into z-order std::sort(views.begin(), views.end(), zcompare); for(std::vector<View*>::iterator iv = views.begin(); iv != views.end(); ++iv ) { (*iv)->Resize(v); } }else if( layout == LayoutVertical ) { // Allocate space incrementally Viewport space = v.Inset(panal_v_margin); int num_children = 0; for(std::vector<View*>::iterator iv = views.begin(); iv != views.end(); ++iv ) { num_children++; if(scroll_offset > num_children ) { (*iv)->show = false; }else{ (*iv)->show = true; (*iv)->Resize(space); space.h = (*iv)->v.b - panal_v_margin - space.b; } } }else if(layout == LayoutHorizontal ) { // Allocate space incrementally const int margin = 8; Viewport space = v.Inset(margin); for(std::vector<View*>::iterator iv = views.begin(); iv != views.end(); ++iv ) { (*iv)->Resize(space); space.w = (*iv)->v.l + margin + space.l; } }else if(layout == LayoutEqualVertical ) { // Allocate vertical space equally const size_t visiblechildren = NumVisibleChildren(); const float height = (float)v.h / (float)visiblechildren; for( size_t i=0; i < visiblechildren; ++i) { Viewport space(v.l, (GLint)(v.b+(visiblechildren-1-i)*height), v.w, (GLint)(height) ); VisibleChild(i).Resize(space); } }else if(layout == LayoutEqualHorizontal ) { // Allocate vertical space equally const size_t visiblechildren = NumVisibleChildren(); const float width = (float)v.w / (float)visiblechildren; for( size_t i=0; i < visiblechildren; ++i) { Viewport space( (GLint)(v.l+i*width), v.b, (GLint)width, v.h); VisibleChild(i).Resize(space); } }else if(layout == LayoutEqual ) { const size_t visiblechildren = NumVisibleChildren(); // TODO: Make this neater, and make fewer assumptions! if( visiblechildren > 0 ) { // This containers aspect const double this_a = std::fabs(v.aspect()); // Use first child with fixed aspect for all children double child_a = std::fabs(VisibleChild(0).aspect); for(size_t i=1; (child_a==0) && i < visiblechildren; ++i ) { child_a = std::fabs(VisibleChild(i).aspect); } if(child_a == 0) { child_a = 1; } double a = visiblechildren*child_a; double area = AspectAreaWithinTarget(this_a, a); size_t cols = visiblechildren-1; for(; cols > 0; --cols) { const size_t rows = visiblechildren / cols + (visiblechildren % cols == 0 ? 0 : 1); const double na = cols * child_a / rows; const double new_area = visiblechildren*AspectAreaWithinTarget(this_a,na)/(rows*cols); if( new_area <= area ) break; area = new_area; a = na; } cols++; const size_t rows = visiblechildren / cols + (visiblechildren % cols == 0 ? 0 : 1); size_t cw, ch; if( a > this_a ) { cw = v.w / cols; ch = (int)(cw / child_a); //v.h / rows; }else{ ch = v.h / rows; cw = (int)(ch * child_a); } for(size_t i=0; i< visiblechildren; ++i ) { size_t c = i % cols; size_t r = i / cols; Viewport space( GLint(v.l + c*cw), GLint(v.t() - (r+1)*ch), GLint(cw), GLint(ch) ); VisibleChild(i).Resize(space); } } } }
int main(int argc, char* argv[]) { // Load the mesh. Mesh mesh; H2DReader mloader; mloader.load("domain.mesh", &mesh); // Perform initial mesh refinements. mesh.refine_towards_vertex(3, CORNER_REF_LEVEL); // Enter boundary markers. BCTypes bc_types; bc_types.add_bc_dirichlet(BDY_INNER); bc_types.add_bc_neumann(Hermes::Tuple<int>(BDY_BOTTOM, BDY_OUTER, BDY_LEFT)); // Enter Dirichlet boudnary values. BCValues bc_values; bc_values.add_zero(BDY_INNER); // Create an H1 space with default shapeset. H1Space space(&mesh, &bc_types, &bc_values, P_INIT); int ndof = Space::get_num_dofs(&space); info("ndof = %d", ndof); // Initialize the weak formulation. WeakForm wf; wf.add_matrix_form(callback(bilinear_form)); wf.add_vector_form(callback(linear_form)); wf.add_vector_form_surf(callback(linear_form_surf_bottom), BDY_BOTTOM); wf.add_vector_form_surf(callback(linear_form_surf_outer), BDY_OUTER); wf.add_vector_form_surf(callback(linear_form_surf_left), BDY_LEFT); // Initialize the FE problem. bool is_linear = true; DiscreteProblem dp(&wf, &space, is_linear); // Set up the solver, matrix, and rhs according to the solver selection. SparseMatrix* matrix = create_matrix(matrix_solver); Vector* rhs = create_vector(matrix_solver); Solver* solver = create_linear_solver(matrix_solver, matrix, rhs); // Initialize the solution. Solution sln; // Assemble the stiffness matrix and right-hand side vector. info("Assembling the stiffness matrix and right-hand side vector."); dp.assemble(matrix, rhs); // Solve the linear system and if successful, obtain the solution. info("Solving the matrix problem."); if(solver->solve()) Solution::vector_to_solution(solver->get_solution(), &space, &sln); else error ("Matrix solver failed.\n"); // Visualize the approximation. ScalarView view("Solution", new WinGeom(0, 0, 440, 350)); view.show(&sln); // Compute and show gradient magnitude. // (Note that the gradient at the re-entrant // corner needs to be truncated for visualization purposes.) ScalarView gradview("Gradient", new WinGeom(450, 0, 400, 350)); MagFilter grad(Hermes::Tuple<MeshFunction *>(&sln, &sln), Hermes::Tuple<int>(H2D_FN_DX, H2D_FN_DY)); gradview.show(&grad); // Wait for the views to be closed. View::wait(); // Clean up. delete solver; delete matrix; delete rhs; return 0; }
int main(int argc, char **argv) { int res = ERR_SUCCESS; #ifdef WITH_PETSC PetscInitialize(&argc, &argv, (char *) PETSC_NULL, PETSC_NULL); #endif set_verbose(false); if (argc < 5) error("Not enough parameters."); H1ShapesetLobattoHex shapeset; printf("* Loading mesh '%s'\n", argv[1]); Mesh mesh; Mesh3DReader mloader; if (!mloader.load(argv[1], &mesh)) error("Loading mesh file '%s'\n", argv[1]); printf("* Setting the space up\n"); H1Space space(&mesh, &shapeset); space.set_bc_types(bc_types); space.set_essential_bc_values(essential_bc_values); int o[3] = { 0, 0, 0 }; sscanf(argv[2], "%d", o + 0); sscanf(argv[3], "%d", o + 1); sscanf(argv[4], "%d", o + 2); order3_t order(o[0], o[1], o[2]); printf(" - Setting uniform order to (%d, %d, %d)\n", order.x, order.y, order.z); space.set_uniform_order(order); WeakForm wf; wf.add_matrix_form(bilinear_form<double, scalar>, bilinear_form<ord_t, ord_t>, SYM, ANY); wf.add_vector_form(linear_form<double, scalar>, linear_form<ord_t, ord_t>, ANY); LinearProblem lp(&wf); lp.set_space(&space); bool done = false; int iter = 0; do { Timer assemble_timer("Assembling stiffness matrix"); Timer solve_timer("Solving stiffness matrix"); printf("\n=== Iter #%d ================================================================\n", iter); printf("\nSolution\n"); #if defined WITH_UMFPACK UMFPackMatrix mat; UMFPackVector rhs; UMFPackLinearSolver solver(&mat, &rhs); #elif defined WITH_PARDISO PardisoMatrix mat; PardisoVector rhs; PardisoLinearSolver solver(&mat, &rhs); #elif defined WITH_PETSC PetscMatrix mat; PetscVector rhs; PetscLinearSolver solver(&mat, &rhs); #elif defined WITH_MUMPS MumpsMatrix mat; MumpsVector rhs; MumpsSolver solver(&mat, &rhs); #endif int ndofs = space.assign_dofs(); printf(" - Number of DOFs: %d\n", ndofs); // assemble stiffness matrix printf(" - Assembling... "); fflush(stdout); assemble_timer.reset(); assemble_timer.start(); lp.assemble(&mat, &rhs); assemble_timer.stop(); printf("done in %s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds()); // solve the stiffness matrix printf(" - Solving... "); fflush(stdout); solve_timer.reset(); solve_timer.start(); bool solved = solver.solve(); solve_timer.stop(); if (solved) printf("done in %s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds()); else { res = ERR_FAILURE; printf("failed\n"); break; } printf("Reference solution\n"); #if defined WITH_UMFPACK UMFPackLinearSolver rsolver(&mat, &rhs); #elif defined WITH_PARDISO PardisoLinearSolver rsolver(&mat, &rhs); #elif defined WITH_PETSC PetscLinearSolver rsolver(&mat, &rhs); #elif defined WITH_MUMPS MumpsSolver rsolver(&mat, &rhs); #endif Mesh rmesh; rmesh.copy(mesh); rmesh.refine_all_elements(H3D_H3D_H3D_REFT_HEX_XYZ); Space *rspace = space.dup(&rmesh); rspace->copy_orders(space, 1); LinearProblem rlp(&wf); rlp.set_space(rspace); int rndofs = rspace->assign_dofs(); printf(" - Number of DOFs: %d\n", rndofs); printf(" - Assembling... "); fflush(stdout); assemble_timer.reset(); assemble_timer.start(); rlp.assemble(&mat, &rhs); assemble_timer.stop(); printf("done in %s (%lf secs)\n", assemble_timer.get_human_time(), assemble_timer.get_seconds()); printf(" - Solving... "); fflush(stdout); solve_timer.reset(); solve_timer.start(); bool rsolved = rsolver.solve(); solve_timer.stop(); if (rsolved) printf("done in %s (%lf secs)\n", solve_timer.get_human_time(), solve_timer.get_seconds()); else { res = ERR_FAILURE; printf("failed\n"); break; } Solution sln(&mesh); sln.set_fe_solution(&space, solver.get_solution()); Solution rsln(&rmesh); rsln.set_fe_solution(rspace, rsolver.get_solution()); printf("Adaptivity:\n"); H1Adapt hp(&space); double tol = hp.calc_error(&sln, &rsln) * 100; printf(" - tolerance: "); fflush(stdout); printf("% lf\n", tol); if (tol < TOLERANCE) { printf("\nDone\n"); ExactSolution ex_sln(&mesh, exact_solution); // norm double h1_sln_norm = h1_norm(&sln); double h1_err_norm = h1_error(&sln, &ex_sln); printf(" - H1 solution norm: % le\n", h1_sln_norm); printf(" - H1 error norm: % le\n", h1_err_norm); double l2_sln_norm = l2_norm(&sln); double l2_err_norm = l2_error(&sln, &ex_sln); printf(" - L2 solution norm: % le\n", l2_sln_norm); printf(" - L2 error norm: % le\n", l2_err_norm); if (h1_err_norm > EPS || l2_err_norm > EPS) { // calculated solution is not enough precise res = ERR_FAILURE; } break; } Timer t(""); printf(" - adapting... "); fflush(stdout); t.start(); hp.adapt(THRESHOLD); t.stop(); printf("done in %lf secs (refined %d element(s))\n", t.get_seconds(), hp.get_num_refined_elements()); iter++; } while (!done); #ifdef WITH_PETSC PetscFinalize(); #endif return res; }