libMesh
Functions | Variables
introduction_ex5.C File Reference

Go to the source code of this file.

Functions

void assemble_poisson (EquationSystems &es, const std::string &system_name)
 
Real exact_solution (const Real x, const Real y, const Real z=0.)
 This is the exact solution that we are trying to obtain. More...
 
void exact_solution_wrapper (DenseVector< Number > &output, const Point &p, const Real)
 
int main (int argc, char **argv)
 
void assemble_poisson (EquationSystems &es, const std::string &libmesh_dbg_var(system_name))
 

Variables

QuadratureType quad_type =INVALID_Q_RULE
 

Function Documentation

◆ assemble_poisson() [1/2]

void assemble_poisson ( EquationSystems es,
const std::string &  system_name 
)

Definition at line 261 of file miscellaneous_ex16.C.

Referenced by main().

262 {
263  // Get a constant reference to the mesh object.
264  const MeshBase & mesh = es.get_mesh();
265 
266  // The dimension that we are running
267  const unsigned int dim = mesh.mesh_dimension();
268 
269  // Get a reference to the LinearImplicitSystem we are solving
270  LinearImplicitSystem & system = es.get_system<LinearImplicitSystem>(system_name);
271 
272  // Get a pointer to the StaticCondensation class if it exists
273  StaticCondensation * sc = nullptr;
274  if (system.has_static_condensation())
275  sc = &system.get_static_condensation();
276 
277  // A reference to the DofMap object for this system. The DofMap
278  // object handles the index translation from node and element numbers
279  // to degree of freedom numbers. We will talk more about the DofMap
280  // in future examples.
281  const DofMap & dof_map = system.get_dof_map();
282 
283  // Get a constant reference to the Finite Element type
284  // for the first (and only) variable in the system.
285  FEType fe_type = dof_map.variable_type(0);
286 
287  // Build a Finite Element object of the specified type. Since the
288  // FEBase::build() member dynamically creates memory we will
289  // store the object as a std::unique_ptr<FEBase>. This can be thought
290  // of as a pointer that will clean up after itself. Introduction Example 4
291  // describes some advantages of std::unique_ptr's in the context of
292  // quadrature rules.
293  std::unique_ptr<FEBase> fe(FEBase::build(dim, fe_type));
294 
295  // A 5th order Gauss quadrature rule for numerical integration.
296  QGauss qrule(dim, FIFTH);
297 
298  // Tell the finite element object to use our quadrature rule.
299  fe->attach_quadrature_rule(&qrule);
300 
301  // Declare a special finite element object for
302  // boundary integration.
303  std::unique_ptr<FEBase> fe_face(FEBase::build(dim, fe_type));
304 
305  // Boundary integration requires one quadrature rule,
306  // with dimensionality one less than the dimensionality
307  // of the element.
308  QGauss qface(dim - 1, FIFTH);
309 
310  // Tell the finite element object to use our
311  // quadrature rule.
312  fe_face->attach_quadrature_rule(&qface);
313 
314  // Here we define some references to cell-specific data that
315  // will be used to assemble the linear system.
316  //
317  // The element Jacobian * quadrature weight at each integration point.
318  const std::vector<Real> & JxW = fe->get_JxW();
319 
320  // The physical XY locations of the quadrature points on the element.
321  // These might be useful for evaluating spatially varying material
322  // properties at the quadrature points.
323  const std::vector<Point> & q_point = fe->get_xyz();
324 
325  // The element shape functions evaluated at the quadrature points.
326  const std::vector<std::vector<Real>> & phi = fe->get_phi();
327 
328  // The element shape function gradients evaluated at the quadrature
329  // points.
330  const std::vector<std::vector<RealGradient>> & dphi = fe->get_dphi();
331 
332  // Define data structures to contain the element matrix
333  // and right-hand-side vector contribution. Following
334  // basic finite element terminology we will denote these
335  // "Ke" and "Fe". These datatypes are templated on
336  // Number, which allows the same code to work for real
337  // or complex numbers.
340 
341  // This vector will hold the degree of freedom indices for
342  // the element. These define where in the global system
343  // the element degrees of freedom get mapped.
344  std::vector<dof_id_type> dof_indices;
345 
346  // The global system matrix
347  SparseMatrix<Number> & matrix = system.get_system_matrix();
348 
349  // Now we will loop over all the elements in the mesh.
350  // We will compute the element matrix and right-hand-side
351  // contribution.
352  //
353  // Element ranges are a nice way to iterate through all the
354  // elements, or all the elements that have some property. The
355  // range will iterate from the first to the last element on
356  // the local processor.
357  // It is smart to make this one const so that we don't accidentally
358  // mess it up! In case users later modify this program to include
359  // refinement, we will be safe and will only consider the active
360  // elements; hence we use a variant of the
361  // active_local_element_ptr_range.
362  for (const auto & elem : mesh.active_local_element_ptr_range())
363  {
364  // Get the degree of freedom indices for the
365  // current element. These define where in the global
366  // matrix and right-hand-side this element will
367  // contribute to.
368  dof_map.dof_indices(elem, dof_indices);
369 
370  // Cache the number of degrees of freedom on this element, for
371  // use as a loop bound later. We use cast_int to explicitly
372  // convert from size() (which may be 64-bit) to unsigned int
373  // (which may be 32-bit but which is definitely enough to count
374  // *local* degrees of freedom.
375  const unsigned int n_dofs = cast_int<unsigned int>(dof_indices.size());
376 
377  // Compute the element-specific data for the current
378  // element. This involves computing the location of the
379  // quadrature points (q_point) and the shape functions
380  // (phi, dphi) for the current element.
381  fe->reinit(elem);
382 
383  // With one variable, we should have the same number of degrees
384  // of freedom as shape functions.
385  libmesh_assert_equal_to(n_dofs, phi.size());
386 
387  // Zero the element matrix and right-hand side before
388  // summing them. We use the resize member here because
389  // the number of degrees of freedom might have changed from
390  // the last element. Note that this will be the case if the
391  // element type is different (i.e. the last element was a
392  // triangle, now we are on a quadrilateral).
393 
394  // The DenseMatrix::resize() and the DenseVector::resize()
395  // members will automatically zero out the matrix and vector.
396  Ke.resize(n_dofs, n_dofs);
397 
398  Fe.resize(n_dofs);
399 
400  // Now loop over the quadrature points. This handles
401  // the numeric integration.
402  for (unsigned int qp = 0; qp < qrule.n_points(); qp++)
403  {
404 
405  // Now we will build the element matrix. This involves
406  // a double loop to integrate the test functions (i) against
407  // the trial functions (j).
408  for (unsigned int i = 0; i != n_dofs; i++)
409  for (unsigned int j = 0; j != n_dofs; j++)
410  {
411  Ke(i, j) += JxW[qp] * (dphi[i][qp] * dphi[j][qp]);
412  }
413 
414  // This is the end of the matrix summation loop
415  // Now we build the element right-hand-side contribution.
416  // This involves a single loop in which we integrate the
417  // "forcing function" in the PDE against the test functions.
418  {
419  const Real x = q_point[qp](0);
420  const Real y = q_point[qp](1);
421  const Real eps = 1.e-3;
422 
423  // "fxy" is the forcing function for the Poisson equation.
424  // In this case we set fxy to be a finite difference
425  // Laplacian approximation to the (known) exact solution.
426  //
427  // We will use the second-order accurate FD Laplacian
428  // approximation, which in 2D is
429  //
430  // u_xx + u_yy = (u(i,j-1) + u(i,j+1) +
431  // u(i-1,j) + u(i+1,j) +
432  // -4*u(i,j))/h^2
433  //
434  // Since the value of the forcing function depends only
435  // on the location of the quadrature point (q_point[qp])
436  // we will compute it here, outside of the i-loop
437  const Real fxy =
438  -(exact_solution(x, y - eps) + exact_solution(x, y + eps) + exact_solution(x - eps, y) +
439  exact_solution(x + eps, y) - 4. * exact_solution(x, y)) /
440  eps / eps;
441 
442  for (unsigned int i = 0; i != n_dofs; i++)
443  Fe(i) += JxW[qp] * fxy * phi[i][qp];
444  }
445  }
446 
447  // We have now reached the end of the RHS summation,
448  // and the end of quadrature point loop, so
449  // the interior element integration has
450  // been completed. However, we have not yet addressed
451  // boundary conditions. For this example we will only
452  // consider simple Dirichlet boundary conditions.
453  //
454  // There are several ways Dirichlet boundary conditions
455  // can be imposed. A simple approach, which works for
456  // interpolary bases like the standard Lagrange polynomials,
457  // is to assign function values to the
458  // degrees of freedom living on the domain boundary. This
459  // works well for interpolary bases, but is more difficult
460  // when non-interpolary (e.g Legendre or Hierarchic) bases
461  // are used.
462  //
463  // Dirichlet boundary conditions can also be imposed with a
464  // "penalty" method. In this case essentially the L2 projection
465  // of the boundary values are added to the matrix. The
466  // projection is multiplied by some large factor so that, in
467  // floating point arithmetic, the existing (smaller) entries
468  // in the matrix and right-hand-side are effectively ignored.
469  //
470  // This amounts to adding a term of the form (in latex notation)
471  //
472  // \frac{1}{\epsilon} \int_{\delta \Omega} \phi_i \phi_j = \frac{1}{\epsilon} \int_{\delta
473  // \Omega} u \phi_i
474  //
475  // where
476  //
477  // \frac{1}{\epsilon} is the penalty parameter, defined such that \epsilon << 1
478  {
479 
480  // The following loop is over the sides of the element.
481  // If the element has no neighbor on a side then that
482  // side MUST live on a boundary of the domain.
483  for (auto side : elem->side_index_range())
484  if (elem->neighbor_ptr(side) == nullptr)
485  {
486  // The value of the shape functions at the quadrature
487  // points.
488  const std::vector<std::vector<Real>> & phi_face = fe_face->get_phi();
489 
490  // The Jacobian * Quadrature Weight at the quadrature
491  // points on the face.
492  const std::vector<Real> & JxW_face = fe_face->get_JxW();
493 
494  // The XYZ locations (in physical space) of the
495  // quadrature points on the face. This is where
496  // we will interpolate the boundary value function.
497  const std::vector<Point> & qface_point = fe_face->get_xyz();
498 
499  // Compute the shape function values on the element
500  // face.
501  fe_face->reinit(elem, side);
502 
503  // Some shape functions will be 0 on the face, but for
504  // ease of indexing and generality of code we loop over
505  // them anyway
506  libmesh_assert_equal_to(n_dofs, phi_face.size());
507 
508  // Loop over the face quadrature points for integration.
509  for (unsigned int qp = 0; qp < qface.n_points(); qp++)
510  {
511  // The location on the boundary of the current
512  // face quadrature point.
513  const Real xf = qface_point[qp](0);
514  const Real yf = qface_point[qp](1);
515 
516  // The penalty value. \frac{1}{\epsilon}
517  // in the discussion above.
518  const Real penalty = 1.e10;
519 
520  // The boundary value.
521  const Real value = exact_solution(xf, yf);
522 
523  // Matrix contribution of the L2 projection.
524  for (unsigned int i = 0; i != n_dofs; i++)
525  for (unsigned int j = 0; j != n_dofs; j++)
526  Ke(i, j) += JxW_face[qp] * penalty * phi_face[i][qp] * phi_face[j][qp];
527 
528  // Right-hand-side contribution of the L2
529  // projection.
530  for (unsigned int i = 0; i != n_dofs; i++)
531  Fe(i) += JxW_face[qp] * penalty * value * phi_face[i][qp];
532  }
533  }
534  }
535 
536  // We have now finished the quadrature point loop,
537  // and have therefore applied all the boundary conditions.
538 
539  // If this assembly program were to be used on an adaptive mesh,
540  // we would have to apply any hanging node constraint equations
541  dof_map.constrain_element_matrix_and_vector(Ke, Fe, dof_indices);
542 
543  if (sc)
544  sc->set_current_elem(*elem);
545 
546  // The element matrix and right-hand-side are now built
547  // for this element. Add them to the global matrix and
548  // right-hand-side vector. The SparseMatrix::add_matrix()
549  // and NumericVector::add_vector() members do this for us.
550  matrix.add_matrix(Ke, dof_indices);
551  system.rhs->add_vector(Fe, dof_indices);
552  }
553 
554  matrix.close();
555 }
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition: fe_type.h:196
Real exact_solution(const Real x, const Real y, const Real z=0.)
This is the exact solution that we are trying to obtain.
void constrain_element_matrix_and_vector(DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true) const
Constrains the element matrix and vector.
Definition: dof_map.h:2330
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
Definition: dof_map.C:2164
unsigned int dim
Manages consistently variables, degrees of freedom, coefficient vectors, matrices and linear solvers ...
void resize(const unsigned int n)
Resize the vector.
Definition: dense_vector.h:396
virtual void add_vector(const T *v, const std::vector< numeric_index_type > &dof_indices)
Computes , where v is a pointer and each dof_indices[i] specifies where to add value v[i]...
const FEType & variable_type(const unsigned int c) const
Definition: dof_map.h:2220
MeshBase & mesh
NumericVector< Number > * rhs
The system matrix.
bool has_static_condensation() const
Definition: system.C:2871
const T_sys & get_system(std::string_view name) const
This is the MeshBase class.
Definition: mesh_base.h:75
This class handles the numbering of degrees of freedom on a mesh.
Definition: dof_map.h:179
virtual void add_matrix(const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols)=0
Add the full matrix dm to the SparseMatrix.
StaticCondensation & get_static_condensation()
virtual void close()=0
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const MeshBase & get_mesh() const
static const bool value
Definition: xdr_io.C:54
void resize(const unsigned int new_m, const unsigned int new_n)
Resizes the matrix to the specified size and calls zero().
Definition: dense_matrix.h:895
This class implements specific orders of Gauss quadrature.
unsigned int mesh_dimension() const
Definition: mesh_base.C:372
const DofMap & get_dof_map() const
Definition: system.h:2374
const SparseMatrix< Number > & get_system_matrix() const

