Poster of Linux kernelThe best gift for a Linux geek
libMeshEnums

libMeshEnums

Section: C Library Functions (3) Updated: Thu Apr 7 2011
Local index Up
 

NAME

libMeshEnums -  

SYNOPSIS


 

Enumerations


enum EigenSolverType { POWER = 0, LAPACK, SUBSPACE, ARNOLDI, LANCZOS, KRYLOVSCHUR, INVALID_EIGENSOLVER }

enum EigenProblemType { NHEP = 0, HEP, GNHEP, GHEP, INVALID_EIGENPROBLEMTYPE }

enum PositionOfSpectrum { LARGEST_MAGNITUDE = 0, SMALLEST_MAGNITUDE, LARGEST_REAL, SMALLEST_REAL, LARGEST_IMAGINARY, SMALLEST_IMAGINARY, INVALID_Postion_of_Spectrum }

enum ElemQuality { ASPECT_RATIO = 0, SKEW, SHEAR, SHAPE, MAX_ANGLE, MIN_ANGLE, CONDITION, DISTORTION, TAPER, WARP, STRETCH, DIAGONAL, ASPECT_RATIO_BETA, ASPECT_RATIO_GAMMA, SIZE, JACOBIAN }

enum ElemType { EDGE2 = 0, EDGE3, EDGE4, TRI3, TRI6, QUAD4, QUAD8, QUAD9, TET4, TET10, HEX8, HEX20, HEX27, PRISM6, PRISM15, PRISM18, PYRAMID5, INFEDGE2, INFQUAD4, INFQUAD6, INFHEX8, INFHEX16, INFHEX18, INFPRISM6, INFPRISM12, NODEELEM, REMOTEELEM, INVALID_ELEM }

enum FEFamily { LAGRANGE = 0, HIERARCHIC = 1, MONOMIAL = 2, BERNSTEIN = 3, SZABAB = 4, XYZ = 5, INFINITE_MAP = 11, JACOBI_20_00 = 12, JACOBI_30_00 = 13, LEGENDRE = 14, CLOUGH = 21, HERMITE = 22, SCALAR = 31, INVALID_FE = 42 }

enum FEContinuity { DISCONTINUOUS, C_ZERO, C_ONE }

enum InfMapType { CARTESIAN = 0, SPHERICAL, ELLIPSOIDAL, INVALID_INF_MAP }

enum IOPackage { TECPLOT, GMV, GMSH, VTK, DIVA, TETGEN, UCD, LIBMESH, INVALID_IO_PACKAGE }

enum FEMNormType { L2 = 0, H1 = 1, H2 = 2, L1 = 5, L_INF = 6, H1_SEMINORM = 10, H2_SEMINORM = 11, W1_INF_SEMINORM = 15, W2_INF_SEMINORM = 16, DISCRETE_L1 = 20, DISCRETE_L2 = 21, DISCRETE_L_INF = 22, INVALID_NORM = 42 }

enum Order { CONSTANT = 0, FIRST = 1, SECOND = 2, THIRD = 3, FOURTH = 4, FIFTH = 5, SIXTH = 6, SEVENTH = 7, EIGHTH = 8, NINTH = 9, TENTH = 10, ELEVENTH = 11, TWELFTH = 12, THIRTEENTH = 13, FOURTEENTH = 14, FIFTEENTH = 15, SIXTEENTH = 16, SEVENTEENTH = 17, EIGHTTEENTH = 18, NINTEENTH = 19, TWENTIETH = 20, TWENTYFIRST = 21, TWENTYSECOND = 22, TWENTYTHIRD = 23, TWENTYFOURTH = 24, TWENTYFIFTH = 25, TWENTYSIXTH = 26, TWENTYSEVENTH = 27, TWENTYEIGHTH = 28, TWENTYNINTH = 29, THIRTIETH = 30, THIRTYFIRST = 31, THIRTYSECOND = 32, THIRTYTHIRD = 33, THIRTYFOURTH = 34, THIRTYFIFTH = 35, THIRTYSIXTH = 36, THIRTYSEVENTH = 37, THIRTYEIGHTH = 38, THIRTYNINTH = 39, FORTIETH = 40, FORTYFIRST = 41, FORTYSECOND = 42, FORTYTHIRD = 43, INVALID_ORDER }

