// The main program
int main(int argc, char** argv)
{
// Initialize libMesh
LibMeshInit init(argc, argv);
// Parameters
GetPot infile("fem_system_params.in");
const Real global_tolerance = infile("global_tolerance", 0.);
const unsigned int nelem_target = infile("n_elements", 400);
const bool transient = infile("transient", true);
const Real deltat = infile("deltat", 0.005);
unsigned int n_timesteps = infile("n_timesteps", 1);
//const unsigned int coarsegridsize = infile("coarsegridsize", 1);
const unsigned int coarserefinements = infile("coarserefinements", 0);
const unsigned int max_adaptivesteps = infile("max_adaptivesteps", 10);
//const unsigned int dim = 2;
#ifdef LIBMESH_HAVE_EXODUS_API
const unsigned int write_interval = infile("write_interval", 5);
#endif
// Create a mesh, with dimension to be overridden later, distributed
// across the default MPI communicator.
Mesh mesh(init.comm());
GetPot infileForMesh("convdiff_mprime.in");
std::string find_mesh_here = infileForMesh("mesh","psiLF_mesh.xda");
mesh.read(find_mesh_here);
std::cout << "Read in mesh from: " << find_mesh_here << "\n\n";
// And an object to refine it
MeshRefinement mesh_refinement(mesh);
mesh_refinement.coarsen_by_parents() = true;
mesh_refinement.absolute_global_tolerance() = global_tolerance;
mesh_refinement.nelem_target() = nelem_target;
mesh_refinement.refine_fraction() = 0.3;
mesh_refinement.coarsen_fraction() = 0.3;
mesh_refinement.coarsen_threshold() = 0.1;
//mesh_refinement.uniformly_refine(coarserefinements);
// Print information about the mesh to the screen.
mesh.print_info();
// Create an equation systems object.
EquationSystems equation_systems (mesh);
// Name system
ConvDiff_MprimeSys & system =
equation_systems.add_system<ConvDiff_MprimeSys>("Diff_ConvDiff_MprimeSys");
// Steady-state problem
system.time_solver =
AutoPtr<TimeSolver>(new SteadySolver(system));
// Sanity check that we are indeed solving a steady problem
libmesh_assert_equal_to (n_timesteps, 1);
// Read in all the equation systems data from the LF solve (system, solutions, rhs, etc)
std::string find_psiLF_here = infileForMesh("psiLF_file","psiLF.xda");
std::cout << "Looking for psiLF at: " << find_psiLF_here << "\n\n";
equation_systems.read(find_psiLF_here, READ,
EquationSystems::READ_HEADER |
EquationSystems::READ_DATA |
EquationSystems::READ_ADDITIONAL_DATA);
// Check that the norm of the solution read in is what we expect it to be
Real readin_L2 = system.calculate_norm(*system.solution, 0, L2);
std::cout << "Read in solution norm: "<< readin_L2 << std::endl << std::endl;
//DEBUG
//equation_systems.write("right_back_out.xda", WRITE, EquationSystems::WRITE_DATA |
// EquationSystems::WRITE_ADDITIONAL_DATA);
#ifdef LIBMESH_HAVE_GMV
//GMVIO(equation_systems.get_mesh()).write_equation_systems(std::string("right_back_out.gmv"), equation_systems);
#endif
// Initialize the system
//equation_systems.init (); //already initialized by read-in
// And the nonlinear solver options
NewtonSolver *solver = new NewtonSolver(system);
system.time_solver->diff_solver() = AutoPtr<DiffSolver>(solver);
solver->quiet = infile("solver_quiet", true);
solver->verbose = !solver->quiet;
solver->max_nonlinear_iterations =
infile("max_nonlinear_iterations", 15);
solver->relative_step_tolerance =
infile("relative_step_tolerance", 1.e-3);
solver->relative_residual_tolerance =
infile("relative_residual_tolerance", 0.0);
solver->absolute_residual_tolerance =
infile("absolute_residual_tolerance", 0.0);
// And the linear solver options
solver->max_linear_iterations =
infile("max_linear_iterations", 50000);
solver->initial_linear_tolerance =
infile("initial_linear_tolerance", 1.e-3);
// Print information about the system to the screen.
equation_systems.print_info();
// Now we begin the timestep loop to compute the time-accurate
// solution of the equations...not that this is transient, but eh, why not...
for (unsigned int t_step=0; t_step != n_timesteps; ++t_step)
{
// A pretty update message
std::cout << "\n\nSolving time step " << t_step << ", time = "
<< system.time << std::endl;
// Adaptively solve the timestep
unsigned int a_step = 0;
for (; a_step != max_adaptivesteps; ++a_step)
{ // VESTIGIAL for now ('vestigial' eh ? ;) )
std::cout << "\n\n I should be skipped what are you doing here lalalalalalala *!**!*!*!*!*!* \n\n";
system.solve();
system.postprocess();
ErrorVector error;
AutoPtr<ErrorEstimator> error_estimator;
// To solve to a tolerance in this problem we
// need a better estimator than Kelly
if (global_tolerance != 0.)
{
// We can't adapt to both a tolerance and a mesh
// size at once
libmesh_assert_equal_to (nelem_target, 0);
UniformRefinementEstimator *u =
new UniformRefinementEstimator;
// The lid-driven cavity problem isn't in H1, so
// lets estimate L2 error
u->error_norm = L2;
error_estimator.reset(u);
}
else
{
// If we aren't adapting to a tolerance we need a
// target mesh size
libmesh_assert_greater (nelem_target, 0);
// Kelly is a lousy estimator to use for a problem
// not in H1 - if we were doing more than a few
// timesteps we'd need to turn off or limit the
// maximum level of our adaptivity eventually
error_estimator.reset(new KellyErrorEstimator);
}
// Calculate error
std::vector<Real> weights(9,1.0); // based on u, v, p, c, their adjoints, and source parameter
// Keep the same default norm type.
std::vector<FEMNormType>
norms(1, error_estimator->error_norm.type(0));
error_estimator->error_norm = SystemNorm(norms, weights);
error_estimator->estimate_error(system, error);
// Print out status at each adaptive step.
Real global_error = error.l2_norm();
std::cout << "Adaptive step " << a_step << ": " << std::endl;
if (global_tolerance != 0.)
std::cout << "Global_error = " << global_error
<< std::endl;
if (global_tolerance != 0.)
std::cout << "Worst element error = " << error.maximum()
<< ", mean = " << error.mean() << std::endl;
if (global_tolerance != 0.)
{
// If we've reached our desired tolerance, we
// don't need any more adaptive steps
if (global_error < global_tolerance)
break;
mesh_refinement.flag_elements_by_error_tolerance(error);
}
else
{
// If flag_elements_by_nelem_target returns true, this
// should be our last adaptive step.
if (mesh_refinement.flag_elements_by_nelem_target(error))
{
mesh_refinement.refine_and_coarsen_elements();
equation_systems.reinit();
a_step = max_adaptivesteps;
break;
}
}
// Carry out the adaptive mesh refinement/coarsening
mesh_refinement.refine_and_coarsen_elements();
equation_systems.reinit();
std::cout << "Refined mesh to "
<< mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl;
} // End loop over adaptive steps
// Do one last solve if necessary
if (a_step == max_adaptivesteps)
{
QoISet qois;
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qois.add_indices(qoi_indices);
qois.set_weight(0, 1.0);
system.assemble_qoi_sides = true; //QoI doesn't involve sides
std::cout << "\n~*~*~*~*~*~*~*~*~ adjoint solve start ~*~*~*~*~*~*~*~*~\n" << std::endl;
std::pair<unsigned int, Real> adjsolve = system.adjoint_solve();
std::cout << "number of iterations to solve adjoint: " << adjsolve.first << std::endl;
std::cout << "final residual of adjoint solve: " << adjsolve.second << std::endl;
std::cout << "\n~*~*~*~*~*~*~*~*~ adjoint solve end ~*~*~*~*~*~*~*~*~" << std::endl;
NumericVector<Number> &dual_solution = system.get_adjoint_solution(0);
NumericVector<Number> &primal_solution = *system.solution;
primal_solution.swap(dual_solution);
ExodusII_IO(mesh).write_timestep("super_adjoint.exo",
equation_systems,
1, /* This number indicates how many time steps
are being written to the file */
system.time);
primal_solution.swap(dual_solution);
system.assemble(); //overwrite residual read in from psiLF solve
// The total error estimate
system.postprocess(); //to compute M_HF(psiLF) and M_LF(psiLF) terms
Real QoI_error_estimate = (-0.5*(system.rhs)->dot(dual_solution)) + system.get_MHF_psiLF() - system.get_MLF_psiLF();
std::cout << "\n\n 0.5*M'_HF(psiLF)(superadj): " << std::setprecision(17) << 0.5*(system.rhs)->dot(dual_solution) << "\n";
std::cout << " M_HF(psiLF): " << std::setprecision(17) << system.get_MHF_psiLF() << "\n";
std::cout << " M_LF(psiLF): " << std::setprecision(17) << system.get_MLF_psiLF() << "\n";
std::cout << "\n\n Residual L2 norm: " << system.calculate_norm(*system.rhs, L2) << "\n";
std::cout << " Residual discrete L2 norm: " << system.calculate_norm(*system.rhs, DISCRETE_L2) << "\n";
std::cout << " Super-adjoint L2 norm: " << system.calculate_norm(dual_solution, L2) << "\n";
std::cout << " Super-adjoint discrete L2 norm: " << system.calculate_norm(dual_solution, DISCRETE_L2) << "\n";
std::cout << "\n\n QoI error estimate: " << std::setprecision(17) << QoI_error_estimate << "\n\n";
//DEBUG
std::cout << "\n------------ herp derp ------------" << std::endl;
//libMesh::out.precision(16);
//dual_solution.print();
//system.get_adjoint_rhs().print();
AutoPtr<NumericVector<Number> > adjresid = system.solution->clone();
(system.matrix)->vector_mult(*adjresid,system.get_adjoint_solution(0));
SparseMatrix<Number>& adjmat = *system.matrix;
(system.matrix)->get_transpose(adjmat);
adjmat.vector_mult(*adjresid,system.get_adjoint_solution(0));
//std::cout << "******************** matrix-superadj product (libmesh) ************************" << std::endl;
//adjresid->print();
adjresid->add(-1.0, system.get_adjoint_rhs(0));
//std::cout << "******************** superadjoint system residual (libmesh) ***********************" << std::endl;
//adjresid->print();
std::cout << "\n\nadjoint system residual (discrete L2): " << system.calculate_norm(*adjresid,DISCRETE_L2) << std::endl;
std::cout << "adjoint system residual (L2, all): " << system.calculate_norm(*adjresid,L2) << std::endl;
std::cout << "adjoint system residual (L2, 0): " << system.calculate_norm(*adjresid,0,L2) << std::endl;
std::cout << "adjoint system residual (L2, 1): " << system.calculate_norm(*adjresid,1,L2) << std::endl;
std::cout << "adjoint system residual (L2, 2): " << system.calculate_norm(*adjresid,2,L2) << std::endl;
std::cout << "adjoint system residual (L2, 3): " << system.calculate_norm(*adjresid,3,L2) << std::endl;
std::cout << "adjoint system residual (L2, 4): " << system.calculate_norm(*adjresid,4,L2) << std::endl;
std::cout << "adjoint system residual (L2, 5): " << system.calculate_norm(*adjresid,5,L2) << std::endl;
/*
AutoPtr<NumericVector<Number> > sadj_matlab = system.solution->clone();
AutoPtr<NumericVector<Number> > adjresid_matlab = system.solution->clone();
if(FILE *fp=fopen("superadj_matlab.txt","r")){
Real value;
int counter = 0;
int flag = 1;
while(flag != -1){
flag = fscanf(fp,"%lf",&value);
if(flag != -1){
sadj_matlab->set(counter, value);
counter += 1;
}
}
fclose(fp);
}
(system.matrix)->vector_mult(*adjresid_matlab,*sadj_matlab);
//std::cout << "******************** matrix-superadj product (matlab) ***********************" << std::endl;
//adjresid_matlab->print();
adjresid_matlab->add(-1.0, system.get_adjoint_rhs(0));
//std::cout << "******************** superadjoint system residual (matlab) ***********************" << std::endl;
//adjresid_matlab->print();
std::cout << "\n\nmatlab import adjoint system residual (discrete L2): " << system.calculate_norm(*adjresid_matlab,DISCRETE_L2) << "\n" << std::endl;
*/
/*
AutoPtr<NumericVector<Number> > sadj_fwd_hack = system.solution->clone();
AutoPtr<NumericVector<Number> > adjresid_fwd_hack = system.solution->clone();
if(FILE *fp=fopen("superadj_forward_hack.txt","r")){
Real value;
int counter = 0;
int flag = 1;
while(flag != -1){
flag = fscanf(fp,"%lf",&value);
if(flag != -1){
sadj_fwd_hack->set(counter, value);
counter += 1;
}
}
fclose(fp);
}
(system.matrix)->vector_mult(*adjresid_fwd_hack,*sadj_fwd_hack);
//std::cout << "******************** matrix-superadj product (fwd_hack) ***********************" << std::endl;
//adjresid_fwd_hack->print();
adjresid_fwd_hack->add(-1.0, system.get_adjoint_rhs(0));
//std::cout << "******************** superadjoint system residual (fwd_hack) ***********************" << std::endl;
//adjresid_fwd_hack->print();
std::cout << "\n\nfwd_hack import adjoint system residual (discrete L2): " << system.calculate_norm(*adjresid_fwd_hack,DISCRETE_L2) << "\n" << std::endl;
std::cout << "fwd_hack adjoint system residual (L2, 0): " << system.calculate_norm(*adjresid_fwd_hack,0,L2) << std::endl;
std::cout << "fwd_hack adjoint system residual (L2, 1): " << system.calculate_norm(*adjresid_fwd_hack,1,L2) << std::endl;
std::cout << "fwd_hack adjoint system residual (L2, 2): " << system.calculate_norm(*adjresid_fwd_hack,2,L2) << std::endl;
std::cout << "fwd_hack adjoint system residual (L2, 3): " << system.calculate_norm(*adjresid_fwd_hack,3,L2) << std::endl;
std::cout << "fwd_hack adjoint system residual (L2, 4): " << system.calculate_norm(*adjresid_fwd_hack,4,L2) << std::endl;
std::cout << "fwd_hack adjoint system residual (L2, 5): " << system.calculate_norm(*adjresid_fwd_hack,5,L2) << std::endl;
*/
//std::cout << "************************ system.matrix ***********************" << std::endl;
//system.matrix->print();
std::cout << "\n------------ herp derp ------------" << std::endl;
// The cell wise breakdown
ErrorVector cell_wise_error;
cell_wise_error.resize((system.rhs)->size());
for(unsigned int i = 0; i < (system.rhs)->size() ; i++)
{
if(i < system.get_mesh().n_elem())
cell_wise_error[i] = fabs(-0.5*((system.rhs)->el(i) * dual_solution(i))
+ system.get_MHF_psiLF(i) - system.get_MLF_psiLF(i));
else
cell_wise_error[i] = fabs(-0.5*((system.rhs)->el(i) * dual_solution(i)));
/*csv from 'save data' from gmv output gives a few values at each node point (value
for every element that shares that node), yet paraview display only seems to show one
of them -> the value in an element is given at each of the nodes that it has, hence the
repetition; what is displayed in paraview is each element's value; even though MHF_psiLF
and MLF_psiLF are stored by element this seems to give elemental contributions that
agree with if we had taken the superadj-residual dot product by integrating over elements*/
/*at higher mesh resolutions and lower k, weird-looking artifacts start to appear and
it no longer agrees with output from manual integration of superadj-residual...*/
}
// Plot it
std::ostringstream error_gmv;
error_gmv << "error.gmv";
cell_wise_error.plot_error(error_gmv.str(), equation_systems.get_mesh());
//alternate element-wise breakdown, outputed as values matched to element centroids; for matlab plotz
primal_solution.swap(dual_solution);
system.postprocess(1);
primal_solution.swap(dual_solution);
system.postprocess(2);
std::cout << "\n\n -0.5*M'_HF(psiLF)(superadj): " << std::setprecision(17) << system.get_half_adj_weighted_resid() << "\n";
primal_solution.swap(dual_solution);
std::string write_error_here = infileForMesh("error_est_output_file", "error_est_breakdown.dat");
std::ofstream output(write_error_here);
for(unsigned int i = 0 ; i < system.get_mesh().n_elem(); i++) {
Point elem_cent = system.get_mesh().elem(i)->centroid();
if(output.is_open()) {
output << elem_cent(0) << " " << elem_cent(1) << " "
<< fabs(system.get_half_adj_weighted_resid(i) + system.get_MHF_psiLF(i) - system.get_MLF_psiLF(i)) << "\n";
}
}
output.close();
} // End if at max adaptive steps
#ifdef LIBMESH_HAVE_EXODUS_API
// Write out this timestep if we're requested to
if ((t_step+1)%write_interval == 0)
{
std::ostringstream file_name;
/*
// We write the file in the ExodusII format.
file_name << "out_"
<< std::setw(3)
<< std::setfill('0')
<< std::right
<< t_step+1
<< ".e";
//this should write out the primal which should be the same as what's read in...
ExodusII_IO(mesh).write_timestep(file_name.str(),
equation_systems,
1, //number of time steps written to file
system.time);
*/
}
#endif // #ifdef LIBMESH_HAVE_EXODUS_API
}
// All done.
return 0;
} //end main
// The main program.
int main (int argc, char** argv)
{
// Initialize libMesh.
LibMeshInit init (argc, argv);
// This example requires a linear solver package.
libmesh_example_requires(libMesh::default_solver_package() != INVALID_SOLVER_PACKAGE,
"--enable-petsc, --enable-trilinos, or --enable-eigen");
// Skip adaptive examples on a non-adaptive libMesh build
#ifndef LIBMESH_ENABLE_AMR
libmesh_example_requires(false, "--enable-amr");
#else
// This doesn't converge with Eigen BICGSTAB for some reason...
libmesh_example_requires(libMesh::default_solver_package() != EIGEN_SOLVERS, "--enable-petsc");
libMesh::out << "Started " << argv[0] << std::endl;
// Make sure the general input file exists, and parse it
{
std::ifstream i("general.in");
if (!i)
libmesh_error_msg('[' << init.comm().rank() << "] Can't find general.in; exiting early.");
}
GetPot infile("general.in");
// Read in parameters from the input file
FEMParameters param(init.comm());
param.read(infile);
// Skip this default-2D example if libMesh was compiled as 1D-only.
libmesh_example_requires(2 <= LIBMESH_DIM, "2D support");
// Create a mesh, with dimension to be overridden later, distributed
// across the default MPI communicator.
Mesh mesh(init.comm());
// And an object to refine it
std::unique_ptr<MeshRefinement> mesh_refinement =
build_mesh_refinement(mesh, param);
// And an EquationSystems to run on it
EquationSystems equation_systems (mesh);
libMesh::out << "Reading in and building the mesh" << std::endl;
// Read in the mesh
mesh.read(param.domainfile.c_str());
// Make all the elements of the mesh second order so we can compute
// with a higher order basis
mesh.all_second_order();
// Create a mesh refinement object to do the initial uniform refinements
// on the coarse grid read in from lshaped.xda
MeshRefinement initial_uniform_refinements(mesh);
initial_uniform_refinements.uniformly_refine(param.coarserefinements);
libMesh::out << "Building system" << std::endl;
// Build the FEMSystem
LaplaceSystem & system = equation_systems.add_system<LaplaceSystem> ("LaplaceSystem");
// Set its parameters
set_system_parameters(system, param);
libMesh::out << "Initializing systems" << std::endl;
equation_systems.init ();
// Print information about the mesh and system to the screen.
mesh.print_info();
equation_systems.print_info();
LinearSolver<Number> *linear_solver = system.get_linear_solver();
{
// Adaptively solve the timestep
unsigned int a_step = 0;
for (; a_step != param.max_adaptivesteps; ++a_step)
{
// We can't adapt to both a tolerance and a
// target mesh size
if (param.global_tolerance != 0.)
libmesh_assert_equal_to (param.nelem_target, 0);
// If we aren't adapting to a tolerance we need a
// target mesh size
else
libmesh_assert_greater (param.nelem_target, 0);
linear_solver->reuse_preconditioner(false);
// Solve the forward problem
system.solve();
// Write out the computed primal solution
write_output(equation_systems, a_step, "primal", param);
// Get a pointer to the primal solution vector
NumericVector<Number> & primal_solution = *system.solution;
// Declare a QoISet object, we need this object to set weights for our QoI error contributions
QoISet qois;
// Declare a qoi_indices vector, each index will correspond to a QoI
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qoi_indices.push_back(1);
qois.add_indices(qoi_indices);
// Set weights for each index, these will weight the contribution of each QoI in the final error
// estimate to be used for flagging elements for refinement
qois.set_weight(0, 0.5);
qois.set_weight(1, 0.5);
// Make sure we get the contributions to the adjoint RHS from the sides
system.assemble_qoi_sides = true;
// We are about to solve the adjoint system, but before we do this we see the same preconditioner
// flag to reuse the preconditioner from the forward solver
linear_solver->reuse_preconditioner(param.reuse_preconditioner);
// Solve the adjoint system. This takes the transpose of the stiffness matrix and then
// solves the resulting system
system.adjoint_solve();
// Now that we have solved the adjoint, set the adjoint_already_solved boolean to true, so we dont solve unnecessarily in the error estimator
system.set_adjoint_already_solved(true);
// Get a pointer to the solution vector of the adjoint problem for QoI 0
NumericVector<Number> & dual_solution_0 = system.get_adjoint_solution(0);
// Swap the primal and dual solutions so we can write out the adjoint solution
primal_solution.swap(dual_solution_0);
write_output(equation_systems, a_step, "adjoint_0", param);
// Swap back
primal_solution.swap(dual_solution_0);
// Get a pointer to the solution vector of the adjoint problem for QoI 0
NumericVector<Number> & dual_solution_1 = system.get_adjoint_solution(1);
// Swap again
primal_solution.swap(dual_solution_1);
write_output(equation_systems, a_step, "adjoint_1", param);
// Swap back again
primal_solution.swap(dual_solution_1);
libMesh::out << "Adaptive step "
<< a_step
<< ", we have "
<< mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs."
<< std::endl;
// Postprocess, compute the approximate QoIs and write them out to the console
libMesh::out << "Postprocessing: " << std::endl;
system.postprocess_sides = true;
system.postprocess();
Number QoI_0_computed = system.get_QoI_value("computed", 0);
Number QoI_0_exact = system.get_QoI_value("exact", 0);
Number QoI_1_computed = system.get_QoI_value("computed", 1);
Number QoI_1_exact = system.get_QoI_value("exact", 1);
libMesh::out << "The relative error in QoI 0 is "
<< std::setprecision(17)
<< std::abs(QoI_0_computed - QoI_0_exact) / std::abs(QoI_0_exact)
<< std::endl;
libMesh::out << "The relative error in QoI 1 is "
<< std::setprecision(17)
<< std::abs(QoI_1_computed - QoI_1_exact) / std::abs(QoI_1_exact)
<< std::endl
<< std::endl;
// We will declare an error vector for passing to the adjoint refinement error estimator
ErrorVector QoI_elementwise_error;
// Build an adjoint refinement error estimator object
std::unique_ptr<AdjointRefinementEstimator> adjoint_refinement_error_estimator =
build_adjoint_refinement_error_estimator(qois);
// Estimate the error in each element using the Adjoint Refinement estimator
adjoint_refinement_error_estimator->estimate_error(system, QoI_elementwise_error);
// Print out the computed error estimate, note that we access the global error estimates
// using an accessor function, right now sum(QoI_elementwise_error) != global_QoI_error_estimate
libMesh::out << "The computed relative error in QoI 0 is "
<< std::setprecision(17)
<< std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(0)) / std::abs(QoI_0_exact)
<< std::endl;
libMesh::out << "The computed relative error in QoI 1 is "
<< std::setprecision(17)
<< std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(1)) / std::abs(QoI_1_exact)
<< std::endl
<< std::endl;
// Also print out effectivity indices (estimated error/true error)
libMesh::out << "The effectivity index for the computed error in QoI 0 is "
<< std::setprecision(17)
<< std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(0)) / std::abs(QoI_0_computed - QoI_0_exact)
<< std::endl;
libMesh::out << "The effectivity index for the computed error in QoI 1 is "
<< std::setprecision(17)
<< std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(1)) / std::abs(QoI_1_computed - QoI_1_exact)
<< std::endl
<< std::endl;
// For refinement purposes we need to sort by error
// *magnitudes*, but AdjointRefinement gives us signed errors.
if (!param.refine_uniformly)
for (std::size_t i=0; i<QoI_elementwise_error.size(); i++)
if (QoI_elementwise_error[i] != 0.)
QoI_elementwise_error[i] = std::abs(QoI_elementwise_error[i]);
// We have to refine either based on reaching an error tolerance or
// a number of elements target, which should be verified above
// Otherwise we flag elements by error tolerance or nelem target
// Uniform refinement
if (param.refine_uniformly)
{
mesh_refinement->uniformly_refine(1);
}
// Adaptively refine based on reaching an error tolerance
else if (param.global_tolerance >= 0. && param.nelem_target == 0.)
{
mesh_refinement->flag_elements_by_error_tolerance (QoI_elementwise_error);
mesh_refinement->refine_and_coarsen_elements();
}
// Adaptively refine based on reaching a target number of elements
else
{
if (mesh.n_active_elem() >= param.nelem_target)
{
libMesh::out << "We reached the target number of elements." << std::endl << std::endl;
break;
}
mesh_refinement->flag_elements_by_nelem_target (QoI_elementwise_error);
mesh_refinement->refine_and_coarsen_elements();
}
// Dont forget to reinit the system after each adaptive refinement !
equation_systems.reinit();
libMesh::out << "Refined mesh to "
<< mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs."
<< std::endl;
}
// Do one last solve if necessary
if (a_step == param.max_adaptivesteps)
{
linear_solver->reuse_preconditioner(false);
system.solve();
write_output(equation_systems, a_step, "primal", param);
NumericVector<Number> & primal_solution = *system.solution;
QoISet qois;
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qoi_indices.push_back(1);
qois.add_indices(qoi_indices);
qois.set_weight(0, 0.5);
qois.set_weight(1, 0.5);
system.assemble_qoi_sides = true;
linear_solver->reuse_preconditioner(param.reuse_preconditioner);
system.adjoint_solve();
// Now that we have solved the adjoint, set the adjoint_already_solved boolean to true, so we dont solve unnecessarily in the error estimator
system.set_adjoint_already_solved(true);
NumericVector<Number> & dual_solution_0 = system.get_adjoint_solution(0);
primal_solution.swap(dual_solution_0);
write_output(equation_systems, a_step, "adjoint_0", param);
primal_solution.swap(dual_solution_0);
NumericVector<Number> & dual_solution_1 = system.get_adjoint_solution(1);
primal_solution.swap(dual_solution_1);
write_output(equation_systems, a_step, "adjoint_1", param);
primal_solution.swap(dual_solution_1);
libMesh::out << "Adaptive step "
<< a_step
<< ", we have "
<< mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs."
<< std::endl;
libMesh::out << "Postprocessing: " << std::endl;
system.postprocess_sides = true;
system.postprocess();
Number QoI_0_computed = system.get_QoI_value("computed", 0);
Number QoI_0_exact = system.get_QoI_value("exact", 0);
Number QoI_1_computed = system.get_QoI_value("computed", 1);
Number QoI_1_exact = system.get_QoI_value("exact", 1);
libMesh::out << "The relative error in QoI 0 is "
<< std::setprecision(17)
<< std::abs(QoI_0_computed - QoI_0_exact) / std::abs(QoI_0_exact)
<< std::endl;
libMesh::out << "The relative error in QoI 1 is "
<< std::setprecision(17)
<< std::abs(QoI_1_computed - QoI_1_exact) / std::abs(QoI_1_exact)
<< std::endl
<< std::endl;
// We will declare an error vector for passing to the adjoint refinement error estimator
// Right now, only the first entry of this vector will be filled (with the global QoI error estimate)
// Later, each entry of the vector will contain elementwise error that the user can sum to get the total error
ErrorVector QoI_elementwise_error;
// Build an adjoint refinement error estimator object
std::unique_ptr<AdjointRefinementEstimator> adjoint_refinement_error_estimator =
build_adjoint_refinement_error_estimator(qois);
// Estimate the error in each element using the Adjoint Refinement estimator
adjoint_refinement_error_estimator->estimate_error(system, QoI_elementwise_error);
// Print out the computed error estimate, note that we access the global error estimates
// using an accessor function, right now sum(QoI_elementwise_error) != global_QoI_error_estimate
libMesh::out << "The computed relative error in QoI 0 is "
<< std::setprecision(17)
<< std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(0)) / std::abs(QoI_0_exact)
<< std::endl;
libMesh::out << "The computed relative error in QoI 1 is "
<< std::setprecision(17)
<< std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(1)) / std::abs(QoI_1_exact)
<< std::endl
<< std::endl;
// Also print out effectivity indices (estimated error/true error)
libMesh::out << "The effectivity index for the computed error in QoI 0 is "
<< std::setprecision(17)
<< std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(0)) / std::abs(QoI_0_computed - QoI_0_exact)
<< std::endl;
libMesh::out << "The effectivity index for the computed error in QoI 1 is "
<< std::setprecision(17)
<< std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(1)) / std::abs(QoI_1_computed - QoI_1_exact)
<< std::endl
<< std::endl;
// Hard coded assert to ensure that the actual numbers we are getting are what they should be
// The effectivity index isn't exactly reproducible at single precision
// libmesh_assert_less(std::abs(std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(0)) / std::abs(QoI_0_computed - QoI_0_exact) - 0.84010976704434637), 1.e-5);
// libmesh_assert_less(std::abs(std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(1)) / std::abs(QoI_1_computed - QoI_1_exact) - 0.48294428289950514), 1.e-5);
// But the effectivity indices should always be sane
libmesh_assert_less(std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(0)) / std::abs(QoI_0_computed - QoI_0_exact), 2.5);
libmesh_assert_greater(std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(0)) / std::abs(QoI_0_computed - QoI_0_exact), .4);
libmesh_assert_less(std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(1)) / std::abs(QoI_1_computed - QoI_1_exact), 2.5);
libmesh_assert_greater(std::abs(adjoint_refinement_error_estimator->get_global_QoI_error_estimate(1)) / std::abs(QoI_1_computed - QoI_1_exact), .4);
// And the computed errors should still be low
libmesh_assert_less(std::abs(QoI_0_computed - QoI_0_exact), 2e-4);
libmesh_assert_less(std::abs(QoI_1_computed - QoI_1_exact), 2e-4);
}
}
libMesh::err << '[' << mesh.processor_id()
<< "] Completing output."
<< std::endl;
#endif // #ifndef LIBMESH_ENABLE_AMR
// All done.
return 0;
}
// **********************************************************************
// The main program.
int main (int argc, char** argv)
{
// Initialize libMesh.
LibMeshInit init (argc, argv);
// Skip adaptive examples on a non-adaptive libMesh build
#ifndef LIBMESH_ENABLE_AMR
libmesh_example_requires(false, "--enable-amr");
#else
std::cout << "Started " << argv[0] << std::endl;
// Make sure the general input file exists, and parse it
{
std::ifstream i("general.in");
if (!i)
libmesh_error_msg('[' << init.comm().rank() << "] Can't find general.in; exiting early.");
}
GetPot infile("general.in");
// Read in parameters from the input file
FEMParameters param;
param.read(infile);
// Create a mesh, with dimension to be overridden later, distributed
// across the default MPI communicator.
Mesh mesh(init.comm());
// And an object to refine it
AutoPtr<MeshRefinement> mesh_refinement =
build_mesh_refinement(mesh, param);
// And an EquationSystems to run on it
EquationSystems equation_systems (mesh);
std::cout << "Building the mesh" << std::endl;
MeshTools::Generation::build_square (mesh,
20,
20,
0., 1.,
0., 1.,
QUAD9); //if changed, check pressure pinning
// Create a mesh refinement object to do the initial uniform refinements
//MeshRefinement initial_uniform_refinements(mesh);
//initial_uniform_refinements.uniformly_refine(param.coarserefinements);
std::cout << "Building system" << std::endl;
// Build the FEMSystem
ConvDiffSys &system = equation_systems.add_system<ConvDiffSys> ("ConvDiffSys");
// Set its parameters
set_system_parameters(system, param);
std::cout << "Initializing systems" << std::endl;
equation_systems.init ();
// Print information about the mesh and system to the screen.
mesh.print_info();
equation_systems.print_info();
LinearSolver<Number> *linear_solver = system.get_linear_solver();
{
// Adaptively solve the timestep
unsigned int a_step = 0;
for (; a_step != param.max_adaptivesteps; ++a_step)
{
// We can't adapt to both a tolerance and a
// target mesh size
if (param.global_tolerance != 0.)
libmesh_assert_equal_to (param.nelem_target, 0);
// If we aren't adapting to a tolerance we need a
// target mesh size
else
libmesh_assert_greater (param.nelem_target, 0);
linear_solver->reuse_preconditioner(false); //can reuse for adjoint, but not for new forwards solve
// Solve the forward problem
system.solve();
// Write out the computed primal solution
write_output(equation_systems, a_step, "primal");
// Get a pointer to the primal solution vector
NumericVector<Number> &primal_solution = *system.solution;
// Declare a QoISet object, we need this object to set weights for our QoI error contributions
QoISet qois;
// Declare a qoi_indices vector, each index will correspond to a QoI
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qois.add_indices(qoi_indices);
// Set weights for each index, these will weight the contribution of each QoI in the final error
// estimate to be used for flagging elements for refinement
qois.set_weight(0, 1.0);
// A SensitivityData object to hold the qois and parameters
SensitivityData sensitivities_adj(qois, system, system.get_parameter_vector()); //use adjoint solve
SensitivityData sensitivities_for(qois, system, system.get_parameter_vector()); //use forward solve
// Make sure we get the contributions to the adjoint RHS from the sides
system.assemble_qoi_sides = true; //does nothing anyways...
// We are about to solve the adjoint system, but before we do this we see the same preconditioner
// flag to reuse the preconditioner from the forward solver
linear_solver->reuse_preconditioner(param.reuse_preconditioner);
// Here we solve the adjoint problem inside the adjoint_qoi_parameter_sensitivity
// function, so we have to set the adjoint_already_solved boolean to false
system.set_adjoint_already_solved(false);
// Compute the sensitivities
system.adjoint_qoi_parameter_sensitivity(qois, system.get_parameter_vector(), sensitivities_adj);
system.adjoint_qoi_parameter_sensitivity(qois, system.get_parameter_vector(), sensitivities_for);
// Now that we have solved the adjoint, set the adjoint_already_solved boolean to true,
//so we dont solve unneccesarily in the error estimator
system.set_adjoint_already_solved(true);
std::cout << "(Adjoint) Sensitivity of QoI to rho is " << sensitivities_adj[0][0] << std::endl;
std::cout << "(Forward) Sensitivity of QoI to rho is " << sensitivities_for[0][0] << std::endl;
// Get a pointer to the solution vector of the adjoint problem for QoI 0
NumericVector<Number> &dual_solution = system.get_adjoint_solution(0);
// Swap the (pointers to) primal and dual solutions so we can write out the adjoint solution
primal_solution.swap(dual_solution);
write_output(equation_systems, a_step, "adjoint");
// Swap back
primal_solution.swap(dual_solution);
std::cout << "Adaptive step " << a_step << ", we have " << mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl ;
// Postprocess, compute the approximate QoIs and write them out to the console
std::cout << "Postprocessing: " << std::endl;
system.postprocess_sides = false; //QoI doesn't involve edges
system.postprocess();
Number QoI_computed = system.get_QoI_value("computed", 0);
std::cout<< "Computed QoI is " << std::setprecision(17)
<< QoI_computed << std::endl;
// Now we construct the data structures for the mesh refinement process
ErrorVector error;
// Build an error estimator object
AutoPtr<ErrorEstimator> error_estimator =
build_error_estimator(param, qois);
// Estimate the error in each element using the Adjoint Residual or Kelly error estimator
error_estimator->estimate_error(system, error);
// We have to refine either based on reaching an error tolerance or
// a number of elements target, which should be verified above
// Otherwise we flag elements by error tolerance or nelem target
// Uniform refinement
if(param.refine_uniformly)
{
mesh_refinement->uniformly_refine(1);
}
// Adaptively refine based on reaching an error tolerance
else if(param.global_tolerance >= 0. && param.nelem_target == 0.)
{
mesh_refinement->flag_elements_by_error_tolerance (error);
mesh_refinement->refine_and_coarsen_elements();
}
// Adaptively refine based on reaching a target number of elements
else
{
if (mesh.n_active_elem() >= param.nelem_target)
{
std::cout<<"We reached the target number of elements."<<std::endl <<std::endl;
break;
}
mesh_refinement->flag_elements_by_nelem_target (error);
mesh_refinement->refine_and_coarsen_elements();
}
// Dont forget to reinit the system after each adaptive refinement !
equation_systems.reinit();
std::cout << "Refined mesh to "
<< mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl;
}
// Do one last solve if necessary
if (a_step == param.max_adaptivesteps)
{
linear_solver->reuse_preconditioner(false);
system.solve();
write_output(equation_systems, a_step, "primal");
NumericVector<Number> &primal_solution = *system.solution;
QoISet qois;
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qois.add_indices(qoi_indices);
qois.set_weight(0, 1.0);
SensitivityData sensitivities_adj(qois, system, system.get_parameter_vector());
SensitivityData sensitivities_for(qois, system, system.get_parameter_vector());
system.assemble_qoi_sides = false; //QoI doesn't involve sides
linear_solver->reuse_preconditioner(param.reuse_preconditioner);
system.set_adjoint_already_solved(false);
system.adjoint_qoi_parameter_sensitivity(qois, system.get_parameter_vector(), sensitivities_adj);
system.forward_qoi_parameter_sensitivity(qois, system.get_parameter_vector(), sensitivities_for);
// Now that we have solved the adjoint, set the adjoint_already_solved boolean to true,
// so we dont solve unneccesarily in the error estimator
system.set_adjoint_already_solved(true);
std::cout << "(Adjoint) Sensitivity of QoI to rho is " << sensitivities_adj[0][0] << std::endl;
std::cout << "(Forward) Sensitivity of QoI to rho is " << sensitivities_for[0][0] << std::endl;
NumericVector<Number> &dual_solution = system.get_adjoint_solution(0);
primal_solution.swap(dual_solution);
write_output(equation_systems, a_step, "adjoint");
primal_solution.swap(dual_solution);
std::cout << "Adaptive step " << a_step << ", we have " << mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl ;
std::cout << "Postprocessing: " << std::endl;
system.postprocess_sides = false; //nothing special on sides
system.postprocess();
Number QoI_computed = system.get_QoI_value("computed", 0);
std::cout<< "Computed QoI is " << std::setprecision(17)
<< QoI_computed << std::endl;
}
}
std::cerr << '[' << mesh.processor_id()
<< "] Completing output." << std::endl;
#endif // #ifndef LIBMESH_ENABLE_AMR
// All done.
return 0;
}
// The main program.
int main (int argc, char** argv)
{
// Initialize libMesh.
LibMeshInit init (argc, argv);
// Skip adaptive examples on a non-adaptive libMesh build
#ifndef LIBMESH_ENABLE_AMR
libmesh_example_assert(false, "--enable-amr");
#else
// Only our PETSc interface currently supports adjoint solves
libmesh_example_assert(libMesh::default_solver_package() == PETSC_SOLVERS, "--enable-petsc");
std::cout << "Started " << argv[0] << std::endl;
// Make sure the general input file exists, and parse it
{
std::ifstream i("general.in");
if (!i)
{
std::cerr << '[' << libMesh::processor_id()
<< "] Can't find general.in; exiting early."
<< std::endl;
libmesh_error();
}
}
GetPot infile("general.in");
GetPot infile_l_shaped("l-shaped.in");
// Read in parameters from the input file
FEMParameters param;
param.read(infile);
// Skip this default-2D example if libMesh was compiled as 1D-only.
libmesh_example_assert(2 <= LIBMESH_DIM, "2D support");
// Create a mesh.
Mesh mesh;
// And an object to refine it
AutoPtr<MeshRefinement> mesh_refinement =
build_mesh_refinement(mesh, param);
// And an EquationSystems to run on it
EquationSystems equation_systems (mesh);
std::cout << "Reading in and building the mesh" << std::endl;
// Read in the mesh
mesh.read(param.domainfile.c_str());
// Make all the elements of the mesh second order so we can compute
// with a higher order basis
mesh.all_second_order();
// Create a mesh refinement object to do the initial uniform refinements
// on the coarse grid read in from lshaped.xda
MeshRefinement initial_uniform_refinements(mesh);
initial_uniform_refinements.uniformly_refine(param.coarserefinements);
std::cout << "Building system" << std::endl;
// Build the FEMSystem
LaplaceSystem &system = equation_systems.add_system<LaplaceSystem> ("LaplaceSystem");
// Set its parameters
set_system_parameters(system, param);
std::cout << "Initializing systems" << std::endl;
equation_systems.init ();
// Print information about the mesh and system to the screen.
mesh.print_info();
equation_systems.print_info();
{
// Adaptively solve the timestep
unsigned int a_step = 0;
for (; a_step != param.max_adaptivesteps; ++a_step)
{
// We can't adapt to both a tolerance and a
// target mesh size
if (param.global_tolerance != 0.)
libmesh_assert (param.nelem_target == 0);
// If we aren't adapting to a tolerance we need a
// target mesh size
else
libmesh_assert (param.nelem_target > 0);
// Solve the forward problem
system.solve();
// Write out the computed primal solution
write_output(equation_systems, a_step, "primal");
// Get a pointer to the primal solution vector
NumericVector<Number> &primal_solution = *system.solution;
// Declare a QoISet object, we need this object to set weights for our QoI error contributions
QoISet qois;
// Declare a qoi_indices vector, each index will correspond to a QoI
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qoi_indices.push_back(1);
qois.add_indices(qoi_indices);
// Set weights for each index, these will weight the contribution of each QoI in the final error
// estimate to be used for flagging elements for refinement
qois.set_weight(0, 0.5);
qois.set_weight(1, 0.5);
// A SensitivityData object to hold the qois and parameters
SensitivityData sensitivities(qois, system, system.get_parameter_vector());
// Make sure we get the contributions to the adjoint RHS from the sides
system.assemble_qoi_sides = true;
// Compute the sensitivities
system.adjoint_qoi_parameter_sensitivity(qois, system.get_parameter_vector(), sensitivities);
GetPot infile("l-shaped.in");
Number sensitivity_QoI_0_0_computed = sensitivities[0][0];
Number sensitivity_QoI_0_0_exact = infile("sensitivity_0_0", 0.0);
Number sensitivity_QoI_0_1_computed = sensitivities[0][1];
Number sensitivity_QoI_0_1_exact = infile("sensitivity_0_1", 0.0);
std::cout << "Adaptive step " << a_step << ", we have " << mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl ;
std::cout<<"Sensitivity of QoI one to Parameter one is "<<sensitivity_QoI_0_0_computed<<std::endl;
std::cout<<"Sensitivity of QoI one to Parameter two is "<<sensitivity_QoI_0_1_computed<<std::endl;
std::cout<< "The relative error in sensitivity QoI_0_0 is "
<< std::setprecision(17)
<< std::abs(sensitivity_QoI_0_0_computed - sensitivity_QoI_0_0_exact) /
std::abs(sensitivity_QoI_0_0_exact) << std::endl;
std::cout<< "The relative error in sensitivity QoI_0_1 is "
<< std::setprecision(17)
<< std::abs(sensitivity_QoI_0_1_computed - sensitivity_QoI_0_1_exact) /
std::abs(sensitivity_QoI_0_1_exact) << std::endl << std::endl;
// Get a pointer to the solution vector of the adjoint problem for QoI 0
NumericVector<Number> &dual_solution_0 = system.get_adjoint_solution(0);
// Swap the primal and dual solutions so we can write out the adjoint solution
primal_solution.swap(dual_solution_0);
write_output(equation_systems, a_step, "adjoint_0");
// Swap back
primal_solution.swap(dual_solution_0);
// We have to refine either based on reaching an error tolerance or
// a number of elements target, which should be verified above
// Otherwise we flag elements by error tolerance or nelem target
// Uniform refinement
if(param.refine_uniformly)
{
std::cout<<"Refining Uniformly"<<std::endl<<std::endl;
mesh_refinement->uniformly_refine(1);
}
// Adaptively refine based on reaching an error tolerance
else if(param.global_tolerance >= 0. && param.nelem_target == 0.)
{
// Now we construct the data structures for the mesh refinement process
ErrorVector error;
// Build an error estimator object
AutoPtr<ErrorEstimator> error_estimator =
build_error_estimator(param);
// Estimate the error in each element using the Adjoint Residual or Kelly error estimator
error_estimator->estimate_error(system, error);
mesh_refinement->flag_elements_by_error_tolerance (error);
mesh_refinement->refine_and_coarsen_elements();
}
// Adaptively refine based on reaching a target number of elements
else
{
// Now we construct the data structures for the mesh refinement process
ErrorVector error;
// Build an error estimator object
AutoPtr<ErrorEstimator> error_estimator =
build_error_estimator(param);
// Estimate the error in each element using the Adjoint Residual or Kelly error estimator
error_estimator->estimate_error(system, error);
if (mesh.n_active_elem() >= param.nelem_target)
{
std::cout<<"We reached the target number of elements."<<std::endl <<std::endl;
break;
}
mesh_refinement->flag_elements_by_nelem_target (error);
mesh_refinement->refine_and_coarsen_elements();
}
// Dont forget to reinit the system after each adaptive refinement !
equation_systems.reinit();
std::cout << "Refined mesh to "
<< mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl;
}
// Do one last solve if necessary
if (a_step == param.max_adaptivesteps)
{
system.solve();
write_output(equation_systems, a_step, "primal");
NumericVector<Number> &primal_solution = *system.solution;
QoISet qois;
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qoi_indices.push_back(1);
qois.add_indices(qoi_indices);
qois.set_weight(0, 0.5);
qois.set_weight(1, 0.5);
SensitivityData sensitivities(qois, system, system.get_parameter_vector());
system.assemble_qoi_sides = true;
system.adjoint_qoi_parameter_sensitivity(qois, system.get_parameter_vector(), sensitivities);
GetPot infile("l-shaped.in");
Number sensitivity_QoI_0_0_computed = sensitivities[0][0];
Number sensitivity_QoI_0_0_exact = infile("sensitivity_0_0", 0.0);
Number sensitivity_QoI_0_1_computed = sensitivities[0][1];
Number sensitivity_QoI_0_1_exact = infile("sensitivity_0_1", 0.0);
std::cout << "Adaptive step " << a_step << ", we have " << mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl ;
std::cout<<"Sensitivity of QoI one to Parameter one is "<<sensitivity_QoI_0_0_computed<<std::endl;
std::cout<<"Sensitivity of QoI one to Parameter two is "<<sensitivity_QoI_0_1_computed<<std::endl;
std::cout<< "The error in sensitivity QoI_0_0 is "
<< std::setprecision(17)
<< std::abs(sensitivity_QoI_0_0_computed - sensitivity_QoI_0_0_exact)/sensitivity_QoI_0_0_exact << std::endl;
std::cout<< "The error in sensitivity QoI_0_1 is "
<< std::setprecision(17)
<< std::abs(sensitivity_QoI_0_1_computed - sensitivity_QoI_0_1_exact)/sensitivity_QoI_0_1_exact << std::endl << std::endl;
NumericVector<Number> &dual_solution_0 = system.get_adjoint_solution(0);
primal_solution.swap(dual_solution_0);
write_output(equation_systems, a_step, "adjoint_0");
primal_solution.swap(dual_solution_0);
}
}
std::cerr << '[' << libMesh::processor_id()
<< "] Completing output." << std::endl;
#endif // #ifndef LIBMESH_ENABLE_AMR
// All done.
return 0;
}
// The main program.
int main (int argc, char** argv)
{
// Initialize libMesh.
LibMeshInit init (argc, argv);
// Skip adaptive examples on a non-adaptive libMesh build
#ifndef LIBMESH_ENABLE_AMR
libmesh_example_assert(false, "--enable-amr");
#else
std::cout << "Started " << argv[0] << std::endl;
// Make sure the general input file exists, and parse it
{
std::ifstream i("general.in");
if (!i)
{
std::cerr << '[' << init.comm().rank()
<< "] Can't find general.in; exiting early."
<< std::endl;
libmesh_error();
}
}
GetPot infile("general.in");
// Read in parameters from the input file
FEMParameters param;
param.read(infile);
// Skip this default-2D example if libMesh was compiled as 1D-only.
libmesh_example_assert(2 <= LIBMESH_DIM, "2D support");
// Create a mesh, with dimension to be overridden later, distributed
// across the default MPI communicator.
Mesh mesh(init.comm());
// And an object to refine it
AutoPtr<MeshRefinement> mesh_refinement =
build_mesh_refinement(mesh, param);
// And an EquationSystems to run on it
EquationSystems equation_systems (mesh);
std::cout << "Reading in and building the mesh" << std::endl;
// Read in the mesh
mesh.read(param.domainfile.c_str());
// Make all the elements of the mesh second order so we can compute
// with a higher order basis
mesh.all_second_order();
// Create a mesh refinement object to do the initial uniform refinements
// on the coarse grid read in from lshaped.xda
MeshRefinement initial_uniform_refinements(mesh);
initial_uniform_refinements.uniformly_refine(param.coarserefinements);
std::cout << "Building system" << std::endl;
// Build the FEMSystem
LaplaceSystem &system = equation_systems.add_system<LaplaceSystem> ("LaplaceSystem");
// Set its parameters
set_system_parameters(system, param);
std::cout << "Initializing systems" << std::endl;
equation_systems.init ();
// Print information about the mesh and system to the screen.
mesh.print_info();
equation_systems.print_info();
LinearSolver<Number> *linear_solver = system.get_linear_solver();
{
// Adaptively solve the timestep
unsigned int a_step = 0;
for (; a_step != param.max_adaptivesteps; ++a_step)
{
// We can't adapt to both a tolerance and a
// target mesh size
if (param.global_tolerance != 0.)
libmesh_assert_equal_to (param.nelem_target, 0);
// If we aren't adapting to a tolerance we need a
// target mesh size
else
libmesh_assert_greater (param.nelem_target, 0);
linear_solver->reuse_preconditioner(false);
// Solve the forward problem
system.solve();
// Write out the computed primal solution
write_output(equation_systems, a_step, "primal");
// Get a pointer to the primal solution vector
NumericVector<Number> &primal_solution = *system.solution;
// Declare a QoISet object, we need this object to set weights for our QoI error contributions
QoISet qois;
// Declare a qoi_indices vector, each index will correspond to a QoI
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qoi_indices.push_back(1);
qois.add_indices(qoi_indices);
// Set weights for each index, these will weight the contribution of each QoI in the final error
// estimate to be used for flagging elements for refinement
qois.set_weight(0, 0.5);
qois.set_weight(1, 0.5);
// Make sure we get the contributions to the adjoint RHS from the sides
system.assemble_qoi_sides = true;
// We are about to solve the adjoint system, but before we do this we see the same preconditioner
// flag to reuse the preconditioner from the forward solver
linear_solver->reuse_preconditioner(param.reuse_preconditioner);
// Solve the adjoint system. This takes the transpose of the stiffness matrix and then
// solves the resulting system
system.adjoint_solve();
// Now that we have solved the adjoint, set the adjoint_already_solved boolean to true, so we dont solve unneccesarily in the error estimator
system.set_adjoint_already_solved(true);
// Get a pointer to the solution vector of the adjoint problem for QoI 0
NumericVector<Number> &dual_solution_0 = system.get_adjoint_solution(0);
// Swap the primal and dual solutions so we can write out the adjoint solution
primal_solution.swap(dual_solution_0);
write_output(equation_systems, a_step, "adjoint_0");
// Swap back
primal_solution.swap(dual_solution_0);
// Get a pointer to the solution vector of the adjoint problem for QoI 0
NumericVector<Number> &dual_solution_1 = system.get_adjoint_solution(1);
// Swap again
primal_solution.swap(dual_solution_1);
write_output(equation_systems, a_step, "adjoint_1");
// Swap back again
primal_solution.swap(dual_solution_1);
std::cout << "Adaptive step " << a_step << ", we have " << mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl ;
// Postprocess, compute the approximate QoIs and write them out to the console
std::cout << "Postprocessing: " << std::endl;
system.postprocess_sides = true;
system.postprocess();
Number QoI_0_computed = system.get_QoI_value("computed", 0);
Number QoI_0_exact = system.get_QoI_value("exact", 0);
Number QoI_1_computed = system.get_QoI_value("computed", 1);
Number QoI_1_exact = system.get_QoI_value("exact", 1);
std::cout<< "The relative error in QoI 0 is " << std::setprecision(17)
<< std::abs(QoI_0_computed - QoI_0_exact) /
std::abs(QoI_0_exact) << std::endl;
std::cout<< "The relative error in QoI 1 is " << std::setprecision(17)
<< std::abs(QoI_1_computed - QoI_1_exact) /
std::abs(QoI_1_exact) << std::endl << std::endl;
// Now we construct the data structures for the mesh refinement process
ErrorVector error;
// Build an error estimator object
AutoPtr<ErrorEstimator> error_estimator =
build_error_estimator(param, qois);
// Estimate the error in each element using the Adjoint Residual or Kelly error estimator
error_estimator->estimate_error(system, error);
// We have to refine either based on reaching an error tolerance or
// a number of elements target, which should be verified above
// Otherwise we flag elements by error tolerance or nelem target
// Uniform refinement
if(param.refine_uniformly)
{
mesh_refinement->uniformly_refine(1);
}
// Adaptively refine based on reaching an error tolerance
else if(param.global_tolerance >= 0. && param.nelem_target == 0.)
{
mesh_refinement->flag_elements_by_error_tolerance (error);
mesh_refinement->refine_and_coarsen_elements();
}
// Adaptively refine based on reaching a target number of elements
else
{
if (mesh.n_active_elem() >= param.nelem_target)
{
std::cout<<"We reached the target number of elements."<<std::endl <<std::endl;
break;
}
mesh_refinement->flag_elements_by_nelem_target (error);
mesh_refinement->refine_and_coarsen_elements();
}
// Dont forget to reinit the system after each adaptive refinement !
equation_systems.reinit();
std::cout << "Refined mesh to "
<< mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl;
}
// Do one last solve if necessary
if (a_step == param.max_adaptivesteps)
{
linear_solver->reuse_preconditioner(false);
system.solve();
write_output(equation_systems, a_step, "primal");
NumericVector<Number> &primal_solution = *system.solution;
QoISet qois;
std::vector<unsigned int> qoi_indices;
qoi_indices.push_back(0);
qoi_indices.push_back(1);
qois.add_indices(qoi_indices);
qois.set_weight(0, 0.5);
qois.set_weight(1, 0.5);
system.assemble_qoi_sides = true;
linear_solver->reuse_preconditioner(param.reuse_preconditioner);
system.adjoint_solve();
// Now that we have solved the adjoint, set the adjoint_already_solved boolean to true, so we dont solve unneccesarily in the error estimator
system.set_adjoint_already_solved(true);
NumericVector<Number> &dual_solution_0 = system.get_adjoint_solution(0);
primal_solution.swap(dual_solution_0);
write_output(equation_systems, a_step, "adjoint_0");
primal_solution.swap(dual_solution_0);
NumericVector<Number> &dual_solution_1 = system.get_adjoint_solution(1);
primal_solution.swap(dual_solution_1);
write_output(equation_systems, a_step, "adjoint_1");
primal_solution.swap(dual_solution_1);
std::cout << "Adaptive step " << a_step << ", we have " << mesh.n_active_elem()
<< " active elements and "
<< equation_systems.n_active_dofs()
<< " active dofs." << std::endl ;
std::cout << "Postprocessing: " << std::endl;
system.postprocess_sides = true;
system.postprocess();
Number QoI_0_computed = system.get_QoI_value("computed", 0);
Number QoI_0_exact = system.get_QoI_value("exact", 0);
Number QoI_1_computed = system.get_QoI_value("computed", 1);
Number QoI_1_exact = system.get_QoI_value("exact", 1);
std::cout<< "The relative error in QoI 0 is " << std::setprecision(17)
<< std::abs(QoI_0_computed - QoI_0_exact) /
std::abs(QoI_0_exact) << std::endl;
std::cout<< "The relative error in QoI 1 is " << std::setprecision(17)
<< std::abs(QoI_1_computed - QoI_1_exact) /
std::abs(QoI_1_exact) << std::endl << std::endl;
}
}
std::cerr << '[' << mesh.processor_id()
<< "] Completing output." << std::endl;
#endif // #ifndef LIBMESH_ENABLE_AMR
// All done.
return 0;
}
