Scalar CustomWeakFormHeatRK::CustomFormResidualSurf::vector_form_surf(int n, double *wt, Func<Scalar> *u_ext[], Func<Real> *v, GeomSurf<Real> *e, Func<Scalar> **ext) const
{
Scalar T_ext = Scalar(temp_ext(get_current_stage_time()));
Scalar result = Scalar(0);
for (int pt_i = 0; pt_i < n; pt_i++)
{
result += wt[pt_i] * (T_ext - u_ext[this->previous_iteration_space_index]->val[pt_i]) * v->val[pt_i];
}
return alpha / (rho * heatcap) * result;
}
double CustomWeakFormHeatRK::CustomFormResidualSurf::value(int n, double *wt, Func<double> *u_ext[], Func<double> *v, GeomSurf<double> *e,
Func<double> **ext) const
{
double T_ext = temp_ext(get_current_stage_time());
double result = 0.;
for (int pt_i = 0; pt_i < n; pt_i++)
{
result += wt[pt_i] * (T_ext - u_ext[this->previous_iteration_space_index]->val[pt_i]) * v->val[pt_i];
}
return alpha / (rho * heatcap) * result;
}
double CustomWeakFormHeatRK::CustomFormResidualSurf::value(int n, double *wt, Func<double> *u_ext[], Func<double> *v, Geom<double> *e,
ExtData<double> *ext) const
{
double T_ext = temp_ext(get_current_stage_time());
double result = 0;
for (int i = 0; i < n; i++)
{
result += wt[i] * (T_ext - u_ext[0]->val[i]) * v->val[i];
}
return alpha / (rho * heatcap) * result;
}
Scalar vector_form_surf(int n, double *wt, Func<Scalar> *u_ext[], Func<Real> *v, Geom<Real> *e, ExtData<Scalar> *ext) const {
return -alpha / (rho * heatcap) * temp_ext(*current_time_ptr + time_step) * int_v<Real>(n, wt, v);
}
int main(int argc, char* argv[])
{
// 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);
// Initialize an H1 space with default shepeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
int ndof = get_num_dofs(&space);
info("ndof = %d.", ndof);
// Set initial condition.
Solution tsln;
tsln.set_const(&mesh, T_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, double>, bilinear_form<Ord, Ord>);
wf.add_matrix_form_surf(bilinear_form_surf<double, double>, bilinear_form_surf<Ord, Ord>, bdy_air);
wf.add_vector_form(linear_form<double, double>, linear_form<Ord, Ord>, H2D_ANY, &tsln);
wf.add_vector_form_surf(linear_form_surf<double, double>, linear_form_surf<Ord, Ord>, bdy_air);
// Initialize the linear problem.
LinearProblem lp(&wf, &space);
// Initialize matrix solver.
Matrix* mat; Vector* rhs; CommonSolver* solver;
init_matrix_solver(matrix_solver, ndof, mat, rhs, solver);
// Initialize views.
ScalarView Tview("Temperature", new WinGeom(0, 0, 450, 600));
char title[100];
sprintf(title, "Time %3.5f, exterior temperature %3.5f", TIME, temp_ext(TIME));
Tview.set_min_max_range(0,20);
Tview.set_title(title);
Tview.fix_scale_width(3);
// Time stepping:
int nsteps = (int)(FINAL_TIME/TAU + 0.5);
bool rhsonly = false;
for(int ts = 1; ts <= nsteps; ts++)
{
info("---- Time step %d, time %3.5f, ext_temp %g", ts, TIME, temp_ext(TIME));
// Assemble stiffness matrix and rhs.
lp.assemble(mat, rhs, rhsonly);
rhsonly = true;
// Solve the matrix problem.
if (!solver->solve(mat, rhs)) error ("Matrix solver failed.\n");
// Update tsln.
tsln.set_fe_solution(&space, rhs);
// Update the time variable.
TIME += TAU;
// Visualize the solution.
sprintf(title, "Time %3.2f, exterior temperature %3.5f", TIME, temp_ext(TIME));
Tview.set_title(title);
Tview.show(&tsln);
}
// Wait for the view to be closed.
View::wait();
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()) info("Using a %d-stage explicit R-K method.", bt.get_size());
if (bt.is_diagonally_implicit()) info("Using a %d-stage diagonally implicit R-K method.", bt.get_size());
if (bt.is_fully_implicit()) info("Using a %d-stage fully implicit R-K method.", bt.get_size());
// 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_vol));
wf.add_vector_form(callback(stac_residual_vol));
wf.add_matrix_form_surf(callback(stac_jacobian_surf), BDY_AIR);
wf.add_vector_form_surf(callback(stac_residual_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;
}
int main(int argc, char* argv[])
{
// 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 tsln(&mesh, TEMP_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(callback(bilinear_form));
wf.add_matrix_form_surf(callback(bilinear_form_surf), BDY_AIR);
wf.add_vector_form(callback(linear_form), HERMES_ANY, &tsln);
wf.add_vector_form_surf(callback(linear_form_surf), BDY_AIR);
// 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);
solver->set_factorization_scheme(HERMES_REUSE_FACTORIZATION_COMPLETELY);
// 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:
int ts = 1; bool rhs_only = false;
do
{
info("---- Time step %d, time %3.5f s, ext_temp %g C", ts, current_time, temp_ext(current_time));
// First time assemble both the stiffness matrix and right-hand side vector,
// then just the right-hand side vector.
if (rhs_only == false) info("Assembling the stiffness matrix and right-hand side vector.");
else info("Assembling the right-hand side vector (only).");
dp.assemble(matrix, rhs, rhs_only);
rhs_only = true;
// 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, &tsln);
else error ("Matrix solver failed.\n");
// Visualize the solution.
char title[100];
sprintf(title, "Time %3.2f s, exterior temperature %3.5f C", current_time, temp_ext(current_time));
Tview.set_title(title);
Tview.show(&tsln);
// Increase current time and time step counter.
current_time += time_step;
ts++;
}
while (current_time < T_FINAL);
// Wait for the view to be closed.
View::wait();
return 0;
}
int main(int argc, char* argv[])
{
// load and refine mesh
Mesh mesh;
mesh.load("cathedral.mesh");
for(int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
mesh.refine_towards_boundary(2, 5);
// set up shapeset
H1Shapeset shapeset;
PrecalcShapeset pss(&shapeset);
// set up spaces
H1Space space(&mesh, &shapeset);
space.set_bc_types(bc_types);
space.set_bc_values(bc_values);
space.set_uniform_order(P_INIT);
// enumerate basis functions
space.assign_dofs();
// set initial condition
Solution tsln;
tsln.set_const(&mesh, T_INIT);
// weak formulation
WeakForm wf(1);
wf.add_biform(0, 0, bilinear_form<double, double>, bilinear_form<Ord, Ord>);
wf.add_biform_surf(0, 0, bilinear_form_surf<double, double>, bilinear_form_surf<Ord, Ord>, marker_air);
wf.add_liform(0, linear_form<double, double>, linear_form<Ord, Ord>, ANY, 1, &tsln);
wf.add_liform_surf(0, linear_form_surf<double, double>, linear_form_surf<Ord, Ord>, marker_air);
// matrix solver
UmfpackSolver umfpack;
// linear system
LinSystem ls(&wf, &umfpack);
ls.set_spaces(1, &space);
ls.set_pss(1, &pss);
// visualisation
ScalarView Tview("Temperature", 0, 0, 450, 600);
char title[100];
sprintf(title, "Time %3.5f, exterior temperature %3.5f", TIME, temp_ext(TIME));
Tview.set_min_max_range(0,20);
Tview.set_title(title);
Tview.fix_scale_width(3);
// time stepping
int nsteps = (int)(FINAL_TIME/TAU + 0.5);
bool rhsonly = false;
for(int n = 1; n <= nsteps; n++)
{
info("\n---- Time %3.5f, time step %d, ext_temp %g ----------", TIME, n, temp_ext(TIME));
// assemble and solve
ls.assemble(rhsonly);
rhsonly = true;
ls.solve(1, &tsln);
// shifting the time variable
TIME += TAU;
// visualization of solution
sprintf(title, "Time %3.2f, exterior temperature %3.5f", TIME, temp_ext(TIME));
Tview.set_title(title);
Tview.show(&tsln);
//Tview.wait_for_keypress();
}
// Note: a separate example shows how to create videos
// wait for keyboard or mouse input
View::wait("Waiting for keyboard or mouse input.");
return 0;
}
Scalar linear_form_surf(int n, double *wt, Func<Real> *v, Geom<Real> *e, ExtData<Scalar> *ext)
{
return LAMBDA * ALPHA * temp_ext(TIME) * int_v<Real, Scalar>(n, wt, v);
}
int main(int argc, char* argv[])
{
// 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(2, 5);
// Initialize an H1 space.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
// Set initial condition.
Solution tsln;
tsln.set_const(&mesh, T_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, double>, bilinear_form<Ord, Ord>);
wf.add_matrix_form_surf(bilinear_form_surf<double, double>, bilinear_form_surf<Ord, Ord>, marker_air);
wf.add_vector_form(linear_form<double, double>, linear_form<Ord, Ord>, H2D_ANY, &tsln);
wf.add_vector_form_surf(linear_form_surf<double, double>, linear_form_surf<Ord, Ord>, marker_air);
// Initialize linear system.
LinSystem ls(&wf, &space);
// time stepping
int nsteps = (int)(FINAL_TIME/TAU + 0.5);
bool rhsonly = false;
for(int n = 1; n <= nsteps; n++)
{
info("---- Time step %d, time %3.5f, ext_temp %g", ts, TIME, temp_ext(TIME));
// Assemble and solve.
ls.assemble(rhsonly);
rhsonly = true;
ls.solve(&tsln);
// Update the time variable.
TIME += TAU;
}
scalar *sol_vector;
int n_dof;
ls.get_solution_vector(sol_vector, n_dof);
printf("n_dof = %d\n", n_dof);
double sum = 0;
for (int i=0; i < n_dof; i++) sum += sol_vector[i];
printf("coefficient sum = %g\n", sum);
// Actual test. The value of 'sum' depend on the
// current shapeset. If you change the shapeset,
// you need to correct this number.
int success = 1;
if (fabs(sum - 8508.36) > 1e-1) success = 0;
#define ERROR_SUCCESS 0
#define ERROR_FAILURE -1
if (success == 1) {
printf("Success!\n");
return ERROR_SUCCESS;
}
else {
printf("Failure!\n");
return ERROR_FAILURE;
}
}
virtual Ord ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *v, Geom<Ord> *e, ExtData<Ord> *ext) const
{
return -alpha / (rho * heatcap) * temp_ext(*current_time_ptr + time_step) * int_v<Ord>(n, wt, v);
}
virtual scalar value(int n, double *wt, Func<scalar> *u_ext[], Func<double> *v, Geom<double> *e, ExtData<scalar> *ext) const
{
return -alpha / (rho * heatcap) * temp_ext(*current_time_ptr + time_step) * int_v<double>(n, wt, v);
}
int main(int argc, char* argv[])
{
// 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);
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_GROUND);
bc_types.add_bc_newton(BDY_AIR);
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_const(BDY_GROUND, T_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);
// Initialize the solution.
Solution tsln;
// Set the initial condition.
tsln.set_const(&mesh, T_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, double>, bilinear_form<Ord, Ord>);
wf.add_matrix_form_surf(bilinear_form_surf<double, double>, bilinear_form_surf<Ord, Ord>, BDY_AIR);
wf.add_vector_form(linear_form<double, double>, linear_form<Ord, Ord>, HERMES_ANY, &tsln);
wf.add_vector_form_surf(linear_form_surf<double, double>, linear_form_surf<Ord, Ord>, BDY_AIR);
// 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 views.
ScalarView Tview("Temperature", new WinGeom(0, 0, 450, 600));
char title[100];
sprintf(title, "Time %3.5f, exterior temperature %3.5f", TIME, temp_ext(TIME));
Tview.set_min_max_range(0,20);
Tview.set_title(title);
Tview.fix_scale_width(3);
// Time stepping:
int nsteps = (int)(FINAL_TIME/TAU + 0.5);
bool rhs_only = false;
for(int ts = 1; ts <= nsteps; ts++)
{
info("---- Time step %d, time %3.5f, ext_temp %g", ts, TIME, temp_ext(TIME));
// First time assemble both the stiffness matrix and right-hand side vector,
// then just the right-hand side vector.
if (rhs_only == false) info("Assembling the stiffness matrix and right-hand side vector.");
else info("Assembling the right-hand side vector (only).");
dp.assemble(matrix, rhs, rhs_only);
rhs_only = true;
// 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, &tsln);
else
error ("Matrix solver failed.\n");
// Update the time variable.
TIME += TAU;
// Visualize the solution.
sprintf(title, "Time %3.2f, exterior temperature %3.5f", TIME, temp_ext(TIME));
Tview.set_title(title);
Tview.show(&tsln);
}
// 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[])
{
// 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(2, 5);
// Initialize an H1 space with default shepeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof = %d.", ndof);
// Initialize the solution.
Solution tsln;
// Set the initial condition.
tsln.set_const(&mesh, T_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, double>, bilinear_form<Ord, Ord>);
wf.add_matrix_form_surf(bilinear_form_surf<double, double>, bilinear_form_surf<Ord, Ord>, bdy_air);
wf.add_vector_form(linear_form<double, double>, linear_form<Ord, Ord>, HERMES_ANY, &tsln);
wf.add_vector_form_surf(linear_form_surf<double, double>, linear_form_surf<Ord, Ord>, bdy_air);
// 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);
// Time stepping:
int nsteps = (int)(FINAL_TIME/TAU + 0.5);
bool rhs_only = false;
for(int ts = 1; ts <= nsteps; ts++)
{
info("---- Time step %d, time %3.5f, ext_temp %g", ts, TIME, temp_ext(TIME));
// First time assemble both the stiffness matrix and right-hand side vector,
// then just the right-hand side vector.
if (rhs_only == false) info("Assembling the stiffness matrix and right-hand side vector.");
else info("Assembling the right-hand side vector (only).");
dp.assemble(matrix, rhs, rhs_only);
rhs_only = true;
// 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, &tsln);
else
error ("Matrix solver failed.\n");
// Update the time variable.
TIME += TAU;
}
double sum = 0;
for (int i=0; i < ndof; i++) sum += solver->get_solution()[i];
printf("coefficient sum = %g\n", sum);
// Actual test. The value of 'sum' depend on the
// current shapeset. If you change the shapeset,
// you need to correct this number.
int success = 1;
if (fabs(sum - 4737.73) > 1e-1) success = 0;
#define ERROR_SUCCESS 0
#define ERROR_FAILURE -1
if (success == 1) {
printf("Success!\n");
return ERROR_SUCCESS;
}
else {
printf("Failure!\n");
return ERROR_FAILURE;
}
}
int main(int argc, char* argv[])
{
// 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);
// Initialize an H1 space with default shepeset.
H1Space space(&mesh, bc_types, essential_bc_values, P_INIT);
int ndof = get_num_dofs(&space);
info("ndof = %d.", ndof);
// Set initial condition.
Solution tsln;
tsln.set_const(&mesh, T_INIT);
// Initialize weak formulation.
WeakForm wf;
wf.add_matrix_form(bilinear_form<double, double>, bilinear_form<Ord, Ord>);
wf.add_matrix_form_surf(bilinear_form_surf<double, double>, bilinear_form_surf<Ord, Ord>, bdy_air);
wf.add_vector_form(linear_form<double, double>, linear_form<Ord, Ord>, H2D_ANY, &tsln);
wf.add_vector_form_surf(linear_form_surf<double, double>, linear_form_surf<Ord, Ord>, bdy_air);
// Initialize the linear problem.
LinearProblem lp(&wf, &space);
// Initialize matrix solver.
Matrix* mat; Vector* rhs; CommonSolver* solver;
init_matrix_solver(matrix_solver, ndof, mat, rhs, solver);
// Time stepping:
int nsteps = (int)(FINAL_TIME/TAU + 0.5);
bool rhsonly = false;
for(int ts = 1; ts <= nsteps; ts++)
{
info("---- Time step %d, time %3.5f, ext_temp %g", ts, TIME, temp_ext(TIME));
// Assemble stiffness matrix and rhs.
lp.assemble(mat, rhs, rhsonly);
rhsonly = true;
// Solve the matrix problem.
if (!solver->solve(mat, rhs)) error ("Matrix solver failed.\n");
// Update tsln.
tsln.set_fe_solution(&space, rhs);
if (ts % OUTPUT_FREQUENCY == 0) {
Linearizer lin;
int item = H2D_FN_VAL_0;
double eps = H2D_EPS_NORMAL;
double max_abs = -1.0;
MeshFunction* xdisp = NULL;
MeshFunction* ydisp = NULL;
double dmult = 1.0;
lin.process_solution(&tsln, item, eps, max_abs, xdisp, ydisp, dmult);
char* filename = new char[100];
sprintf(filename, "tsln_%d.lin", ts);
// Save Linearizer data.
lin.save_data(filename);
info("Linearizer data saved to file %s.", filename);
// Save complete Solution.
sprintf(filename, "tsln_%d.dat", ts);
bool compress = false; // Gzip compression not used as it only works on Linux.
tsln.save(filename, compress);
info("Complete Solution saved to file %s.", filename);
}
// Update the time variable.
TIME += TAU;
}
info("Let's assume that the remote computation has finished and you fetched the *.lin files.");
info("Visualizing Linearizer data from file tsln_40.lin.");
// First use ScalarView to read and show the Linearizer data.
WinGeom* win_geom_1 = new WinGeom(0, 0, 450, 600);
ScalarView sview_1("Saved Linearizer data", win_geom_1);
sview_1.lin.load_data("tsln_40.lin");
sview_1.set_min_max_range(0,20);
sview_1.fix_scale_width(3);
sview_1.show_linearizer_data();
info("Visualizing Solution from file tsln_60.dat.");
Solution sln_from_file;
sln_from_file.load("tsln_60.dat");
WinGeom* win_geom_2 = new WinGeom(460, 0, 450, 600);
ScalarView sview_2("Saved Solution data", win_geom_2);
sview_2.set_min_max_range(0,20);
sview_2.fix_scale_width(3);
sview_2.show(&sln_from_file);
info("Visualizing Mesh and Orders extracted from the Solution.");
int p_init = 1;
// The NULLs are for bc_types() and essential_bc_values().
H1Space space_from_file(sln_from_file.get_mesh(), NULL, NULL, p_init);
space_from_file.set_element_orders(sln_from_file.get_element_orders());
WinGeom* win_geom_3 = new WinGeom(920, 0, 450, 600);
OrderView oview("Saved Solution -> Space", win_geom_3);
oview.show(&space_from_file);
// Wait for the view to be closed.
View::wait();
return 0;
}
