adjoints_ex2.C File Reference

Go to the source code of this file.

Functions
void	write_output (EquationSystems &es, unsigned int a_step, std::string solution_type, FEMParameters &param)
void	adjust_linear_solver (LinearSolver< Number > &linear_solver)
void	adjust_linear_solvers (LaplaceSystem &system)
void	set_system_parameters (LaplaceSystem &system, FEMParameters &param)
std::unique_ptr< MeshRefinement >	build_mesh_refinement (MeshBase &mesh, FEMParameters &param)
std::unique_ptr< ErrorEstimator >	build_error_estimator (FEMParameters &param)
int	main (int argc, char **argv)

Function Documentation

adjust_linear_solver()

void adjust_linear_solver

(

LinearSolver< Number > &

linear_solver

)

Definition at line 169 of file adjoints_ex2.C.

{
  // Eigen's BiCGSTAB doesn't seem reliable at the full refinement
  // level we use here.
#ifdef LIBMESH_HAVE_EIGEN_SPARSE
  EigenSparseLinearSolver<Number> * eigen_linear_solver =
    dynamic_cast<EigenSparseLinearSolver<Number> *>(&linear_solver);
 
  if (eigen_linear_solver)
    eigen_linear_solver->set_solver_type(SPARSELU);
#else
  libmesh_ignore(linear_solver);
#endif
}

References libMesh::libmesh_ignore(), libMesh::LinearSolver< T >::set_solver_type(), and libMesh::SPARSELU.

Referenced by adjust_linear_solvers().

adjust_linear_solvers()

void adjust_linear_solvers

(

LaplaceSystem &

system

)

Definition at line 184 of file adjoints_ex2.C.

{
  auto diff_solver = cast_ptr<NewtonSolver*>(system.get_time_solver().diff_solver().get());
  if (diff_solver) // Some compilers don't like dynamic cast of nullptr?
    {
      auto solver = cast_ptr<NewtonSolver*>(diff_solver);
      if (solver)
        adjust_linear_solver(solver->get_linear_solver());
    }
 
  LinearSolver<Number> * linear_solver = system.get_linear_solver();
  if (linear_solver)
    adjust_linear_solver(*linear_solver);
}

References adjust_linear_solver(), libMesh::TimeSolver::diff_solver(), libMesh::DifferentiableSystem::get_linear_solver(), and libMesh::DifferentiableSystem::get_time_solver().

Referenced by main(), and set_system_parameters().

build_error_estimator()

std::unique_ptr< ErrorEstimator > build_error_estimator

(

FEMParameters &

param

)

Definition at line 287 of file adjoints_ex2.C.

{
  if (param.indicator_type == "kelly")
    {
      libMesh::out << "Using Kelly Error Estimator" << std::endl;
 
      return std::make_unique<KellyErrorEstimator>();
    }
  else if (param.indicator_type == "adjoint_residual")
    {
      libMesh::out << "Using Adjoint Residual Error Estimator with Patch Recovery Weights" << std::endl << std::endl;
 
      auto adjoint_residual_estimator = std::make_unique<AdjointResidualErrorEstimator>();
 
      adjoint_residual_estimator->error_plot_suffix = "error.gmv";
 
      adjoint_residual_estimator->primal_error_estimator() = std::make_unique<PatchRecoveryErrorEstimator>();
      adjoint_residual_estimator->primal_error_estimator()->error_norm.set_type(0, H1_SEMINORM);
 
      adjoint_residual_estimator->dual_error_estimator() = std::make_unique<PatchRecoveryErrorEstimator>();
      adjoint_residual_estimator->dual_error_estimator()->error_norm.set_type(0, H1_SEMINORM);
 
      return adjoint_residual_estimator;
    }
  else
    libmesh_error_msg("Unknown indicator_type = " << param.indicator_type);
}

References libMesh::H1_SEMINORM, FEMParameters::indicator_type, and libMesh::out.

Referenced by main().

build_mesh_refinement()

std::unique_ptr< MeshRefinement > build_mesh_refinement	(	MeshBase &	mesh,
		FEMParameters &	param
	)

Definition at line 264 of file adjoints_ex2.C.

{
  auto mesh_refinement = std::make_unique<MeshRefinement>(mesh);
  mesh_refinement->coarsen_by_parents() = true;
  mesh_refinement->absolute_global_tolerance() = param.global_tolerance;
  mesh_refinement->nelem_target()      = param.nelem_target;
  mesh_refinement->refine_fraction()   = param.refine_fraction;
  mesh_refinement->coarsen_fraction()  = param.coarsen_fraction;
  mesh_refinement->coarsen_threshold() = param.coarsen_threshold;
 
  return mesh_refinement;
}

