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;
}