enum ParallelType { AUTOMATIC = 0, SERIAL, PARALLEL, GHOSTED, INVALID_PARALLELIZATION }

enum PreconditionerType { IDENTITY_PRECOND = 0, JACOBI_PRECOND, BLOCK_JACOBI_PRECOND, SOR_PRECOND, SSOR_PRECOND, EISENSTAT_PRECOND, ASM_PRECOND, CHOLESKY_PRECOND, ICC_PRECOND, ILU_PRECOND, LU_PRECOND, USER_PRECOND, SHELL_PRECOND, AMG_PRECOND, INVALID_PRECONDITIONER }

enum QuadratureType { QGAUSS = 0, QJACOBI_1_0 = 1, QJACOBI_2_0 = 2, QSIMPSON = 3, QTRAP = 4, QGRID = 5, QGRUNDMANN_MOLLER = 6, QMONOMIAL = 7, QCONICAL = 8, QCLOUGH = 21, INVALID_Q_RULE = 127 }

enum SolverPackage { PETSC_SOLVERS = 0, TRILINOS_SOLVERS, LASPACK_SOLVERS, SLEPC_SOLVERS, INVALID_SOLVER_PACKAGE }

enum SolverType { CG = 0, CGN, CGS, CR, QMR, TCQMR, TFQMR, BICG, BICGSTAB, MINRES, GMRES, LSQR, JACOBI, SOR_FORWARD, SOR_BACKWARD, SSOR, RICHARDSON, CHEBYSHEV, INVALID_SOLVER }

enum XdrMODE { UNKNOWN = -1, ENCODE = 0, DECODE, WRITE, READ }
 

Detailed Description

The libMeshEnums namespace is the namespace all enum definitions should be put into.  

Enumeration Type Documentation

 

enum libMeshEnums::EigenProblemTypeDefines an enum for eigenproblem types. This can be Hermitian (HEP), generalized Hermitian (GHEP), non-Hermitian (NHEP), and generalized non-Hermitian (GNHEP)

Enumerator:

NHEP
HEP
GNHEP
GHEP
INVALID_EIGENPROBLEMTYPE

Definition at line 57 of file enum_eigen_solver_type.h.

                        {NHEP=0,
                         HEP,
                         GNHEP,
                         GHEP,
                   
                         INVALID_EIGENPROBLEMTYPE};
 

enum libMeshEnums::EigenSolverTypeDefines an enum for iterative eigenproblem solver types

Enumerator:

POWER
LAPACK
SUBSPACE
ARNOLDI
LANCZOS
KRYLOVSCHUR
INVALID_EIGENSOLVER

Definition at line 37 of file enum_eigen_solver_type.h.

                       {POWER=0,
                        LAPACK,
                        SUBSPACE,
                        ARNOLDI,
                        LANCZOS,
                        KRYLOVSCHUR,
                        // SLEPc optional packages
                        // EPSARPACK,
                        // EPSLAPACK,
                        // EPSBLZPACK,
                        // EPSPLANSO,
                        // EPSTRLAN,
                   
                        INVALID_EIGENSOLVER};
 

enum libMeshEnums::ElemQualityDefines an enum for element quality metrics.

Enumerator:

ASPECT_RATIO
SKEW
SHEAR
SHAPE
MAX_ANGLE
MIN_ANGLE
CONDITION
DISTORTION
TAPER
WARP
STRETCH
DIAGONAL
ASPECT_RATIO_BETA
ASPECT_RATIO_GAMMA
SIZE
JACOBIAN