References FEMParameters::coarsen_fraction, FEMParameters::coarsen_threshold, FEMParameters::global_tolerance, mesh, FEMParameters::nelem_target, and FEMParameters::refine_fraction.

Referenced by main().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 316 of file adjoints_ex2.C.

{
  // 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
 
  libMesh::out << "Started " << argv[0] << std::endl;
 
  // Make sure the general input file exists, and parse it
  {
    std::ifstream i("general.in");
    libmesh_error_msg_if(!i, '[' << init.comm().rank() << "] Can't find general.in; exiting early.");
  }
 
  // Read in parameters from the input file
  GetPot infile("general.in");
  // But allow the command line to override it.
  infile.parse_command_line(argc, argv);
 
  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");
 
  QoISet qois;
 
  qois.add_indices({0});
 
  qois.set_weight(0, 0.5);
 
  // Put some scope here to test that the cloning is working right
  {
    LaplaceQoI qoi;
    system.attach_qoi(&qoi);
  }
 
  // 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();
 
  {
    // 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);
 
        // 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;
 
        // 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;
 
        // 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);
 
        // 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);
 
        GetPot infile_l_shaped("l-shaped.in");
 
        Number sensitivity_QoI_0_0_computed = sensitivities[0][0];
        Number sensitivity_QoI_0_0_exact = infile_l_shaped("sensitivity_0_0", 0.0);
        Number sensitivity_QoI_0_1_computed = sensitivities[0][1];
        Number sensitivity_QoI_0_1_exact = infile_l_shaped("sensitivity_0_1", 0.0);
 
        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 << "Sensitivity of QoI one to Parameter one is "
                     << sensitivity_QoI_0_0_computed
                     << std::endl;
        libMesh::out << "Sensitivity of QoI one to Parameter two is "
                     << sensitivity_QoI_0_1_computed
                     << std::endl;
 
        libMesh::out << "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;
 
        libMesh::out << "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", param);
 
        // 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)
          {
            libMesh::out << "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
            std::unique_ptr<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
            std::unique_ptr<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)
              {
                libMesh::out<<"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();
 
        // Fix up the linear solver options if that reinit just cleared it
        adjust_linear_solvers(system);
 
        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)
      {
        system.solve();
 
        write_output(equation_systems, a_step, "primal", param);
 
        system.assemble_qoi_sides = true;
 
        SensitivityData sensitivities(qois, system, system.get_parameter_vector());
 
        // 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);
 
        system.adjoint_qoi_parameter_sensitivity(qois, system.get_parameter_vector(), sensitivities);
 
        // 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);
 
        GetPot infile_l_shaped("l-shaped.in");
 
        Number sensitivity_QoI_0_0_computed = sensitivities[0][0];
        Number sensitivity_QoI_0_0_exact = infile_l_shaped("sensitivity_0_0", 0.0);
        Number sensitivity_QoI_0_1_computed = sensitivities[0][1];
        Number sensitivity_QoI_0_1_exact = infile_l_shaped("sensitivity_0_1", 0.0);
 
        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 << "Sensitivity of QoI one to Parameter one is "
                     << sensitivity_QoI_0_0_computed
                     << std::endl;
 
        libMesh::out << "Sensitivity of QoI one to Parameter two is "
                     << sensitivity_QoI_0_1_computed
                     << std::endl;
 
        libMesh::out << "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;
 
        libMesh::out << "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;
 
        // Hard coded asserts to ensure that the actual numbers we are getting are what they should be
        libmesh_assert_less(std::abs((sensitivity_QoI_0_0_computed - sensitivity_QoI_0_0_exact)/sensitivity_QoI_0_0_exact), 2.e-4);
        libmesh_assert_less(std::abs((sensitivity_QoI_0_1_computed - sensitivity_QoI_0_1_exact)/sensitivity_QoI_0_1_exact), 2.e-4);
 
        // Let's do a forward sensitivity solve too, unless we're
        // told to skip it for backwards compatibility with old
        // performance benchmarks.
        const bool forward_sensitivity = infile("--forward_sensitivity", true);
 
        // Don't confuse PETSc with our custom GetPot's arguments
        libMesh::add_command_line_names(infile);
 
        if (forward_sensitivity)
          {
            // This will require two linear solves (one per parameter)
            // rather than the adjoint sensitivity's one, but it's useful
            // for regression testing.
            SensitivityData forward_sensitivities(qois, system, system.get_parameter_vector());
            system.forward_qoi_parameter_sensitivity(qois, system.get_parameter_vector(), forward_sensitivities);
 
            libmesh_assert_less(std::abs((forward_sensitivities[0][0] - sensitivity_QoI_0_0_exact)/sensitivity_QoI_0_0_exact), 2.e-4);
            libmesh_assert_less(std::abs((forward_sensitivities[0][1] - sensitivity_QoI_0_1_exact)/sensitivity_QoI_0_1_exact), 2.e-4);
 
            // These should be the same linearization, just calculated
            // different ways with different roundoff error
            libmesh_assert_less
              (std::abs((forward_sensitivities[0][0] - sensitivity_QoI_0_0_computed)/sensitivity_QoI_0_0_computed), TOLERANCE);
            libmesh_assert_less
              (std::abs((forward_sensitivities[0][1] - sensitivity_QoI_0_1_computed)/sensitivity_QoI_0_1_computed), TOLERANCE);
 
            libMesh::out << "The error in forward calculation of sensitivity QoI_0_0 is "
                         << std::setprecision(17)
                         << std::abs(forward_sensitivities[0][0] - sensitivity_QoI_0_0_exact)/sensitivity_QoI_0_0_exact
                         << std::endl;
 
            libMesh::out << "The error in forward calculation of sensitivity QoI_0_1 is "
                         << std::setprecision(17)
                         << std::abs(forward_sensitivities[0][1] - sensitivity_QoI_0_1_exact)/sensitivity_QoI_0_1_exact
                         << std::endl
                         << std::endl;
 
 
          }
 
        NumericVector<Number> & primal_solution = *system.solution;
        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);
      }
  }
 
  libMesh::err << '[' << system.processor_id()
               << "] Completing output."
               << std::endl;
 