◆ assemble_poisson() [2/2]

void assemble_poisson ( EquationSystems es,
const std::string &  libmesh_dbg_varsystem_name 
)

Definition at line 212 of file introduction_ex5.C.

References libMesh::SparseMatrix< T >::add_matrix(), libMesh::NumericVector< T >::add_vector(), libMesh::QBase::build(), libMesh::FEGenericBase< OutputType >::build(), dim, exact_solution(), libMesh::System::get_dof_map(), libMesh::EquationSystems::get_mesh(), libMesh::EquationSystems::get_system(), libMesh::ImplicitSystem::get_system_matrix(), mesh, libMesh::MeshBase::mesh_dimension(), quad_type, libMesh::Real, libMesh::DenseVector< T >::resize(), libMesh::DenseMatrix< T >::resize(), libMesh::ExplicitSystem::rhs, and libMesh::THIRD.

214 {
215  libmesh_assert_equal_to (system_name, "Poisson");
216 
217  const MeshBase & mesh = es.get_mesh();
218 
219  const unsigned int dim = mesh.mesh_dimension();
220 
221  LinearImplicitSystem & system = es.get_system<LinearImplicitSystem>("Poisson");
222 
223  const DofMap & dof_map = system.get_dof_map();
224 
225  FEType fe_type = dof_map.variable_type(0);
226 
227  // Build a Finite Element object of the specified type. Since the
228  // FEBase::build() member dynamically creates memory we will
229  // store the object as a std::unique_ptr<FEBase>. Below, the
230  // functionality of std::unique_ptr's is described more detailed in
231  // the context of building quadrature rules.
232  std::unique_ptr<FEBase> fe (FEBase::build(dim, fe_type));
233 
234  // Now this deviates from example 4. we create a
235  // 5th order quadrature rule of user-specified type
236  // for numerical integration. Note that not all
237  // quadrature rules support this order.
238  std::unique_ptr<QBase> qrule(QBase::build(quad_type, dim, THIRD));
239 
240  // Tell the finite element object to use our
241  // quadrature rule. Note that a std::unique_ptr<QBase> returns
242  // a QBase* pointer to the object it handles with get().
243  // However, using get(), the std::unique_ptr<QBase> qrule is
244  // still in charge of this pointer. I.e., when qrule goes
245  // out of scope, it will safely delete the QBase object it
246  // points to. This behavior may be overridden using
247  // std::unique_ptr<Xyz>::release(), but is currently not
248  // recommended.
249  fe->attach_quadrature_rule (qrule.get());
250 
251  // Declare a special finite element object for
252  // boundary integration.
253  std::unique_ptr<FEBase> fe_face (FEBase::build(dim, fe_type));
254 
255  // As already seen in example 3, boundary integration
256  // requires a quadrature rule. Here, however,
257  // we use the more convenient way of building this
258  // rule at run-time using quad_type. Note that one
259  // could also have initialized the face quadrature rules
260  // with the type directly determined from qrule, namely
261  // through:
262  // \verbatim
263  // std::unique_ptr<QBase> qface (QBase::build(qrule->type(),
264  // dim-1,
265  // THIRD));
266  // \endverbatim
267  // And again: using the std::unique_ptr<QBase> relaxes
268  // the need to delete the object afterward,
269  // they clean up themselves.
270  std::unique_ptr<QBase> qface (QBase::build(quad_type,
271  dim-1,
272  THIRD));
273 
274  // Tell the finite element object to use our
275  // quadrature rule. Note that a std::unique_ptr<QBase> returns
276  // a QBase* pointer to the object it handles with get().
277  // However, using get(), the std::unique_ptr<QBase> qface is
278  // still in charge of this pointer. I.e., when qface goes
279  // out of scope, it will safely delete the QBase object it
280  // points to. This behavior may be overridden using
281  // std::unique_ptr<Xyz>::release(), but is not recommended.
282  fe_face->attach_quadrature_rule (qface.get());
283 
284  // This is again identical to example 4, and not commented.
285  const std::vector<Real> & JxW = fe->get_JxW();
286 
287  const std::vector<Point> & q_point = fe->get_xyz();
288 
289  const std::vector<std::vector<Real>> & phi = fe->get_phi();
290 
291  const std::vector<std::vector<RealGradient>> & dphi = fe->get_dphi();
292 
295  std::vector<dof_id_type> dof_indices;
296 
297  // The global system matrix
298  SparseMatrix<Number> & matrix = system.get_system_matrix();
299 
300  // Now we will loop over all the elements in the mesh.
301  // See example 3 for details.
302  for (const auto & elem : mesh.active_local_element_ptr_range())
303  {
304  dof_map.dof_indices (elem, dof_indices);
305 
306  const unsigned int n_dofs =
307  cast_int<unsigned int>(dof_indices.size());
308 
309  fe->reinit (elem);
310 
311  libmesh_assert_equal_to (n_dofs, phi.size());
312 
313  Ke.resize (n_dofs, n_dofs);
314 
315  Fe.resize (n_dofs);
316 
317  // Now loop over the quadrature points. This handles
318  // the numeric integration. Note the slightly different
319  // access to the QBase members!
320  for (unsigned int qp=0; qp<qrule->n_points(); qp++)
321  {
322  // Add the matrix contribution
323  for (unsigned int i=0; i != n_dofs; i++)
324  for (unsigned int j=0; j != n_dofs; j++)
325  Ke(i,j) += JxW[qp]*(dphi[i][qp]*dphi[j][qp]);
326 
327  // fxy is the forcing function for the Poisson equation.
328  // In this case we set fxy to be a finite difference
329  // Laplacian approximation to the (known) exact solution.
330  //
331  // We will use the second-order accurate FD Laplacian
332  // approximation, which in 2D on a structured grid is
333  //
334  // u_xx + u_yy = (u(i-1,j) + u(i+1,j) +
335  // u(i,j-1) + u(i,j+1) +
336  // -4*u(i,j))/h^2
337  //
338  // Since the value of the forcing function depends only
339  // on the location of the quadrature point (q_point[qp])
340  // we will compute it here, outside of the i-loop
341  const Real x = q_point[qp](0);
342  const Real y = q_point[qp](1);
343  const Real z = q_point[qp](2);
344  const Real eps = 1.e-3;
345 
346  const Real uxx = (exact_solution(x-eps, y, z) +
347  exact_solution(x+eps, y, z) +
348  -2.*exact_solution(x, y, z))/eps/eps;
349 
350  const Real uyy = (exact_solution(x, y-eps, z) +
351  exact_solution(x, y+eps, z) +
352  -2.*exact_solution(x, y, z))/eps/eps;
353 
354  const Real uzz = (exact_solution(x, y, z-eps) +
355  exact_solution(x, y, z+eps) +
356  -2.*exact_solution(x, y, z))/eps/eps;
357 
358  const Real fxy = - (uxx + uyy + ((dim==2) ? 0. : uzz));
359 
360 
361  // Add the RHS contribution
362  for (unsigned int i=0; i != n_dofs; i++)
363  Fe(i) += JxW[qp]*fxy*phi[i][qp];
364  }
365 
366  // If this assembly program were to be used on an adaptive mesh,
367  // we would have to apply any hanging node constraint equations
368  // Call heterogenously_constrain_element_matrix_and_vector to impose
369  // non-homogeneous Dirichlet BCs
370  dof_map.heterogenously_constrain_element_matrix_and_vector (Ke, Fe, dof_indices);
371 
372  // The element matrix and right-hand-side are now built
373  // for this element. Add them to the global matrix and
374  // right-hand-side vector. The SparseMatrix::add_matrix()
375  // and NumericVector::add_vector() members do this for us.
376  matrix.add_matrix (Ke, dof_indices);
377  system.rhs->add_vector (Fe, dof_indices);
378 
379  } // end of element loop
380 }
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
Definition: fe_type.h:196
unsigned int dim
Manages consistently variables, degrees of freedom, coefficient vectors, matrices and linear solvers ...
QuadratureType quad_type
void resize(const unsigned int n)
Resize the vector.
Definition: dense_vector.h:396
virtual void add_vector(const T *v, const std::vector< numeric_index_type > &dof_indices)
Computes , where v is a pointer and each dof_indices[i] specifies where to add value v[i]...
MeshBase & mesh
NumericVector< Number > * rhs
The system matrix.
const T_sys & get_system(std::string_view name) const
This is the MeshBase class.
Definition: mesh_base.h:75
This class handles the numbering of degrees of freedom on a mesh.
Definition: dof_map.h:179
virtual void add_matrix(const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols)=0
Add the full matrix dm to the SparseMatrix.
Real exact_solution(const Real x, const Real y, const Real z=0.)
This is the exact solution that we are trying to obtain.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const MeshBase & get_mesh() const
void resize(const unsigned int new_m, const unsigned int new_n)
Resizes the matrix to the specified size and calls zero().
Definition: dense_matrix.h:895
unsigned int mesh_dimension() const
Definition: mesh_base.C:372
const DofMap & get_dof_map() const
Definition: system.h:2374
const SparseMatrix< Number > & get_system_matrix() const

