miscellaneous_ex3.C File Reference

Go to the source code of this file.

Classes
class	LaplaceYoung
	A class which provides the residual and jacobian assembly functions for the Laplace-Young system of equations. More...

Functions
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 135 of file miscellaneous_ex3.C.

{
  // Initialize libMesh and any dependent libraries, like in example 2.
  LibMeshInit init (argc, argv);
 
  // This example requires a NonlinearSolver.
#if !defined(LIBMESH_HAVE_PETSC) && (!defined(LIBMESH_TRILINOS_HAVE_NOX) || !defined(LIBMESH_TRILINOS_HAVE_EPETRA))
  libmesh_example_requires(false, "--enable-petsc or --enable-trilinos");
#endif
 
  if (libMesh::on_command_line ("--use-eigen"))
    {
      libMesh::err << "This example requires a NonlinearSolver, and therefore does not "
                   << "support --use-eigen on the command line."
                   << std::endl;
      return 0;
    }
 
#ifndef LIBMESH_ENABLE_AMR
  libmesh_example_requires(false, "--enable-amr");
#else
 
  // Create a GetPot object to parse the command line
  GetPot command_line (argc, argv);
 
  // Check for proper calling arguments.
  libmesh_error_msg_if(argc < 3, "Usage:\n" << "\t " << argv[0] << " -r 2");
 
  // Brief message to the user regarding the program name
  // and command line arguments.
  libMesh::out << "Running " << argv[0];
 
  for (int i=1; i<argc; i++)
    libMesh::out << " " << argv[i];
 
  libMesh::out << std::endl << std::endl;
 
  // Read number of refinements
  const int nr = libMesh::command_line_next("-r", 2);
 
  // Read FE order from command line
  std::string order = "FIRST";
  order = libMesh::command_line_next("-o", order);
  order = libMesh::command_line_next("-Order", order);
 
  // Read FE Family from command line
  std::string family = "LAGRANGE";
  family = libMesh::command_line_next("-f", family);
  family = libMesh::command_line_next("-FEFamily", family);
 
  // Cannot use discontinuous basis.
  libmesh_error_msg_if((family == "MONOMIAL") || (family == "XYZ"),
                       "This example requires a C^0 (or higher) FE basis.");
 
  if (libMesh::on_command_line("-pre"))
    {
#ifdef LIBMESH_HAVE_PETSC
      //Use the jacobian for preconditioning.
#  if PETSC_VERSION_LESS_THAN(3,7,0)
      LibmeshPetscCall2(init.comm(), PetscOptionsSetValue("-snes_mf_operator",
                                                          LIBMESH_PETSC_NULLPTR));
#  else
      LibmeshPetscCall2(init.comm(), PetscOptionsSetValue(LIBMESH_PETSC_NULLPTR, "-snes_mf_operator",
                                                          LIBMESH_PETSC_NULLPTR));
#  endif
#else
      libMesh::err << "Must be using PETSc to use jacobian based preconditioning" << std::endl;
 
      //returning zero so that "make run" won't fail if we ever enable this capability there.
      return 0;
#endif //LIBMESH_HAVE_PETSC
    }
 
  // Skip this 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 by the file,
  // distributed across the default MPI communicator.
  Mesh mesh(init.comm());
 
  mesh.read ("lshaped.xda");
 
  if (order != "FIRST")
    mesh.all_second_order();
 
  MeshRefinement(mesh).uniformly_refine(nr);
 
  // Print information about the mesh to the screen.
  mesh.print_info();
 
  // Create an equation systems object.
  EquationSystems equation_systems (mesh);
 
  // Declare the system and its variables.
 
  // Creates a system named "Laplace-Young"
  NonlinearImplicitSystem & system =
    equation_systems.add_system<NonlinearImplicitSystem> ("Laplace-Young");
 
  // Here we specify the tolerance for the nonlinear solver and
  // the maximum of nonlinear iterations.
  equation_systems.parameters.set<Real>         ("nonlinear solver tolerance")          = 1.e-12;
  equation_systems.parameters.set<unsigned int> ("nonlinear solver maximum iterations") = 50;
 
 
  // Adds the variable "u" to "Laplace-Young".  "u"
  // will be approximated using second-order approximation.
  system.add_variable("u",
                      Utility::string_to_enum<Order>   (order),
                      Utility::string_to_enum<FEFamily>(family));
 
  // Construct object which provides the residual and jacobian
  // computations and tell the solver to use it.
  LaplaceYoung laplace_young;
  system.nonlinear_solver->residual_object = &laplace_young;
  system.nonlinear_solver->jacobian_object = &laplace_young;
  system.nonlinear_solver->postcheck_object = &laplace_young;
 
  // Initialize the data structures for the equation system.
  equation_systems.init();
 
  // Prints information about the system to the screen.
  equation_systems.print_info();
 
  // Solve the system "Laplace-Young", print the number of iterations
  // and final residual
  equation_systems.get_system("Laplace-Young").solve();
 
  // Print out final convergence information.  This duplicates some
  // output from during the solve itself, but demonstrates another way
  // to get this information after the solve is complete.
  libMesh::out << "Laplace-Young system solved at nonlinear iteration "
               << system.n_nonlinear_iterations()
               << " , final nonlinear residual norm: "
               << system.final_nonlinear_residual()
               << std::endl;
 
#ifdef LIBMESH_HAVE_EXODUS_API
  // After solving the system write the solution
  ExodusII_IO (mesh).write_equation_systems ("out.e",
                                             equation_systems);
#endif // #ifdef LIBMESH_HAVE_EXODUS_API
#endif // #ifndef LIBMESH_ENABLE_AMR
 
  // All done.
  return 0;
}

References libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::MeshBase::all_second_order(), libMesh::command_line_next(), libMesh::err, libMesh::NonlinearImplicitSystem::final_nonlinear_residual(), libMesh::EquationSystems::get_system(), libMesh::EquationSystems::init(), main(), mesh, libMesh::NonlinearImplicitSystem::n_nonlinear_iterations(), libMesh::NonlinearImplicitSystem::nonlinear_solver, libMesh::on_command_line(), libMesh::out, libMesh::EquationSystems::parameters, libMesh::EquationSystems::print_info(), libMesh::MeshBase::print_info(), libMesh::MeshBase::read(), libMesh::Real, libMesh::Parameters::set(), libMesh::MeshRefinement::uniformly_refine(), and libMesh::ExodusII_IO::write_equation_systems().