#endif // #ifndef LIBMESH_ENABLE_AMR
 
  // All done.
  return 0;
}

References libMesh::add_command_line_names(), libMesh::QoISet::add_indices(), libMesh::EquationSystems::add_system(), libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), adjust_linear_solvers(), libMesh::MeshBase::all_second_order(), libMesh::DifferentiableQoI::assemble_qoi_sides, libMesh::DifferentiableSystem::attach_qoi(), build_error_estimator(), build_mesh_refinement(), FEMParameters::coarserefinements, libMesh::default_solver_package(), FEMParameters::domainfile, libMesh::err, libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::System::get_adjoint_solution(), LaplaceSystem::get_parameter_vector(), FEMParameters::global_tolerance, libMesh::EquationSystems::init(), libMesh::INVALID_SOLVER_PACKAGE, main(), FEMParameters::max_adaptivesteps, mesh, libMesh::EquationSystems::n_active_dofs(), libMesh::MeshBase::n_active_elem(), FEMParameters::nelem_target, libMesh::out, libMesh::EquationSystems::print_info(), libMesh::MeshBase::print_info(), libMesh::ParallelObject::processor_id(), libMesh::MeshBase::read(), FEMParameters::read(), FEMParameters::refine_uniformly, libMesh::EquationSystems::reinit(), libMesh::System::set_adjoint_already_solved(), set_system_parameters(), libMesh::System::solution, libMesh::FEMSystem::solve(), libMesh::NumericVector< T >::swap(), libMesh::TOLERANCE, libMesh::MeshRefinement::uniformly_refine(), and write_output().

set_system_parameters()

void set_system_parameters	(	LaplaceSystem &	system,
		FEMParameters &	param
	)

Definition at line 201 of file adjoints_ex2.C.

{
  // Use analytical jacobians?
  system.analytic_jacobians() = param.analytic_jacobians;
 
  // Verify analytic jacobians against numerical ones?
  system.verify_analytic_jacobians = param.verify_analytic_jacobians;
 
  // Use the prescribed FE type
  system.fe_family() = param.fe_family[0];
  system.fe_order() = param.fe_order[0];
 
  // More desperate debugging options
  system.print_solution_norms = param.print_solution_norms;
  system.print_solutions      = param.print_solutions;
  system.print_residual_norms = param.print_residual_norms;
  system.print_residuals      = param.print_residuals;
  system.print_jacobian_norms = param.print_jacobian_norms;
  system.print_jacobians      = param.print_jacobians;
 
  // No transient time solver
  system.time_solver = std::make_unique<SteadySolver>(system);
 
  // Nonlinear solver options
  if (param.use_petsc_snes)
  {
#ifdef LIBMESH_HAVE_PETSC
    system.time_solver->diff_solver() = std::make_unique<PetscDiffSolver>(system);
#else
    libmesh_error_msg("This example requires libMesh to be compiled with PETSc support.");
#endif
  }
  else
  {
    system.time_solver->diff_solver() = std::make_unique<NewtonSolver>(system);
    auto solver = cast_ptr<NewtonSolver*>(system.time_solver->diff_solver().get());
 
    solver->quiet                       = param.solver_quiet;
    solver->max_nonlinear_iterations    = param.max_nonlinear_iterations;
    solver->minsteplength               = param.min_step_length;
    solver->relative_step_tolerance     = param.relative_step_tolerance;
    solver->relative_residual_tolerance = param.relative_residual_tolerance;
    solver->require_residual_reduction  = param.require_residual_reduction;
    solver->linear_tolerance_multiplier = param.linear_tolerance_multiplier;
    if (system.time_solver->reduce_deltat_on_diffsolver_failure)
      {
        solver->continue_after_max_iterations = true;
        solver->continue_after_backtrack_failure = true;
      }
    system.set_constrain_in_solver(param.constrain_in_solver);
 
    // And the linear solver options
    solver->max_linear_iterations    = param.max_linear_iterations;
    solver->initial_linear_tolerance = param.initial_linear_tolerance;
    solver->minimum_linear_tolerance = param.minimum_linear_tolerance;
    adjust_linear_solvers(system);
  }
}