◆ exact_solution()

Real exact_solution ( const Real  x,
const Real  y,
const Real  t 
)

This is the exact solution that we are trying to obtain.

We will solve

  • (u_xx + u_yy) = f

and take a finite difference approximation using this function to get f. This is the well-known "method of manufactured solutions".

Definition at line 43 of file exact_solution.C.

Referenced by assemble_poisson(), and exact_solution_wrapper().

46 {
47  static const Real pi = acos(-1.);
48 
49  return cos(.5*pi*x)*sin(.5*pi*y)*cos(.5*pi*z);
50 }
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const Real pi
.
Definition: libmesh.h:299

◆ exact_solution_wrapper()

void exact_solution_wrapper ( DenseVector< Number > &  output,
const Point p,
const Real   
)

Definition at line 89 of file introduction_ex5.C.

References exact_solution().

Referenced by main().

92 {
93  output(0) = exact_solution(p(0), p(1), p(2));
94 }
Real exact_solution(const Real x, const Real y, const Real z=0.)
This is the exact solution that we are trying to obtain.

◆ main()

int main ( int  argc,
char **  argv 
)

Definition at line 103 of file introduction_ex5.C.

References libMesh::EquationSystems::add_system(), assemble_poisson(), libMesh::MeshTools::Generation::build_cube(), libMesh::command_line_next(), libMesh::default_solver_package(), exact_solution_wrapper(), libMesh::FIRST, libMesh::EquationSystems::get_system(), libMesh::HEX8, libMesh::TriangleWrapper::init(), libMesh::EquationSystems::init(), libMesh::INVALID_SOLVER_PACKAGE, mesh, libMesh::out, libMesh::EquationSystems::print_info(), libMesh::MeshBase::print_info(), quad_type, and libMesh::ExodusII_IO::write_equation_systems().