Definition at line 32 of file enum_elem_quality.h.

                   {ASPECT_RATIO=0,
                    SKEW,
                    SHEAR,
                    SHAPE,
                    MAX_ANGLE,
                    MIN_ANGLE,
                    CONDITION,
                    DISTORTION,
                    TAPER,
                    WARP,
                    STRETCH,
                    DIAGONAL,
                    ASPECT_RATIO_BETA,
                    ASPECT_RATIO_GAMMA,
                    SIZE,
                    JACOBIAN};
 

enum libMeshEnums::ElemTypeDefines an enum for geometric element types.

Enumerator:

EDGE2
EDGE3
EDGE4
TRI3
TRI6
QUAD4
QUAD8
QUAD9
TET4
TET10
HEX8
HEX20
HEX27
PRISM6
PRISM15
PRISM18
PYRAMID5
INFEDGE2
INFQUAD4
INFQUAD6
INFHEX8
INFHEX16
INFHEX18
INFPRISM6
INFPRISM12
NODEELEM
REMOTEELEM
INVALID_ELEM

Definition at line 37 of file enum_elem_type.h.

                {EDGE2=0,    // 0
                 EDGE3,      // 1
                 EDGE4,      // 2
                 
                 TRI3,       // 3
                 TRI6,       // 4
                 
                 QUAD4,      // 5
                 QUAD8,      // 6
                 QUAD9,      // 7
                 
                 TET4,       // 8
                 TET10,      // 9
                 
                 HEX8,       // 10
                 HEX20,      // 11
                 HEX27,      // 12
                 
                 PRISM6,     // 13
                 PRISM15,    // 14
                 PRISM18,    // 15
                 
                 PYRAMID5,   // 16
                 
                 INFEDGE2,   // 17
                 
                 INFQUAD4,   // 18
                 INFQUAD6,   // 19
                 
                 INFHEX8,    // 20
                 INFHEX16,   // 21
                 INFHEX18,   // 22
                 
                 INFPRISM6,  // 23
                 INFPRISM12, // 24

                 NODEELEM,   // 25

                 REMOTEELEM,   // 26
                 
                 INVALID_ELEM};  // 27 - should always be last
 

enum libMeshEnums::FEContinuitydefines an enum for finite element types to libmesh_assert a certain level (or type? Hcurl?) of continuity.

Enumerator:

DISCONTINUOUS
C_ZERO
C_ONE

Definition at line 67 of file enum_fe_family.h.

                    {DISCONTINUOUS,
                     C_ZERO,
                     C_ONE};
 

enum libMeshEnums::FEFamilydefines an enum for finite element families.

Enumerator:

LAGRANGE
HIERARCHIC
MONOMIAL
BERNSTEIN
SZABAB
XYZ
INFINITE_MAP
JACOBI_20_00
JACOBI_30_00
LEGENDRE
CLOUGH
HERMITE
SCALAR
INVALID_FE

Definition at line 34 of file enum_fe_family.h.

                {LAGRANGE     = 0,
                 HIERARCHIC   = 1,

                 // discontinuous, in local coordinates
                 MONOMIAL     = 2,

                 // higher-order 
                 BERNSTEIN    = 3,
                 SZABAB       = 4,

                 // discontinuous, in global coordinates
                 XYZ          = 5,

                 // infinite element stuff
                 INFINITE_MAP = 11,     //   for 1/r-map
                 JACOBI_20_00 = 12,     //   i_max = 19
                 JACOBI_30_00 = 13,     //   i_max = 19
                 LEGENDRE     = 14,     //   i_max = 19

                 // C1 elements
                 CLOUGH       = 21,
                 HERMITE      = 22,

                 // A scalar variable that couples to 
                 // all other DOFs in the system
                 SCALAR       = 31,
                 
                 INVALID_FE   = 42};
 

enum libMeshEnums::FEMNormTypedefines an enum for norms defined on vectors of finite element coefficients

Enumerator:

L2
H1
H2
L1
L_INF
H1_SEMINORM
H2_SEMINORM
W1_INF_SEMINORM
W2_INF_SEMINORM
DISCRETE_L1
DISCRETE_L2
DISCRETE_L_INF
INVALID_NORM