References adjust_linear_solvers(), FEMParameters::analytic_jacobians, LaplaceSystem::analytic_jacobians(), FEMParameters::constrain_in_solver, FEMParameters::fe_family, LaplaceSystem::fe_family(), FEMParameters::fe_order, LaplaceSystem::fe_order(), FEMParameters::initial_linear_tolerance, FEMParameters::linear_tolerance_multiplier, FEMParameters::max_linear_iterations, FEMParameters::max_nonlinear_iterations, FEMParameters::min_step_length, FEMParameters::minimum_linear_tolerance, FEMParameters::print_jacobian_norms, libMesh::DifferentiableSystem::print_jacobian_norms, FEMParameters::print_jacobians, libMesh::DifferentiableSystem::print_jacobians, FEMParameters::print_residual_norms, libMesh::DifferentiableSystem::print_residual_norms, FEMParameters::print_residuals, libMesh::DifferentiableSystem::print_residuals, FEMParameters::print_solution_norms, libMesh::DifferentiableSystem::print_solution_norms, FEMParameters::print_solutions, libMesh::DifferentiableSystem::print_solutions, FEMParameters::relative_residual_tolerance, FEMParameters::relative_step_tolerance, FEMParameters::require_residual_reduction, libMesh::DifferentiableSystem::set_constrain_in_solver(), FEMParameters::solver_quiet, libMesh::DifferentiableSystem::time_solver, FEMParameters::use_petsc_snes, FEMParameters::verify_analytic_jacobians, and libMesh::FEMSystem::verify_analytic_jacobians.

Referenced by main().

write_output()

void write_output	(	EquationSystems &	es,
		unsigned int	a_step,
		std::string	solution_type,
		FEMParameters &	param
	)

Definition at line 110 of file adjoints_ex2.C.

{
  // Ignore parameters when there are no output formats available.
  libmesh_ignore(es, a_step, solution_type, param);
 
#ifdef LIBMESH_HAVE_GMV
  if (param.output_gmv)
    {
      MeshBase & mesh = es.get_mesh();
 
      std::ostringstream file_name_gmv;
      file_name_gmv << solution_type
                    << ".out.gmv."
                    << std::setw(2)
                    << std::setfill('0')
                    << std::right
                    << a_step;
 
      GMVIO(mesh).write_equation_systems(file_name_gmv.str(), es);
    }
#endif
 
#ifdef LIBMESH_HAVE_EXODUS_API
  if (param.output_exodus)
    {
      MeshBase & mesh = es.get_mesh();
 
      // We write out one file per adaptive step. The files are named in
      // the following way:
      // foo.e
      // foo.e-s002
      // foo.e-s003
      // ...
      // so that, if you open the first one with Paraview, it actually
      // opens the entire sequence of adapted files.
      std::ostringstream file_name_exodus;
 
      file_name_exodus << solution_type << ".e";
      if (a_step > 0)
        file_name_exodus << "-s"
                         << std::setw(3)
                         << std::setfill('0')
                         << std::right
                         << a_step + 1;
 
      // We write each adaptive step as a pseudo "time" step, where the
      // time simply matches the (1-based) adaptive step we are on.
      ExodusII_IO(mesh).write_timestep(file_name_exodus.str(),
                                       es,
                                       1,
                                       /*time=*/a_step + 1);
    }
#endif
}

References libMesh::EquationSystems::get_mesh(), libMesh::libmesh_ignore(), mesh, FEMParameters::output_exodus, FEMParameters::output_gmv, libMesh::MeshOutput< MT >::write_equation_systems(), and libMesh::ExodusII_IO::write_timestep().

Referenced by main().