104 {
105  // Initialize libMesh and any dependent libraries, like in example 2.
106  LibMeshInit init (argc, argv);
107 
108  // This example requires a linear solver package.
109  libmesh_example_requires(libMesh::default_solver_package() != INVALID_SOLVER_PACKAGE,
110  "--enable-petsc, --enable-trilinos, or --enable-eigen");
111 
112  // Check for proper usage. The quadrature rule
113  // must be given at run time.
114  libmesh_error_msg_if(argc < 3,
115  "Usage: " << argv[0] << " -q <rule>\n"
116  " where <rule> is one of QGAUSS, QSIMPSON, or QTRAP.");
117 
118  // Tell the user what we are doing.
119  libMesh::out << "Running " << argv[0];
120 
121  for (int i=1; i<argc; i++)
122  libMesh::out << " " << argv[i];
123 
124  libMesh::out << std::endl << std::endl;
125 
126  // Set the quadrature rule type that the user wants
127  quad_type = Utility::string_to_enum<QuadratureType>
128  (libMesh::command_line_next("-q", std::string("QGAUSS")));
129 
130  // Skip this 3D example if libMesh was compiled as 1D-only.
131  libmesh_example_requires(3 <= LIBMESH_DIM, "3D support");
132 
133  // We use Dirichlet boundary conditions here
134 #ifndef LIBMESH_ENABLE_DIRICHLET
135  libmesh_example_requires(false, "--enable-dirichlet");
136 #endif
137 
138  // The following is identical to example 4, and therefore
139  // not commented. Differences are mentioned when present.
140  Mesh mesh(init.comm());
141 
142  // We will use a linear approximation space in this example,
143  // hence 8-noded hexahedral elements are sufficient. This
144  // is different than example 4 where we used 27-noded
145  // hexahedral elements to support a second-order approximation
146  // space.
148  16, 16, 16,
149  -1., 1.,
150  -1., 1.,
151  -1., 1.,
152  HEX8);
153 
154  mesh.print_info();
155 
156  EquationSystems equation_systems (mesh);
157 
158  equation_systems.add_system<LinearImplicitSystem> ("Poisson");
159 
160  unsigned int u_var = equation_systems.get_system("Poisson").add_variable("u", FIRST);
161 
162  equation_systems.get_system("Poisson").attach_assemble_function (assemble_poisson);
163 
164  // Construct a Dirichlet boundary condition object
165 
166  // Indicate which boundary IDs we impose the BC on
167  // We either build a line, a square or a cube, and
168  // here we indicate boundaries covering each case
169  std::set<boundary_id_type> boundary_ids {0,1,2,3,4,5};
170 
171  // Create an AnalyticFunction object that we use to project the BC
172  // This function just calls the function exact_solution via exact_solution_wrapper
173  AnalyticFunction<> exact_solution_object(exact_solution_wrapper);
174 
175 #ifdef LIBMESH_ENABLE_DIRICHLET
176  // In general, when reusing a system-indexed exact solution, we want
177  // to use the default system-ordering constructor for
178  // DirichletBoundary, so we demonstrate that here. In this case,
179  // though, we have only one variable, so system- and local-
180  // orderings are the same.
181  DirichletBoundary dirichlet_bc
182  (boundary_ids, {u_var}, exact_solution_object);
183 
184  // We must add the Dirichlet boundary condition _before_
185  // we call equation_systems.init()
186  equation_systems.get_system("Poisson").get_dof_map().add_dirichlet_boundary(dirichlet_bc);
187 #endif
188 
189  equation_systems.init();
190 
191  equation_systems.print_info();
192 
193  equation_systems.get_system("Poisson").solve();
194 
195  // "Personalize" the output, with the
196  // number of the quadrature rule appended.
197  std::ostringstream f_name;
198  f_name << "out_" << quad_type << ".e";
199 
200 #ifdef LIBMESH_HAVE_EXODUS_API
201  ExodusII_IO(mesh).write_equation_systems (f_name.str(),
202  equation_systems);
203 #endif // #ifdef LIBMESH_HAVE_EXODUS_API
204 
205  // All done.
206  return 0;
207 }
T command_line_next(std::string name, T default_value)
Use GetPot&#39;s search()/next() functions to get following arguments from the command line...
Definition: libmesh.C:1078
This is the EquationSystems class.
The ExodusII_IO class implements reading meshes in the ExodusII file format from Sandia National Labs...
Definition: exodusII_io.h:52
Manages consistently variables, degrees of freedom, coefficient vectors, matrices and linear solvers ...
QuadratureType quad_type
MeshBase & mesh
This class allows one to associate Dirichlet boundary values with a given set of mesh boundary ids an...
The LibMeshInit class, when constructed, initializes the dependent libraries (e.g.
Definition: libmesh.h:90
Wraps a function pointer into a FunctionBase object.
SolverPackage default_solver_package()
Definition: libmesh.C:1117
void exact_solution_wrapper(DenseVector< Number > &output, const Point &p, const Real)
virtual void write_equation_systems(const std::string &fname, const EquationSystems &es, const std::set< std::string > *system_names=nullptr) override
Writes out the solution for no specific time or timestep.
Definition: exodusII_io.C:2033
void print_info(std::ostream &os=libMesh::out, const unsigned int verbosity=0, const bool global=true) const
Prints relevant information about the mesh.
Definition: mesh_base.C:1562
void init(triangulateio &t)
Initializes the fields of t to nullptr/0 as necessary.
unsigned int add_variable(std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds the variable var to the list of variables for this system.
Definition: system.C:1357
OStreamProxy out
The Mesh class is a thin wrapper, around the ReplicatedMesh class by default.
Definition: mesh.h:50
void build_cube(UnstructuredMesh &mesh, const unsigned int nx=0, const unsigned int ny=0, const unsigned int nz=0, const Real xmin=0., const Real xmax=1., const Real ymin=0., const Real ymax=1., const Real zmin=0., const Real zmax=1., const ElemType type=INVALID_ELEM, const bool gauss_lobatto_grid=false)
Builds a (elements) cube.
void assemble_poisson(EquationSystems &es, const std::string &system_name)

Variable Documentation

◆ quad_type

QuadratureType quad_type =INVALID_Q_RULE

Definition at line 98 of file introduction_ex5.C.

Referenced by assemble_poisson(), and main().