Definition at line 34 of file enum_norm_type.h.

                   {L2              = 0,
                    H1              = 1,
                    H2              = 2,

                    L1              = 5,
                    L_INF           = 6,

                    H1_SEMINORM     = 10,
                    H2_SEMINORM     = 11,

                    W1_INF_SEMINORM = 15,
                    W2_INF_SEMINORM = 16,

                    // discrete vector norms
                    DISCRETE_L1     = 20,
                    DISCRETE_L2     = 21,
                    DISCRETE_L_INF  = 22,

                    INVALID_NORM    = 42};
 

enum libMeshEnums::InfMapTypedefines an enum for the types of coordinate mappings available in infinite elements.

Enumerator:

CARTESIAN
SPHERICAL
ELLIPSOIDAL
INVALID_INF_MAP

Definition at line 38 of file enum_inf_map_type.h.

                  {CARTESIAN=0,
                   SPHERICAL,
                   ELLIPSOIDAL,
                   INVALID_INF_MAP};
 

enum libMeshEnums::IOPackagelibMesh interfaces with several different software packages for the purposes of creating, reading, and writing mesh files. These enumerations give an easy way of selecting one or the other.

Enumerator:

TECPLOT
GMV
GMSH
VTK
DIVA
TETGEN
UCD
LIBMESH
INVALID_IO_PACKAGE

Definition at line 40 of file enum_io_package.h.

    { 
      TECPLOT,
      GMV,
      GMSH,
      VTK,
      DIVA,
      TETGEN,
      UCD,
      LIBMESH,
      INVALID_IO_PACKAGE
    };
 

enum libMeshEnums::Orderdefines an enum for polynomial orders. Fixing each label to a specific int, since InfFE and p refinement may cast between them

Enumerator:

CONSTANT
FIRST
SECOND
THIRD
FOURTH
FIFTH
SIXTH
SEVENTH
EIGHTH
NINTH
TENTH
ELEVENTH
TWELFTH
THIRTEENTH
FOURTEENTH
FIFTEENTH
SIXTEENTH
SEVENTEENTH
EIGHTTEENTH
NINTEENTH
TWENTIETH
TWENTYFIRST
TWENTYSECOND
TWENTYTHIRD
TWENTYFOURTH
TWENTYFIFTH
TWENTYSIXTH
TWENTYSEVENTH
TWENTYEIGHTH
TWENTYNINTH
THIRTIETH
THIRTYFIRST
THIRTYSECOND
THIRTYTHIRD
THIRTYFOURTH
THIRTYFIFTH
THIRTYSIXTH
THIRTYSEVENTH
THIRTYEIGHTH
THIRTYNINTH
FORTIETH
FORTYFIRST
FORTYSECOND
FORTYTHIRD
INVALID_ORDER

Definition at line 34 of file enum_order.h.

             {CONSTANT     =  0,
              FIRST        =  1,
              SECOND       =  2,
              THIRD        =  3,
              FOURTH       =  4,
              FIFTH        =  5,
              SIXTH        =  6,
              SEVENTH      =  7,
              EIGHTH       =  8,
              NINTH        =  9,
              TENTH        = 10,

              ELEVENTH     = 11,
              TWELFTH      = 12,
              THIRTEENTH   = 13,
              FOURTEENTH   = 14,
              FIFTEENTH    = 15,
              SIXTEENTH    = 16,
              SEVENTEENTH  = 17,
              EIGHTTEENTH  = 18,
              NINTEENTH    = 19,
              TWENTIETH    = 20,

              TWENTYFIRST   = 21,
              TWENTYSECOND  = 22,
              TWENTYTHIRD   = 23,             
              TWENTYFOURTH  = 24,
              TWENTYFIFTH   = 25,
              TWENTYSIXTH   = 26,
              TWENTYSEVENTH = 27,
              TWENTYEIGHTH  = 28,
              TWENTYNINTH   = 29,
              THIRTIETH     = 30,

              THIRTYFIRST   = 31,
              THIRTYSECOND  = 32,
              THIRTYTHIRD   = 33,
              THIRTYFOURTH  = 34,
              THIRTYFIFTH   = 35,
              THIRTYSIXTH   = 36,
              THIRTYSEVENTH = 37,
              THIRTYEIGHTH  = 38,
              THIRTYNINTH   = 39,
              FORTIETH     = 40,

              FORTYFIRST   = 41,
              FORTYSECOND  = 42,
              FORTYTHIRD   = 43,

              INVALID_ORDER};
 

