libMeshEnums Namespace Reference


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::EigenProblemType

Defines 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.

00057                         {NHEP=0,
00058                          HEP,
00059                          GNHEP,
00060                          GHEP,
00061                    
00062                          INVALID_EIGENPROBLEMTYPE};

enum libMeshEnums::EigenSolverType

Defines 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.

00037                        {POWER=0,
00038                         LAPACK,
00039                         SUBSPACE,
00040                         ARNOLDI,
00041                         LANCZOS,
00042                         KRYLOVSCHUR,
00043                         // SLEPc optional packages
00044                         // EPSARPACK,
00045                         // EPSLAPACK,
00046                         // EPSBLZPACK,
00047                         // EPSPLANSO,
00048                         // EPSTRLAN,
00049                    
00050                         INVALID_EIGENSOLVER};

enum libMeshEnums::ElemQuality

Defines 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.

00032                    {ASPECT_RATIO=0,
00033                     SKEW,
00034                     SHEAR,
00035                     SHAPE,
00036                     MAX_ANGLE,
00037                     MIN_ANGLE,
00038                     CONDITION,
00039                     DISTORTION,
00040                     TAPER,
00041                     WARP,
00042                     STRETCH,
00043                     DIAGONAL,
00044                     ASPECT_RATIO_BETA,
00045                     ASPECT_RATIO_GAMMA,
00046                     SIZE,
00047                     JACOBIAN};

enum libMeshEnums::ElemType

Defines 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.

00037                 {EDGE2=0,    // 0
00038                  EDGE3,      // 1
00039                  EDGE4,      // 2
00040                  
00041                  TRI3,       // 3
00042                  TRI6,       // 4
00043                  
00044                  QUAD4,      // 5
00045                  QUAD8,      // 6
00046                  QUAD9,      // 7
00047                  
00048                  TET4,       // 8
00049                  TET10,      // 9
00050                  
00051                  HEX8,       // 10
00052                  HEX20,      // 11
00053                  HEX27,      // 12
00054                  
00055                  PRISM6,     // 13
00056                  PRISM15,    // 14
00057                  PRISM18,    // 15
00058                  
00059                  PYRAMID5,   // 16
00060                  
00061                  INFEDGE2,   // 17
00062                  
00063                  INFQUAD4,   // 18
00064                  INFQUAD6,   // 19
00065                  
00066                  INFHEX8,    // 20
00067                  INFHEX16,   // 21
00068                  INFHEX18,   // 22
00069                  
00070                  INFPRISM6,  // 23
00071                  INFPRISM12, // 24
00072 
00073                  NODEELEM,   // 25
00074 
00075                  REMOTEELEM,   // 26
00076                  
00077                  INVALID_ELEM};  // 27 - should always be last

enum libMeshEnums::FEContinuity

defines 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.

00067                     {DISCONTINUOUS,
00068                      C_ZERO,
00069                      C_ONE};

enum libMeshEnums::FEFamily

defines 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.

00034                 {LAGRANGE     = 0,
00035                  HIERARCHIC   = 1,
00036 
00037                  // discontinuous, in local coordinates
00038                  MONOMIAL     = 2,
00039 
00040                  // higher-order 
00041                  BERNSTEIN    = 3,
00042                  SZABAB       = 4,
00043 
00044                  // discontinuous, in global coordinates
00045                  XYZ          = 5,
00046 
00047                  // infinite element stuff
00048                  INFINITE_MAP = 11,     //   for 1/r-map
00049                  JACOBI_20_00 = 12,     //   i_max = 19
00050                  JACOBI_30_00 = 13,     //   i_max = 19
00051                  LEGENDRE     = 14,     //   i_max = 19
00052 
00053                  // C1 elements
00054                  CLOUGH       = 21,
00055                  HERMITE      = 22,
00056 
00057                  // A scalar variable that couples to 
00058                  // all other DOFs in the system
00059                  SCALAR       = 31,
00060                  
00061                  INVALID_FE   = 42};

enum libMeshEnums::FEMNormType

defines 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.

00034                    {L2              = 0,
00035                     H1              = 1,
00036                     H2              = 2,
00037 
00038                     L1              = 5,
00039                     L_INF           = 6,
00040 
00041                     H1_SEMINORM     = 10,
00042                     H2_SEMINORM     = 11,
00043 
00044                     W1_INF_SEMINORM = 15,
00045                     W2_INF_SEMINORM = 16,
00046 
00047                     // discrete vector norms
00048                     DISCRETE_L1     = 20,
00049                     DISCRETE_L2     = 21,
00050                     DISCRETE_L_INF  = 22,
00051 
00052                     INVALID_NORM    = 42};

enum libMeshEnums::InfMapType

defines 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.

00038                   {CARTESIAN=0,
00039                    SPHERICAL,
00040                    ELLIPSOIDAL,
00041                    INVALID_INF_MAP};

enum libMeshEnums::IOPackage

libMesh 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.

00041     { 
00042       TECPLOT,
00043       GMV,
00044       GMSH,
00045       VTK,
00046       DIVA,
00047       TETGEN,
00048       UCD,
00049       LIBMESH,
00050       INVALID_IO_PACKAGE
00051     };

enum libMeshEnums::Order

defines 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.

