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.
int mx = 2;
Ord3 order(mx, mx, mx);
H1Space space(&mesh, bc_types, NULL, order);
#if defined LIN_DIRICHLET || defined NLN_DIRICHLET
space.set_essential_bc_values(essential_bc_values);
#endif
// Initialize the weak formulation.
WeakForm wf;
wf.add_vector_form(form_0<double, scalar>, form_0<Ord, Ord>);
#if defined LIN_NEUMANN || defined LIN_NEWTON
wf.add_vector_form_surf(form_0_surf<double, scalar>, form_0_surf<Ord, Ord>);
#endif
#if defined LIN_DIRICHLET || defined NLN_DIRICHLET
// preconditioner
wf.add_matrix_form(precond_0_0<double, scalar>, precond_0_0<Ord, Ord>, HERMES_SYM);
#endif
// Initialize the FE problem.
DiscreteProblem fep(&wf, &space);
#if defined LIN_DIRICHLET || defined NLN_DIRICHLET
// use ML preconditioner to speed-up things
MlPrecond pc("sa");
pc.set_param("max levels", 6);
pc.set_param("increasing or decreasing", "decreasing");
pc.set_param("aggregation: type", "MIS");
pc.set_param("coarse: type", "Amesos-KLU");
#endif
NoxSolver solver(&fep);
#if defined LIN_DIRICHLET || defined NLN_DIRICHLET
// solver.set_precond(&pc);
#endif
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);
ex_sln.set_exact(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;
if (success_test) {
info("Success!");
return ERR_SUCCESS;
}
else {
info("Failure!");
return ERR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinemets.
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Create H1 spaces with default shapesets.
H1Space* t_space = new H1Space(&mesh, bc_types, essential_bc_values_t, P_INIT);
H1Space* c_space = new H1Space(&mesh, bc_types, essential_bc_values_c, P_INIT);
int ndof = get_num_dofs(Tuple<Space *>(t_space, c_space));
info("ndof = %d.", ndof);
// Define initial conditions.
Solution t_prev_time_1, c_prev_time_1, t_prev_time_2,
c_prev_time_2, t_iter, c_iter, t_prev_newton, c_prev_newton;
t_prev_time_1.set_exact(&mesh, temp_ic);
c_prev_time_1.set_exact(&mesh, conc_ic);
t_prev_time_2.set_exact(&mesh, temp_ic);
c_prev_time_2.set_exact(&mesh, conc_ic);
t_iter.set_exact(&mesh, temp_ic);
c_iter.set_exact(&mesh, conc_ic);
// Filters for the reaction rate omega and its derivatives.
DXDYFilter omega(omega_fn, Tuple<MeshFunction*>(&t_prev_time_1, &c_prev_time_1));
DXDYFilter omega_dt(omega_dt_fn, Tuple<MeshFunction*>(&t_prev_time_1, &c_prev_time_1));
DXDYFilter omega_dc(omega_dc_fn, Tuple<MeshFunction*>(&t_prev_time_1, &c_prev_time_1));
// Initialize visualization.
ScalarView rview("Reaction rate", new WinGeom(0, 0, 800, 230));
// Initialize weak formulation.
WeakForm wf(2, JFNK ? true : false);
if (!JFNK || (JFNK && PRECOND == 1))
{
wf.add_matrix_form(callback(newton_bilinear_form_0_0), H2D_UNSYM, H2D_ANY, &omega_dt);
wf.add_matrix_form_surf(0, 0, callback(newton_bilinear_form_0_0_surf), 3);
wf.add_matrix_form(1, 1, callback(newton_bilinear_form_1_1), H2D_UNSYM, H2D_ANY, &omega_dc);
wf.add_matrix_form(0, 1, callback(newton_bilinear_form_0_1), H2D_UNSYM, H2D_ANY, &omega_dc);
wf.add_matrix_form(1, 0, callback(newton_bilinear_form_1_0), H2D_UNSYM, H2D_ANY, &omega_dt);
}
else if (PRECOND == 2)
{
wf.add_matrix_form(0, 0, callback(precond_0_0));
wf.add_matrix_form(1, 1, callback(precond_1_1));
}
wf.add_vector_form(0, callback(newton_linear_form_0), H2D_ANY,
Tuple<MeshFunction*>(&t_prev_time_1, &t_prev_time_2, &omega));
wf.add_vector_form_surf(0, callback(newton_linear_form_0_surf), 3);
wf.add_vector_form(1, callback(newton_linear_form_1), H2D_ANY,
Tuple<MeshFunction*>(&c_prev_time_1, &c_prev_time_2, &omega));
// Project the functions "t_iter" and "c_iter" on the FE space
// in order to obtain initial vector for NOX.
info("Projecting initial solutions on the FE meshes.");
Vector* coeff_vec = new AVector(ndof);
project_global(Tuple<Space *>(t_space, c_space), Tuple<int>(H2D_H1_NORM, H2D_H1_NORM),
Tuple<MeshFunction*>(&t_prev_time_1, &c_prev_time_1), Tuple<Solution*>(&t_prev_time_1, &c_prev_time_1),
coeff_vec);
// Measure the projection time.
double proj_time = cpu_time.tick().last();
// Initialize finite element problem.
FeProblem fep(&wf, Tuple<Space*>(t_space, c_space));
// Initialize NOX solver and preconditioner.
NoxSolver solver(&fep);
MlPrecond pc("sa");
if (PRECOND)
{
if (JFNK) solver.set_precond(&pc);
else solver.set_precond("Ifpack");
}
if (TRILINOS_OUTPUT)
solver.set_output_flags(NOX::Utils::Error | NOX::Utils::OuterIteration |
NOX::Utils::OuterIterationStatusTest |
NOX::Utils::LinearSolverDetails);
// Time stepping loop:
double total_time = 0.0;
cpu_time.tick_reset();
for (int ts = 1; total_time <= 60.0; ts++)
{
info("---- Time step %d, t = %g s", ts, total_time + TAU);
cpu_time.tick(HERMES_SKIP);
solver.set_init_sln(coeff_vec->get_c_array());
bool solved = solver.solve();
if (solved)
{
double* s = solver.get_solution_vector();
AVector *tmp_vector = new AVector(ndof);
tmp_vector->set_c_array(s, ndof);
t_prev_newton.set_fe_solution(t_space, tmp_vector);
c_prev_newton.set_fe_solution(c_space, tmp_vector);
delete tmp_vector;
cpu_time.tick();
info("Number of nonlin iterations: %d (norm of residual: %g)",
solver.get_num_iters(), solver.get_residual());
info("Total number of iterations in linsolver: %d (achieved tolerance in the last step: %g)",
solver.get_num_lin_iters(), solver.get_achieved_tol());
// Time measurement.
cpu_time.tick(HERMES_SKIP);
// Visualization.
DXDYFilter omega_view(omega_fn, Tuple<MeshFunction*>(&t_prev_newton, &c_prev_newton));
rview.set_min_max_range(0.0,2.0);
cpu_time.tick(HERMES_SKIP);
// Skip visualization time.
cpu_time.tick(HERMES_SKIP);
// Update global time.
total_time += TAU;
// Saving solutions for the next time step.
t_prev_time_2.copy(&t_prev_time_1);
c_prev_time_2.copy(&c_prev_time_1);
t_prev_time_1 = t_prev_newton;
c_prev_time_1 = c_prev_newton;
}
else
error("NOX failed.");
info("Total running time for time level %d: %g s.", ts, cpu_time.tick().last());
}
// Wait for all views to be closed.
View::wait();
return 0;
}