enum libMeshEnums::ParallelTypeDefines an enum for parallel data structure types

Enumerator:

AUTOMATIC
SERIAL
PARALLEL
GHOSTED
INVALID_PARALLELIZATION

Definition at line 37 of file enum_parallel_type.h.

                    {AUTOMATIC=0,
                     SERIAL,
                     PARALLEL,
                     GHOSTED,
                   
                     INVALID_PARALLELIZATION};
 

enum libMeshEnums::PositionOfSpectrumDefines an enum for the position of the spectrum, i.e. the eigenvalues to be computed.

Enumerator:

LARGEST_MAGNITUDE
SMALLEST_MAGNITUDE
LARGEST_REAL
SMALLEST_REAL
LARGEST_IMAGINARY
SMALLEST_IMAGINARY
INVALID_Postion_of_Spectrum

Definition at line 70 of file enum_eigen_solver_type.h.

                          {LARGEST_MAGNITUDE=0,
                           SMALLEST_MAGNITUDE,
                           LARGEST_REAL,
                           SMALLEST_REAL,
                           LARGEST_IMAGINARY,
                           SMALLEST_IMAGINARY,
                        
                           INVALID_Postion_of_Spectrum};
 

enum libMeshEnums::PreconditionerTypeDefines an enum for preconditioner types

Enumerator:

IDENTITY_PRECOND
JACOBI_PRECOND
BLOCK_JACOBI_PRECOND
SOR_PRECOND
SSOR_PRECOND
EISENSTAT_PRECOND
ASM_PRECOND
CHOLESKY_PRECOND
ICC_PRECOND
ILU_PRECOND
LU_PRECOND
USER_PRECOND
SHELL_PRECOND
AMG_PRECOND
INVALID_PRECONDITIONER

Definition at line 37 of file enum_preconditioner_type.h.

                          {IDENTITY_PRECOND =0,
                           JACOBI_PRECOND,
                           BLOCK_JACOBI_PRECOND,
                           SOR_PRECOND,
                           SSOR_PRECOND,
                           EISENSTAT_PRECOND,
                           ASM_PRECOND,
                           CHOLESKY_PRECOND,
                           ICC_PRECOND,
                           ILU_PRECOND,
                           LU_PRECOND,
                           USER_PRECOND,
                           SHELL_PRECOND,
                           AMG_PRECOND,
                           
                           INVALID_PRECONDITIONER};
 

enum libMeshEnums::QuadratureTypeDefines an enum for currently available quadrature rules.

Enumerator:

QGAUSS
QJACOBI_1_0
QJACOBI_2_0
QSIMPSON
QTRAP
QGRID
QGRUNDMANN_MOLLER
QMONOMIAL
QCONICAL
QCLOUGH
INVALID_Q_RULE

Definition at line 32 of file enum_quadrature_type.h.

                      {QGAUSS            = 0,
                                         
                       QJACOBI_1_0       = 1,
                       QJACOBI_2_0       = 2,
                                         
                       QSIMPSON          = 3,
                       QTRAP             = 4,
                       QGRID             = 5,
                       QGRUNDMANN_MOLLER = 6,
                       QMONOMIAL         = 7,
                       QCONICAL          = 8,

                       QCLOUGH           = 21,

                       INVALID_Q_RULE    = 127};
 

enum libMeshEnums::SolverPackageDefines an enum for various linear solver packages. This allows for run-time switching between solver packages

Enumerator:

PETSC_SOLVERS
TRILINOS_SOLVERS
LASPACK_SOLVERS
SLEPC_SOLVERS
INVALID_SOLVER_PACKAGE

Definition at line 39 of file enum_solver_package.h.

    { 
      PETSC_SOLVERS=0,
      TRILINOS_SOLVERS,
      LASPACK_SOLVERS,
      SLEPC_SOLVERS,
      
      INVALID_SOLVER_PACKAGE
    };
 

enum libMeshEnums::SolverTypeDefines an enum for iterative solver types

Enumerator:

CG
CGN
CGS
CR
QMR
TCQMR
TFQMR
BICG
BICGSTAB
MINRES
GMRES
LSQR
JACOBI
SOR_FORWARD
SOR_BACKWARD
SSOR
RICHARDSON
CHEBYSHEV
INVALID_SOLVER

Definition at line 37 of file enum_solver_type.h.

                  {CG=0,
                   CGN,
                   CGS,
                   CR,
                   QMR,
                   TCQMR,
                   TFQMR,
                   BICG,
                   BICGSTAB,
                   MINRES,
                   GMRES,
                   LSQR,
                   JACOBI,
                   SOR_FORWARD,
                   SOR_BACKWARD,
                   SSOR,
                   RICHARDSON,
                   CHEBYSHEV,
                   
                   INVALID_SOLVER};
 

enum libMeshEnums::XdrMODEDefines an enum for read/write mode in Xdr format. READ, WRITE perform reading and writing in ASCII format, and DECODE, ENCODE do the same in binary format.

Enumerator:

UNKNOWN
ENCODE
DECODE
WRITE
READ

Definition at line 39 of file enum_xdr_mode.h.

    {
      UNKNOWN = -1, ENCODE=0, DECODE, WRITE, READ
    };
 

Author

Generated automatically by Doxygen for libMesh from the source code.


 

Index

NAME
SYNOPSIS
Enumerations
Detailed Description
Enumeration Type Documentation
enum libMeshEnums::EigenProblemTypeDefines an enum for eigenproblem types. This can be Hermitian (HEP), generalized Hermitian (GHEP), non-Hermitian (NHEP), and generalized non-Hermitian (GNHEP)
enum libMeshEnums::EigenSolverTypeDefines an enum for iterative eigenproblem solver types
enum libMeshEnums::ElemQualityDefines an enum for element quality metrics.
enum libMeshEnums::ElemTypeDefines an enum for geometric element types.
enum libMeshEnums::FEContinuitydefines an enum for finite element types to libmesh_assert a certain level (or type? Hcurl?) of continuity.
enum libMeshEnums::FEFamilydefines an enum for finite element families.
enum libMeshEnums::FEMNormTypedefines an enum for norms defined on vectors of finite element coefficients
enum libMeshEnums::InfMapTypedefines an enum for the types of coordinate mappings available in infinite elements.
enum libMeshEnums::IOPackagelibMesh interfaces with several different software packages for the purposes of creating, reading, and writing mesh files. These enumerations give an easy way of selecting one or the other.
enum libMeshEnums::Orderdefines an enum for polynomial orders. Fixing each label to a specific int, since InfFE and p refinement may cast between them
enum libMeshEnums::ParallelTypeDefines an enum for parallel data structure types
enum libMeshEnums::PositionOfSpectrumDefines an enum for the position of the spectrum, i.e. the eigenvalues to be computed.
enum libMeshEnums::PreconditionerTypeDefines an enum for preconditioner types
enum libMeshEnums::QuadratureTypeDefines an enum for currently available quadrature rules.
enum libMeshEnums::SolverPackageDefines an enum for various linear solver packages. This allows for run-time switching between solver packages
enum libMeshEnums::SolverTypeDefines an enum for iterative solver types
enum libMeshEnums::XdrMODEDefines an enum for read/write mode in Xdr format. READ, WRITE perform reading and writing in ASCII format, and DECODE, ENCODE do the same in binary format.
Author

This document was created by man2html, using the manual pages.
Time: 21:49:20 GMT, April 16, 2011