00034              {CONSTANT     =  0,
00035               FIRST        =  1,
00036               SECOND       =  2,
00037               THIRD        =  3,
00038               FOURTH       =  4,
00039               FIFTH        =  5,
00040               SIXTH        =  6,
00041               SEVENTH      =  7,
00042               EIGHTH       =  8,
00043               NINTH        =  9,
00044               TENTH        = 10,
00045 
00046               ELEVENTH     = 11,
00047               TWELFTH      = 12,
00048               THIRTEENTH   = 13,
00049               FOURTEENTH   = 14,
00050               FIFTEENTH    = 15,
00051               SIXTEENTH    = 16,
00052               SEVENTEENTH  = 17,
00053               EIGHTTEENTH  = 18,
00054               NINTEENTH    = 19,
00055               TWENTIETH    = 20,
00056 
00057               TWENTYFIRST   = 21,
00058               TWENTYSECOND  = 22,
00059               TWENTYTHIRD   = 23,             
00060               TWENTYFOURTH  = 24,
00061               TWENTYFIFTH   = 25,
00062               TWENTYSIXTH   = 26,
00063               TWENTYSEVENTH = 27,
00064               TWENTYEIGHTH  = 28,
00065               TWENTYNINTH   = 29,
00066               THIRTIETH     = 30,
00067 
00068               THIRTYFIRST   = 31,
00069               THIRTYSECOND  = 32,
00070               THIRTYTHIRD   = 33,
00071               THIRTYFOURTH  = 34,
00072               THIRTYFIFTH   = 35,
00073               THIRTYSIXTH   = 36,
00074               THIRTYSEVENTH = 37,
00075               THIRTYEIGHTH  = 38,
00076               THIRTYNINTH   = 39,
00077               FORTIETH     = 40,
00078 
00079               FORTYFIRST   = 41,
00080               FORTYSECOND  = 42,
00081               FORTYTHIRD   = 43,
00082 
00083               INVALID_ORDER};

enum libMeshEnums::ParallelType

Defines an enum for parallel data structure types

Enumerator:

AUTOMATIC
SERIAL
PARALLEL
GHOSTED
INVALID_PARALLELIZATION

Definition at line 37 of file enum_parallel_type.h.

00037                     {AUTOMATIC=0,
00038                      SERIAL,
00039                      PARALLEL,
00040                      GHOSTED,
00041                    
00042                      INVALID_PARALLELIZATION};

enum libMeshEnums::PositionOfSpectrum

Defines 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.

00070                           {LARGEST_MAGNITUDE=0,
00071                            SMALLEST_MAGNITUDE,
00072                            LARGEST_REAL,
00073                            SMALLEST_REAL,
00074                            LARGEST_IMAGINARY,
00075                            SMALLEST_IMAGINARY,
00076                         
00077                            INVALID_Postion_of_Spectrum};

enum libMeshEnums::PreconditionerType

Defines 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.

00037                           {IDENTITY_PRECOND =0,
00038                            JACOBI_PRECOND,
00039                            BLOCK_JACOBI_PRECOND,
00040                            SOR_PRECOND,
00041                            SSOR_PRECOND,
00042                            EISENSTAT_PRECOND,
00043                            ASM_PRECOND,
00044                            CHOLESKY_PRECOND,
00045                            ICC_PRECOND,
00046                            ILU_PRECOND,
00047                            LU_PRECOND,
00048                            USER_PRECOND,
00049                            SHELL_PRECOND,
00050                            AMG_PRECOND,
00051                            
00052                            INVALID_PRECONDITIONER};

enum libMeshEnums::QuadratureType

Defines 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.

00032                       {QGAUSS            = 0,
00033                                          
00034                        QJACOBI_1_0       = 1,
00035                        QJACOBI_2_0       = 2,
00036                                          
00037                        QSIMPSON          = 3,
00038                        QTRAP             = 4,
00039                        QGRID             = 5,
00040                        QGRUNDMANN_MOLLER = 6,
00041                        QMONOMIAL         = 7,
00042                        QCONICAL          = 8,
00043 
00044                        QCLOUGH           = 21,
00045 
00046                        INVALID_Q_RULE    = 127};

enum libMeshEnums::SolverPackage

Defines 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.

00040     { 
00041       PETSC_SOLVERS=0,
00042       TRILINOS_SOLVERS,
00043       LASPACK_SOLVERS,
00044       SLEPC_SOLVERS,
00045       
00046       INVALID_SOLVER_PACKAGE
00047     };

enum libMeshEnums::SolverType

Defines 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.

00037                   {CG=0,
00038                    CGN,
00039                    CGS,
00040                    CR,
00041                    QMR,
00042                    TCQMR,
00043                    TFQMR,
00044                    BICG,
00045                    BICGSTAB,
00046                    MINRES,
00047                    GMRES,
00048                    LSQR,
00049                    JACOBI,
00050                    SOR_FORWARD,
00051                    SOR_BACKWARD,
00052                    SSOR,
00053                    RICHARDSON,
00054                    CHEBYSHEV,
00055                    
00056                    INVALID_SOLVER};

enum libMeshEnums::XdrMODE

Defines 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.

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

libMeshEnums Namespace Reference

Enumerations

Detailed Description

Enumeration Type Documentation