/* $Id: ex4.C 2837 2008-05-08 17:23:37Z roystgnr $ *//* The Next Great Finite Element Library. *//* Copyright (C) 2003  Benjamin S. Kirk *//* This library is free software; you can redistribute it and/or *//* modify it under the terms of the GNU Lesser General Public *//* License as published by the Free Software Foundation; either *//* version 2.1 of the License, or (at your option) any later version. *//* This library is distributed in the hope that it will be useful, *//* but WITHOUT ANY WARRANTY; without even the implied warranty of *//* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *//* Lesser General Public License for more details. *//* You should have received a copy of the GNU Lesser General Public *//* License along with this library; if not, write to the Free Software *//* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */ // <h1>Example 4 - Solving a 1D, 2D or 3D Poisson Problem in Parallel</h1> // // This is the fourth example program.  It builds on // the third example program by showing how to formulate // the code in a dimension-independent way.  Very minor // changes to the example will allow the problem to be // solved in one, two or three dimensions. // // This example will also introduce the PerfLog class // as a way to monitor your code's performance.  We will // use it to instrument the matrix assembly code and look // for bottlenecks where we should focus optimization efforts. // // This example also shows how to extend example 3 to run in // parallel.  Notice how litte has changed!  The significant // differences are marked with "PARALLEL CHANGE".// C++ include files that we need#include <iostream>#include <algorithm>#include <math.h>// Basic include file needed for the mesh functionality.#include "libmesh.h"#include "mesh.h"#include "mesh_generation.h"#include "gmv_io.h"#include "gnuplot_io.h"#include "linear_implicit_system.h"#include "equation_systems.h"// Define the Finite Element object.#include "fe.h"// Define Gauss quadrature rules.#include "quadrature_gauss.h"// Define the DofMap, which handles degree of freedom// indexing.#include "dof_map.h"// Define useful datatypes for finite element// matrix and vector components.#include "sparse_matrix.h"#include "numeric_vector.h"#include "dense_matrix.h"#include "dense_vector.h"// Define the PerfLog, a performance logging utility.// It is useful for timing events in a code and giving// you an idea where bottlenecks lie.#include "perf_log.h"// The definition of a geometric element#include "elem.h"#include "string_to_enum.h"#include "getpot.h"// Function prototype.  This is the function that will assemble// the linear system for our Poisson problem.  Note that the// function will take the \p EquationSystems object and the// name of the system we are assembling as input.  From the// \p EquationSystems object we have acess to the \p Mesh and// other objects we might need.void assemble_poisson(EquationSystems& es,                      const std::string& system_name);// Exact solution function prototype.Real exact_solution (const Real x,                     const Real y = 0.,                     const Real z = 0.);// Begin the main program.int main (int argc, char** argv){  // Initialize libMesh and any dependent libaries, like in example 2.  LibMeshInit init (argc, argv);  // Declare a performance log for the main program  // PerfLog perf_main("Main Program");    // Create a GetPot object to parse the command line  GetPot command_line (argc, argv);    // Check for proper calling arguments.  if (argc < 3)    {      if (libMesh::processor_id() == 0)        std::cerr << "Usage:\n"                  <<"\t " << argv[0] << " -d 2(3)" << " -n 15"                  << std::endl;      // This handy function will print the file name, line number,      // and then abort.  Currrently the library does not use C++      // exception handling.      libmesh_error();    }    // Brief message to the user regarding the program name  // and command line arguments.  else     {      std::cout << "Running " << argv[0];            for (int i=1; i<argc; i++)        std::cout << " " << argv[i];            std::cout << std::endl << std::endl;    }    // Read problem dimension from command line.  Use int  // instead of unsigned since the GetPot overload is ambiguous  // otherwise.  int dim = 2;  if ( command_line.search(1, "-d") )    dim = command_line.next(dim);    // Read number of elements from command line  int ps = 15;  if ( command_line.search(1, "-n") )    ps = command_line.next(ps);    // Read FE order from command line  std::string order = "SECOND";   if ( command_line.search(2, "-Order", "-o") )    order = command_line.next(order);  // Read FE Family from command line  std::string family = "LAGRANGE";   if ( command_line.search(2, "-FEFamily", "-f") )    family = command_line.next(family);    // Cannot use dicontinuous basis.  if ((family == "MONOMIAL") || (family == "XYZ"))    {      std::cout << "ex4 currently requires a C^0 (or higher) FE basis." << std::endl;      libmesh_error();    }      // Create a mesh with user-defined dimension.  Mesh mesh (dim);    // Use the MeshTools::Generation mesh generator to create a uniform  // grid on the square [-1,1]^D.  We instruct the mesh generator  // to build a mesh of 8x8 \p Quad9 elements in 2D, or \p Hex27  // elements in 3D.  Building these higher-order elements allows  // us to use higher-order approximation, as in example 3.  if ((family == "LAGRANGE") && (order == "FIRST"))    {      // No reason to use high-order geometric elements if we are      // solving with low-order finite elements.      MeshTools::Generation::build_cube (mesh,                                         ps, ps, ps,                                         -1., 1.,                                         -1., 1.,                                         -1., 1.,                                         (dim==1)    ? EDGE2 :                                          ((dim == 2) ? QUAD4 : HEX8));    }    else    {      MeshTools::Generation::build_cube (mesh,                                         ps, ps, ps,                                         -1., 1.,                                         -1., 1.,                                         -1., 1.,                                         (dim==1)    ? EDGE3 :                                          ((dim == 2) ? QUAD9 : HEX27));    }    // 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.  // Create a system named "Poisson"  LinearImplicitSystem& system =    equation_systems.add_system<LinearImplicitSystem> ("Poisson");    // Add the variable "u" to "Poisson".  "u"  // will be approximated using second-order approximation.  system.add_variable("u",                      Utility::string_to_enum<Order>   (order),                      Utility::string_to_enum<FEFamily>(family));  // Give the system a pointer to the matrix assembly  // function.  system.attach_assemble_function (assemble_poisson);    // Initialize the data structures for the equation system.  equation_systems.init();  // Print information about the system to the screen.  equation_systems.print_info();  mesh.print_info();  // Solve the system "Poisson", just like example 2.  equation_systems.get_system("Poisson").solve();  // After solving the system write the solution  // to a GMV-formatted plot file.  if(dim == 1)  {            GnuPlotIO plot(mesh,"Example 4, 1D",GnuPlotIO::GRID_ON);    plot.write_equation_systems("out_1",equation_systems);  }  else  {    GMVIO (mesh).write_equation_systems ((dim == 3) ?       "out_3.gmv" : "out_2.gmv",equation_systems);  }    // All done.    return 0;}//////// We now define the matrix assembly function for the// Poisson system.  We need to first compute element// matrices and right-hand sides, and then take into// account the boundary conditions, which will be handled// via a penalty method.void assemble_poisson(EquationSystems& es,                      const std::string& system_name){  // It is a good idea to make sure we are assembling  // the proper system.  libmesh_assert (system_name == "Poisson");  // Declare a performance log.  Give it a descriptive  // string to identify what part of the code we are  // logging, since there may be many PerfLogs in an  // application.  PerfLog perf_log ("Matrix Assembly");      // Get a constant reference to the mesh object.  const MeshBase& mesh = es.get_mesh();  // The dimension that we are running  const unsigned int dim = mesh.mesh_dimension();  // Get a reference to the LinearImplicitSystem we are solving  LinearImplicitSystem& system = es.get_system<LinearImplicitSystem>("Poisson");    // A reference to the \p DofMap object for this system.  The \p DofMap  // object handles the index translation from node and element numbers  // to degree of freedom numbers.  We will talk more about the \p DofMap