Logo  0.95.0-final
Finite Element Embedded Library and Language in C++
Feel++ Feel++ on Github Feel++ community
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Feel Namespace Reference

[marker1] More...

Namespaces

 detail
 
 math
 

Classes

class  AboutData
 Holds information needed by the "About" box and other classes. More...
 
class  AboutPerson
 
class  ADExpr
 brief description More...
 
class  ADType
 Automatically Diffentiated Numerical Type. More...
 
class  Advection
 
class  AdvReact
 Advection-Reaction solver. More...
 
class  Air
 Air material. More...
 
class  Aitken
 Aitken relaxation method for fixed point iterations. More...
 
class  Application
 provides information about the Application More...
 
class  ApplicationXML
 XML application. More...
 
class  AssertContext
 contains details about a failed assertion More...
 
class  Backend
 base class for all linear algebra backends More...
 
class  BackendEigen
 
class  BareEdge
 The Edge basis class It contains the attributes common to all Edges In particular, it contains the two size_type's (first and second) of the points at the two ends of the edge. More...
 
class  BareFace
 The base Face class. More...
 
class  BareItemsHandler
 Bare Items Handler. More...
 
class  BarePoint
 The Point basis class It contains the attributes common to all Points In particular, it contains the one size_type's (first) of the point. More...
 
class  Basis
 Base class for basis. More...
 
class  Bdf
 Backward differencing formula time discretization. More...
 
struct  BFGSInvHessian
 
class  BoundaryAdapted
 BoundaryAdapted Basis on simplex. More...
 
class  BoundingBox
 bounding box for a matrix of points More...
 
class  CastIron
 Cast iron material. More...
 
struct  cmpBareItem
 
struct  cmpBareItem< BareEdge >
 < The actual comparison operator More...
 
struct  cmpBareItem< BareFace >
 
struct  cmpBareItem< BarePoint >
 < The actual comparison operator More...
 
struct  Component
 
class  Context
 Context class. More...
 
class  Continuous
 describe continuous functions More...
 
class  Convex
 Convex base class. More...
 
class  core_data
 
class  CRB
 Certifed Reduced Basis class. More...
 
class  CRBApp
 Certified Reduced Basis application. More...
 
class  CRBDB
 brief description More...
 
class  CRBModel
 Certified Reduced Basis Model class. More...
 
class  CRBModelTrilinear
 Certified Reduced Basis Model trilinear class. More...
 
class  CRBSCM
 SCM algorithm. More...
 
class  CRBTrilinear
 Certifed Reduced Basis for Trilinear forms class. More...
 
class  DAR
 
class  DataMap
 data layout in a multi-processor environnement More...
 
class  DirScalingMatrix
 implements the directional Scaling Matrix for directionally-scaled trust region More...
 
class  DiscontinuousInterfaces
 describes discontinuous interfaces and provide dof creation More...
 
class  Dof
 class that represents a degree of freedom More...
 
class  DofComposite
 Compositing of degree of freedom table. More...
 
class  DofTable
 Local-to-global Degree of Freedom table. More...
 
class  DualBasis
 basis of a space P' dual of some space P More...
 
class  Dubiner
 Dubiner polynomial orthonormal basis. More...
 
class  dummy_data
 dummy data type More...
 
class  EIM
 Empirical interpolation of a function to obtain an affine decomposition. More...
 
class  Elaxi
 
class  equalities
 define the equalities type More...
 
class  ErrorBase
 
class  Example
 Brief description of the class Example. More...
 
class  Exporter
 export Feel generated data to some file formatsUse the visitor and factory pattern. More...
 
class  ExporterEnsight
 exporter to Ensight format More...
 
class  ExporterEnsightGold
 exporter to EnsightGold format More...
 
class  ExporterExodus
 exporter to Exodus format More...
 
class  ExporterGmsh
 Exporter to GMSH format. More...
 
class  ExporterGnuplot
 Exporter to GNUPLOT format. More...
 
class  ExporterQuick
 simple interface to exporter More...
 
class  ExprBase
 Base class for expression. More...
 
class  Factory
 Implements a generic object Factory. More...
 
class  FactoryClone
 Implements a generic cloning object Factory. More...
 
struct  FactoryDefaultError
 
class  FilterFromVtk
 
class  FilterFromVtk3D
 
class  FiniteElement
 Finite element following Ciarlet framework. More...
 
class  Functional
 represents a linear functional More...
 
class  functional
 defines the functional type More...
 
class  FunctionalSet
 Set of functionals. More...
 
class  FunctionSpace
 
class  FunctionSpaceBase
 brief description More...
 
class  Gauss
 Gauss quadrature points. More...
 
class  GaussLobatto
 Gauss quadrature points. More...
 
class  Geo0D
 
class  GeoElement0D
 
class  GeoElement1D
 class for 1D elements More...
 
class  GeoElement2D
 Class for 2D elements. More...
 
class  GeoElement3D
 Class for 3D elements. More...
 
class  GeoEntity
 base class for all geometric entities More...
 
class  GeoMap
 Structure for the geometrical mapping. More...
 
class  GeoMapInverse
 handles the geometric inversion for a given (supposedly quite large) set of points More...
 
class  GeoND
 Base class for Multi-dimensional basis Geometrical Entities. More...
 
class  Gmsh
 Gmsh Mesh Generator. More...
 
class  GmshEllipsoidDomain
 n-Ellipsoid Domain description for gmsh mesh generation. More...
 
class  GmshHypercubeDomain
 Tensorized Domain description for gmsh mesh generation. More...
 
class  GmshSimplexDomain
 Simplex Domain description for gmsh mesh generation. More...
 
class  GraphCSR
 Graph representation of the Compressed Sparse Row format. More...
 
class  Ground
 Heating and Cooling of the ground due to surface temperature. More...
 
class  HeatSink
 
class  IMExact
 exact integration method More...
 
class  IMGeneral
 integration method interface class More...
 
class  Importer
 
class  ImporterGmsh
 gmsh importer class More...
 
struct  IMTetrahedra< 1, T >
 
class  inequalities
 define the inequalities type More...
 
class  Info
 information provider for versioning and installation directories More...
 
struct  IntegrationDegree
 
class  Iteration
 brief description More...
 
class  Jacobi
 1D Jacobi polynomial More...
 
struct  JacobiDegree
 
class  KDTree
 KDTree class. More...
 
class  Laplacian
 
class  LaplacianLM
 
class  Legendre
 Legendre polynomial orthonormal basis. More...
 
class  LU
 
class  Material
 Material base class. More...
 
class  MaterialLib
 Material library. More...
 
struct  matrix_node
 
class  MatrixBlock
 block of matrices More...
 
class  MatrixBlockBase
 ! More...
 
class  MatrixEigenDense
 interface to eigen sparse matrix More...
 
class  MatrixEigenSparse
 interface to eigen sparse matrix More...
 
class  MatrixShell
 matrices that define its action against a vector More...
 
class  MatrixShellSparse
 Allow all sparse matrices to be shell matrices. More...
 
class  MatrixSparse
 
class  MatrixTriplet
 brief description More...
 
class  MatrixUBlas
 interface to ublas sparse matrix More...
 
class  MatrixValue
 interface to matrix More...
 
class  Mesh
 unifying mesh class More...
 
class  Mesh0D
 0D mesh class More...
 
class  Mesh1D
 1D mesh class More...
 
class  Mesh2D
 2D mesh class More...
 
class  Mesh3D
 3D mesh class More...
 
class  MeshBase
 base mesh class More...
 
class  MeshHighOrder
 
class  MeshMover
 Move mesh according to a given map. More...
 
class  MeshTraits
 Traits for meshes. More...
 
class  Mortar
 brief description More...
 
struct  node
 
class  NoPeriodicity
 NoPeriodicity class holder. More...
 
struct  Normalized
 
class  Operator
 Operator between function spaces. More...
 
class  OperatorInterpolation
 Global interpolation operator. More...
 
class  OperatorLagrangeP1
 
class  OperatorLinear
 Linear Operator between function spaces, represented by a matrix. More...
 
class  OperatorLinearFree
 Linear Operator Free between function spaces, represented by a matrix but this matrix is not automatically assembled. More...
 
class  OperatorLinearParametrized
 An interface for linear parametrized operators. More...
 
class  OperatorSteklovPc
 OperatorSteklovPc made easy. More...
 
class  OperatorTrace
 OperatorTrace made easy. More...
 
class  OpusApp
 Certified Reduced Basis application. More...
 
class  OpusAppEigs
 Opus application. More...
 
class  OrthogonalPolynomialSet
 a set of orthogonal polynomials over a convex More...
 
class  OseenDefaults
 Oseen Default Data. More...
 
class  Output
 output class to describe code outputs More...
 
class  Parameter
 parameter class to describe code inputs More...
 
class  ParameterSpace
 Parameter space class. More...
 
class  Partitioner
 
class  Periodic
 Periodic class holder. More...
 
class  PeriodicStokes
 
class  PFemApp
 Parametrized Finite Element Method Application. More...
 
class  POD
 POD class. More...
 
class  PointSet
 Class of all PointSet on a Convex. More...
 
class  PointSetFekete
 
class  PointSetInterpolation
 Good interpolation point sets on a convex. More...
 
class  PointSetQuadrature
 Quadrature point set base class. More...
 
class  PointSetToMesh
 transform a point set to a mesh data structure using a Delaunay More...
 
class  PolicyCreationUsingNew
 
class  PolicyFeelTimeDefault
 
class  Polynomial
 polynomial class More...
 
class  PolynomialSet
 a Set of polynomials More...
 
class  Preconditioner
 base class for preconditioner More...
 
class  PreconditionerPetsc
 Petsc preconditioner class. More...
 
class  Principal
 Principal modified functions. More...
 
class  problem
 Optimization problem specifications. More...
 
class  Projector
 Projection made easy. More...
 
class  PsLogger
 
struct  RankUp
 
class  Reference
 Reference convex. More...
 
struct  RegionMarker2
 
struct  RegionMarker3
 
struct  RegionMarkre
 
struct  RegionProcess
 
class  RegionTree
 implements a region-tree for point search in a set of boxes More...
 
class  ResistanceLaplacian
 
struct  Scalar
 
class  Simget
 Simulation Object. More...
 
class  Simplex
 simplex of dimension Dim More...
 
class  Singleton
 implement the Singleton pattern More...
 
class  SolverBase
 abstract base class for wrapped (linear) solvers More...
 
class  SolverConstrained
 
class  SolverEigen
 base class for eigen solvers More...
 
class  SolverLinear
 
class  SolverNonLinear
 Non linear solver base interface. More...
 
class  SolverUMFPACK
 Interface for the UMFPACK Solver. More...
 
class  SolverUnconstrained
 
class  Sound
 
class  Sphere
 
class  Stokes
 solves the stokes equations More...
 
struct  StorageUBlas
 
class  StructuredGrid
 class to represent a Structured Grid More...
 
class  SubMeshData
 data structure storing sub mesh data More...
 
class  Surface
 
class  SVD
 Singular Value Decomposition of a rectangular matrix. More...
 
class  System
 System of PDE associated to a function space. More...
 
class  SystemExplicit
 describes an explicit system More...
 
class  SystemImplicit
 describes an implicit system More...
 
class  SystemImplicitLinear
 brief description More...
 
class  SystemImplicitNonLinear
 Describes nonlinear implicit systems. More...
 
struct  Tensor2
 
struct  Tensor3
 
class  TensorisedBoundaryAdapted
 TensorisedBoundaryAdapted Basis on simplex products. More...
 
class  ThermalFin
 
class  TimerMap
 timers map More...
 
class  TimeSet
 data TimeSet More...
 
class  TypeInfo
 wrapper for std::type_info More...
 
class  Vector
 
class  VectorBlock
 block of vector More...
 
class  VectorEigen
 interface to vector More...
 
struct  Vectorial
 
class  VectorUblas
 interface to vector More...
 
class  VectorValue
 interface to vector More...
 
class  Visitor
 
class  VisitorBase
 The base class of any Acyclic Visitor. More...
 
class  VisitorBaseImpl
 Implements non-strict visitation (you can implement only part of the Visit functions) More...
 
class  VisitorCyclic
 

Typedefs

typedef boost::shared_ptr
< backend_type
backend_ptrtype
 
typedef Backend< double > backend_type
 
typedef bases< Lagrange
< 1, Scalar > > 
basisP1LS_type
 
typedef std::complex< double > complex_type
 
typedef
ublas::compressed_matrix
< double, ublas::column_major,
0, ublas::unbounded_array< int >
, ublas::unbounded_array
< double > > 
csc_matrix_type
 
typedef
ublas::compressed_matrix
< double, ublas::row_major,
0, ublas::unbounded_array< int >
, ublas::unbounded_array
< double > > 
csr_matrix_type
 
typedef boost::shared_ptr
< d_sparse_matrix_type
d_sparse_matrix_ptrtype
 
typedef MatrixSparse< double > d_sparse_matrix_type
 
typedef uint16_type dim_type
 dimension type
 
typedef int64_type flag_type
 
typedef ReinitializerFMS
< spaceP1LS_type, itRangeLS,
NoPeriodicity
fms_2d_periodic_type
 
typedef ReinitializerFMS
< spaceP1LS_type, itRangeLS,
Periodic<> > 
fms_2d_type
 
typedef ReinitializerFMS
< spaceP1LS_3d_type,
itRange_3d_LS, Periodic<> > 
fms_3d_periodic_type
 
typedef ReinitializerFMS
< spaceP1LS_3d_type,
itRange_3d_LS, NoPeriodicity
fms_3d_type
 
typedef parameter::parameters
< parameter::required
< tag::mesh_type,
boost::is_base_and_derived
< MeshBase, _ >
>, parameter::optional
< parameter::deduced
< tag::bases_list >
, boost::is_base_and_derived
< detail::bases_base, _ >
>, parameter::optional
< parameter::deduced
< tag::value_type >
, boost::is_floating_point< _ >
>, parameter::optional
< parameter::deduced
< tag::periodicity_type >
, boost::is_base_and_derived
< detail::periodicity_base, _ > >> 
functionspace_signature
 
typedef GeoEntity< Simplex< 0, 1 > > GeoPoint
 
typedef boost::shared_ptr
< gmsh_type
gmsh_ptrtype
 
typedef Gmsh gmsh_type
 
typedef
ublas::symmetric_matrix
< double, ublas::lower,
ublas::row_major,
ublas::bounded_array< double, 9 > > 
hessian_node_type
 
typedef boost::int16_t int16_type
 
typedef boost::int32_t int32_type
 
typedef boost::int64_t int64_type
 
typedef boost::int8_t int8_type
 
typedef boost::shared_ptr
< iteration_type
iteration_ptrtype
 
typedef Iteration< double > iteration_type
 
typedef ublas::matrix< double,
ublas::column_major,
ublas::bounded_array< double, 9 > > 
lapack_matrix_type
 
typedef GeoEntity< Hypercube< 3, 1 > > LinearHexa
 
typedef GeoEntity< Simplex< 1, 1 > > LinearLine
 
typedef GeoEntity< Hypercube< 2, 1 > > LinearQuad
 
typedef GeoEntity< Simplex< 3, 1 > > LinearTetra
 
typedef GeoEntity< Simplex< 2, 1 > > LinearTriangle
 
typedef DebugStream &(* LManipFunction )(DebugStream &)
 
typedef NdebugStream &(* LNManipFunction )(NdebugStream &)
 
typedef boost::shared_ptr
< Material
material_ptrtype
 
typedef Material material_type
 
typedef Singleton
< Feel::Factory< Material,
std::string > > 
MaterialFactory
 
typedef boost::shared_ptr
< mesh_3d_typeLS
mesh_3d_ptrtypeLS
 
typedef Mesh< Simplex< 3 > > mesh_3d_typeLS
 
typedef boost::shared_ptr
< mesh_typeLS
mesh_ptrtypeLS
 
typedef Mesh< Simplex< 2 > > mesh_typeLS
 
typedef node< double >::type node_type
 
typedef Geo0D< 3 > Point
 
typedef boost::shared_ptr
< Preconditioner< double > > 
preconditioner_ptrtype
 
typedef Preconditioner< double > preconditioner_type
 
typedef GeoEntity< Hypercube< 3, 2 > > QuadraticHexa
 
typedef GeoEntity< Simplex< 1, 2 > > QuadraticLine
 
typedef GeoEntity< Hypercube< 2, 2 > > QuadraticQuad
 
typedef GeoEntity< Simplex< 3, 2 > > QuadraticTetra
 
typedef GeoEntity< Simplex< 2, 2 > > QuadraticTriangle
 
typedef double Real
 
typedef detail::real< 32 >::type real32_type
 
typedef detail::real< 64 >::type real64_type
 
typedef boost::shared_ptr
< region_tree_type
region_tree_ptrtype
 
typedef RegionTree region_tree_type
 
typedef double scalar_type
 
typedef Singleton< Factory
< Simget, std::string > > 
SimgetFactory
 
typedef size_t size_type
 Indices (starting from 0)
 
typedef FunctionSpace
< mesh_3d_typeLS,
basisP1LS_type, Periodicity
< NoPeriodicity > > 
spaceP1LS_3d_type
 
typedef FunctionSpace
< mesh_typeLS, basisP1LS_type,
Periodicity< NoPeriodicity > > 
spaceP1LS_type
 
typedef boost::shared_ptr
< d_sparse_matrix_type
sparse_matrix_ptrtype
 
typedef Feel::Singleton
< StencilManagerImpl > 
StencilManager
 
typedef
ublas::symmetric_adaptor
< lapack_matrix_type,
ublas::lower > 
symmetric_matrix_type
 
typedef lapack_matrix_type transformation_matrix_type
 
typedef boost::uint16_t uint16_type
 
typedef boost::uint32_t uint32_type
 
typedef boost::uint64_t uint64_type
 
typedef boost::uint8_t uint8_type
 
typedef boost::shared_ptr
< vector_type
vector_ptrtype
 
typedef Vector< double > vector_type
 

Enumerations

enum  {
  lvl_info = google::GLOG_INFO,
  lvl_warn = google::GLOG_WARNING,
  lvl_debug = google::GLOG_INFO,
  lvl_error = google::GLOG_ERROR,
  lvl_fatal = google::GLOG_FATAL
}
 
enum  {
  INTERPOLATE_DIFFERENT_MESH =0,
  INTERPOLATE_SAME_MESH = 1
}
 
enum  {
  STEP_NEW = ( 1<<0 ),
  STEP_HAS_DATA = ( 1<<1 ),
  STEP_ON_DISK = ( 1<<2 ),
  STEP_IN_MEMORY = ( 1<<3 ),
  STEP_OVERWRITE = ( 1<<10 )
}
 
enum  {
  FUNCTIONAL = 0,
  EQUALITIES,
  INEQUALITIES
}
 
enum  AitkenType {
  AITKEN_STANDARD =0,
  AITKEN_METHOD_1 =1,
  FIXED_RELAXATION_METHOD =2
}
 
enum  BackendType {
  BACKEND_GMM = 0,
  BACKEND_PETSC,
  BACKEND_TRILINOS,
  BACKEND_EIGEN,
  BACKEND_EIGEN_DENSE
}
 
enum  BDFState {
  BDF_UNITIALIZED = 0,
  BDF_RUNNING,
  BDF_STOPPED
}
 
enum  BDFStragegy {
  BDF_STRATEGY_DT_CONSTANT,
  BDF_STRATEGY_DT_ADAPTATIVE
}
 
enum  BDFTimeScheme {
  BDF_ORDER_ONE =1,
  BDF_ORDER_TWO,
  BDF_ORDER_THREE,
  BDF_ORDER_FOUR,
  BDF_MAX_ORDER = 4,
  BDF_ORDER_ONE =1,
  BDF_ORDER_TWO,
  BDF_ORDER_THREE,
  BDF_ORDER_FOUR,
  BDF_MAX_ORDER = 4
}
 
enum  BDFTimeScheme {
  BDF_ORDER_ONE =1,
  BDF_ORDER_TWO,
  BDF_ORDER_THREE,
  BDF_ORDER_FOUR,
  BDF_MAX_ORDER = 4,
  BDF_ORDER_ONE =1,
  BDF_ORDER_TWO,
  BDF_ORDER_THREE,
  BDF_ORDER_FOUR,
  BDF_MAX_ORDER = 4
}
 
enum  BFGSType {
  BFGS = 0,
  DFP
}
 
enum  ComponentType {
  NO_COMPONENT = -1,
  X = 0,
  Y,
  Z,
  NX,
  NY,
  NZ,
  TX,
  TY,
  TZ
}
 
enum  CRBErrorType {
  CRB_RESIDUAL = 0,
  CRB_RESIDUAL_SCM =1,
  CRB_NO_RESIDUAL =2,
  CRB_EMPIRICAL =3
}
 
enum  CRBModelMode {
  PFEM = 0,
  SCM = 1,
  CRB = 2,
  SCM_ONLINE =3,
  CRB_ONLINE =4
}
 
enum  DebugLevels {
  DEBUG_INFO = 0,
  DEBUG_WARN = 1,
  DEBUG_ERROR = 2,
  DEBUG_FATAL = 3
}
 Area debugging tool. More...
 
enum  DirichletType {
  STRONG =0,
  WEAK =1
}
 
enum  EigenProblemType {
  NHEP =0,
  HEP,
  GNHEP,
  GHEP,
  PGNHEP,
  INVALID_EIGENPROBLEMTYPE
}
 
enum  EigenSolverType {
  POWER =0,
  LAPACK,
  SUBSPACE,
  ARNOLDI,
  LANCZOS,
  KRYLOVSCHUR,
  ARPACK,
  INVALID_EIGENSOLVER
}
 
enum  ElementsType {
  MESH_ELEMENTS = 0,
  MESH_FACES = 1,
  MESH_INTERNAL_FACES = 2,
  MESH_EDGES = 3,
  MESH_INTERNAL_EDGES = 4,
  MESH_POINTS = 5
}
 
enum  EnumIndex {
  GLOBAL_COMPONENT,
  COMPONENT_IN_COMPONENT,
  GLOBAL_FUNCTION_INDEX,
  PER_COMPONENT_FUNCTION_INDEX,
  COMPONENT_IN_COMPONENT_FUNCTION_INDEX,
  FUNCTION_INDEX
}
 
enum  ExporterGeometry {
  EXPORTER_GEOMETRY_STATIC = 0,
  EXPORTER_GEOMETRY_CHANGE_COORDS_ONLY = 1,
  EXPORTER_GEOMETRY_CHANGE = 2
}
 
enum  FaceLocation {
  INTERNAL = false,
  ON_BOUNDARY = true
}
 
enum  FieldSplitType {
  ADDITIVE =0,
  MULTIPLICATIVE,
  SCHUR
}
 
enum  file_type {
  ASCII = 0,
  BINARY = 1
}
 
enum  FunctionSpaceType {
  SCALAR = 0,
  VECTORIAL = 1
}
 
enum  GeoEntityContext {
  MESH_ENTITY_INTERNAL = ( 1<<0 ),
  MESH_ENTITY_BOUNDARY = ( 1<<1 )
}
 
enum  GeomapStrategyType {
  GEOMAP_OPT = 0,
  GEOMAP_O1 = 1,
  GEOMAP_HO = 2
}
 
enum  GMSH_ENTITY {
  GMSH_LINE = 1,
  GMSH_TRIANGLE = 2,
  GMSH_QUADRANGLE = 3,
  GMSH_TETRAHEDRON = 4,
  GMSH_HEXAHEDRON = 5,
  GMSH_PRISM = 6,
  GMSH_PYRAMID = 7,
  GMSH_LINE_2 = 8,
  GMSH_TRIANGLE_2 = 9,
  GMSH_QUADRANGLE_2 = 10,
  GMSH_TETRAHEDRON_2 = 11,
  GMSH_HEXAHEDRON_2 = 12,
  GMSH_PRISM_2 = 13,
  GMSH_PYRAMID_2 = 14,
  GMSH_POINT = 15,
  GMSH_TRIANGLE_INCOMPLETE_3 =20,
  GMSH_TRIANGLE_3 =21,
  GMSH_TRIANGLE_INCOMPLETE_4 =22,
  GMSH_TRIANGLE_4 =23,
  GMSH_TRIANGLE_INCOMPLETE_5 =24,
  GMSH_TRIANGLE_5 =25,
  GMSH_LINE_3 =26,
  GMSH_LINE_4 =27,
  GMSH_LINE_5 =28,
  GMSH_TETRAHEDRON_3 =29,
  GMSH_TETRAHEDRON_4 =30,
  GMSH_TETRAHEDRON_5 =31
}
 
enum  GMSH_FORMAT {
  GMSH_FORMAT_ASCII = 0,
  GMSH_FORMAT_BINARY = 1
}
 
enum  GMSH_ORDER {
  GMSH_ORDER_ONE = 1,
  GMSH_ORDER_TWO = 2,
  GMSH_ORDER_THREE = 3,
  GMSH_ORDER_FOUR = 4,
  GMSH_ORDER_FIVE = 5
}
 
enum  GMSH_PARTITIONER {
  GMSH_PARTITIONER_CHACO = 1,
  GMSH_PARTITIONER_METIS = 2
}
 
enum  IntegrationFaceEnum {
  ALL_FACES = -1,
  FACE_0 = 0,
  FACE_1 = 1,
  FACE_2,
  FACE_3,
  FACE_4,
  FACE_5,
  FACE_6,
  FACE_7,
  FACE_8
}
 
enum  MatrixProperties {
  HERMITIAN = 0x1,
  NON_HERMITIAN = 0x2,
  POSITIVE_DEFINITE = 0x4,
  SINGULAR = 0x8,
  DENSE = 0x10
}
 
enum  MatrixStructure {
  SAME_NONZERO_PATTERN,
  DIFFERENT_NONZERO_PATTERN,
  SAME_PRECONDITIONER,
  SUBSET_NONZERO_PATTERN,
  INVALID_STRUCTURE
}
 
enum  MatSolverPackageType {
  MATSOLVER_SPOOLES =0,
  MATSOLVER_SUPERLU,
  MATSOLVER_SUPERLU_DIST,
  MATSOLVER_UMFPACK,
  MATSOLVER_ESSL,
  MATSOLVER_LUSOL,
  MATSOLVER_MUMPS,
  MATSOLVER_PASTIX,
  MATSOLVER_DSCPACK,
  MATSOLVER_MATLAB,
  MATSOLVER_PETSC,
  MATSOLVER_PLAPACK,
  MATSOLVER_BAS
}
 
enum  MESH_CHANGES {
  MESH_CHANGES_POINTS_COORDINATES = 0,
  MESH_CHANGES_CONNECTIVITY = 1,
  MESH_CHANGES_PARTITION = 2
}
 
enum  MeshComponents {
  MESH_UPDATE_EDGES = ( 1 << 0 ),
  MESH_UPDATE_FACES = ( 1 << 1 ),
  MESH_CHECK = ( 1 << 2 ),
  MESH_PARTITION = ( 1 << 3 ),
  MESH_RENUMBER = ( 1 << 4 ),
  MESH_ADD_ELEMENTS_INFO = ( 1 << 5 ),
  MESH_PROPAGATE_MARKERS = ( 1 << 6 ),
  MESH_REMOVE_PERIODIC_FACES_FROM_BOUNDARY = ( 1 << 7 )
}
 
enum  MeshFormat {
  MESHPP,
  INRIA,
  GMSH,
  NETGEN,
  GAMBIT
}
 
enum  on_context_type {
  ON_NONE = 0x0,
  ON_ELIMINATION = 0x1,
  ON_PENALISATION = 0x2,
  ON_ELIMINATION_KEEP_DIAGONAL = 0x4,
  ON_ELIMINATION_SYMMETRIC = 0x8
}
 
enum  Pattern {
  DEFAULT = 1 << 0,
  EXTENDED = 1 << 1,
  COUPLED = 1 << 2,
  SYMMETRIC = 1 << 3,
  ZERO = 1 << 4,
  HAS_NO_BLOCK_PATTERN = 1 << 5
}
 
enum  PositionOfSpectrum {
  LARGEST_MAGNITUDE =0,
  SMALLEST_MAGNITUDE,
  LARGEST_REAL,
  SMALLEST_REAL,
  LARGEST_IMAGINARY,
  SMALLEST_IMAGINARY,
  INVALID_Postion_of_Spectrum
}
 
enum  PreconditionerType {
  IDENTITY_PRECOND =0,
  JACOBI_PRECOND,
  BLOCK_JACOBI_PRECOND,
  SOR_PRECOND,
  SSOR_PRECOND,
  EISENSTAT_PRECOND,
  ASM_PRECOND,
  GASM_PRECOND,
  CHOLESKY_PRECOND,
  ICC_PRECOND,
  ILU_PRECOND,
  LU_PRECOND,
  AMG_PRECOND,
  USER_PRECOND,
  SHELL_PRECOND,
  FIELDSPLIT_PRECOND,
  ML_PRECOND,
  INVALID_PRECONDITIONER
}
 
enum  ProjectorType {
  NODAL =-1,
  L2 =0,
  H1 =1,
  DIFF =2,
  HDIV =3,
  HCURL =4,
  LIFT =5,
  CIP =6
}
 
enum  ReferenceGeometry {
  GEOMETRY_POINT = ( 1<<0 ),
  GEOMETRY_LINE = ( 1<<1 ),
  GEOMETRY_SURFACE = ( 1<<2 ),
  GEOMETRY_VOLUME = ( 1<<3 ),
  GEOMETRY_4 = ( 1<<4 ),
  GEOMETRY_5 = ( 1<<5 )
}
 
enum  ReferenceShapes {
  SHAPE_LINEAR = ( 1<<0 ),
  SHAPE_BILINEAR = ( 1<<1 ),
  SHAPE_QUADRATIC = ( 1<<2 ),
  SHAPE_NONE = ( 1<<3 ),
  SHAPE_POINT = ( 1<<4 ),
  SHAPE_LINE = ( 1<<5 ),
  SHAPE_TRIANGLE = ( 1<<6 ),
  SHAPE_QUAD = ( 1<<7 ),
  SHAPE_HEXA = ( 1<<8 ),
  SHAPE_PRISM = ( 1<<9 ),
  SHAPE_TETRA = ( 1<<10 ),
  SHAPE_SP4 = ( 1<<11 ),
  SHAPE_SP5 = ( 1<<12 )
}
 
enum  SamplingMode {
  RANDOM = 0,
  EQUIDISTRIBUTED = 1,
  LOGEQUIDISTRIBUTED = 2
}
 
enum  Shape {
  LINE = 1,
  TRIANGLE = 2,
  TETRAHEDRON = 3
}
 
enum  SolverNonLinearType {
  SELECT_IN_ARGLIST =0,
  LINE_SEARCH,
  TRUST_REGION
}
 
enum  SolverPackage {
  SOLVERS_FEEL =0,
  SOLVERS_GMM,
  SOLVERS_EIGEN,
  SOLVERS_PETSC,
  SOLVERS_TRILINOS,
  SOLVERS_SLEPC,
  SOLVER_INVALID_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  SpectralTransformType {
  SHIFT =0,
  SINVERT,
  FOLD,
  CAYLEY
}
 
enum  StabilizationMethods {
  NO,
  CIP =6,
  SGS,
  SUPG,
  GALS
}
 

Functions

std::string _o (std::string const &prefix, std::string const &opt)
 
template<class T >
Abs (const T &a)
 
template<class Expr >
ADExpr< AdFuncAbs< ADExpr
< Expr > > > 
abs (const ADExpr< Expr > &expr)
 
template<class T , int Nvar, int Order, int Var>
ADExpr< AdFuncAbs< ADType< T,
Nvar, Order, Var > > > 
abs (const ADType< T, Nvar, Order, Var > &x)
 
template<typename SpaceType >
boost::shared_ptr< Aitken
< SpaceType > > 
aitkenNew (boost::shared_ptr< SpaceType > const &_space, AitkenType _type, double _init_theta, double _tol, double _minParam)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::element_const_iterator,
typename MeshTraits< MeshType >
::element_const_iterator > 
allelements (MeshType const &mesh)
 
FEELPP_NO_EXPORT std::pair
< std::string, std::string > 
at_option_parser (std::string const &s)
 
po::options_description backend_options (std::string const &prefix)
 
po::options_description backendeigen_options (std::string const &prefix)
 
po::options_description backendpetsc_options (std::string const &prefix)
 
std::string backtrace ()
 
std::string backtrace (int)
 
po::options_description bdf_options (std::string const &prefix)
 
po::options_description benchmark_options (std::string const &prefix="")
 add benchmark options to feel++ applications
 
template<typename FUNCTION , typename DERIVATIVE , typename VECTOR , typename IterationBFGS >
void bfgs (FUNCTION f, DERIVATIVE grad, VECTOR &x, int restart, IterationBFGS &iter, BFGSType version=BFGS, float lambda_init=0.001, float=1.0)
 
 BOOST_STATIC_ASSERT ((boost::is_same< real32_type, float >::value))
 
 BOOST_STATIC_ASSERT ((boost::is_same< real64_type, double >::value))
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_EDGES >, typename
MeshTraits< MeshType >
::location_edge_const_iterator,
typename MeshTraits< MeshType >
::location_edge_const_iterator > 
boundaryedges (MeshType const &mesh)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::location_element_const_iterator,
typename MeshTraits< MeshType >
::location_element_const_iterator > 
boundaryelements (MeshType const &mesh, uint16_type entity_min_dim=0, uint16_type entity_max_dim=2)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::location_face_const_iterator,
typename MeshTraits< MeshType >
::location_face_const_iterator > 
boundaryfaces (MeshType const &mesh)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_POINTS >, typename
MeshTraits< MeshType >
::location_point_const_iterator,
typename MeshTraits< MeshType >
::location_point_const_iterator > 
boundarypoints (MeshType const &mesh)
 
FEELPP_NO_EXPORT
RegionTree::element_base * 
build (RegionTree::pbox_container_type &b, const node_type &bmin, const node_type &bmax, size_type last_dir)
 
void configurePC (PC &pc, WorldComm const &worldComm, std::string sub="", std::string prefix="")
 
template<class Expr >
ADExpr< ADFuncCos< ADExpr
< Expr > > > 
cos (const ADExpr< Expr > &expr)
 
template<class T , int Nvar, int Order, int Var>
ADExpr< ADFuncCos< ADType< T,
Nvar, Order, Var > > > 
cos (const ADType< T, Nvar, Order, Var > &x)
 
Feel::po::options_description crbOptions (std::string const &prefix)
 
Feel::po::options_description crbSCMOptions (std::string const &prefix)
 
boost::shared_ptr< Mesh
< Simplex< 2 > > > 
createMeshLaplacianBlock ()
 
boost::shared_ptr< Mesh
< Simplex< 2 > > > 
createMeshLaplacianLM ()
 
gmsh_ptrtype createRing (int Dim, int Order, double meshSize, std::string const &convex)
 
gmsh_ptrtype createRoom (int Dim, double meshSize)
 
template<typename MeshType , typename IteratorRange , int TheTag = MeshType::tag>
createSubmeshTool< MeshType,
typename
detail::submeshrangetype
< IteratorRange >::type,
TheTag >::mesh_build_ptrtype 
createSubmesh (boost::shared_ptr< MeshType > inputMesh, IteratorRange const &range, size_type ctx=EXTRACTION_KEEP_MESH_RELATION)
 
boost::shared_ptr< Mesh
< Simplex< 2 > > > 
createSubMeshLaplacianBlock (boost::shared_ptr< Mesh< Simplex< 2 > > > mesh)
 
template<typename E1 , typename E2 >
ublas::vector< double > cross (ublas::vector_expression< E1 > _p1, ublas::vector_expression< E2 > _p2)
 
template<typename T >
ublas::vector< double > cross (Geo0D< 3, T > p1, Geo0D< 3, T > p2)
 
template<typename Poly >
Polynomial< Poly, Vectorialcurl (Polynomial< Poly, Vectorial > const &p)
 compute the curl of a vectorial polynomial p More...
 
template<typename Poly >
PolynomialSet< Poly, Vectorialcurl (PolynomialSet< Poly, Vectorial > const &p)
 compute the curl of a vectorial polynomial set p More...
 
template<typename Poly >
Polynomial< Poly, Vectorialcurlt (Polynomial< Poly, Vectorial > const &p)
 compute the transpose of the curl of a vectorial polynomial p More...
 
template<typename Poly >
PolynomialSet< Poly, Vectorialcurlt (PolynomialSet< Poly, Vectorial > const &p)
 compute the transpose of the curl of a vectorial polynomial p More...
 
gmsh_ptrtype ddmethodGeometryLeft (int RDim, double hsize)
 
gmsh_ptrtype ddmethodGeometryRight (int RDim, double hsize)
 
DebugStream Debug (int area, DebugStream::stprintf func)
 
DebugStream Debug (bool cond, int area, DebugStream::stprintf)
 
BlocksStencilPattern default_block_pattern (1, 1, size_type(Pattern::HAS_NO_BLOCK_PATTERN))
 
FEELPP_NO_EXPORT void destroy (RegionTree::element_base *n)
 
template<int Dim, typename Matrix >
Matrix::value_type det (Matrix const &M)
 
template<typename FUNCTION , typename DERIVATIVE , typename VECTOR , typename IterationBFGS >
void dfp (FUNCTION f, DERIVATIVE grad, VECTOR &x, int restart, IterationBFGS &iter, BFGSType version=DFP)
 
template<typename T >
distance (Geo0D< 1, T > const &p1, Geo0D< 1, T > const &p2)
 
template<typename T >
distance (Geo0D< 2, T > const &p1, Geo0D< 2, T > const &p2)
 
template<typename T >
distance (Geo0D< 3, T > const &p1, Geo0D< 3, T > const &p2)
 
template<typename Poly >
Polynomial< Poly, Scalardivergence (Polynomial< Poly, Vectorial > const &p)
 compute the divergence of a vectorial polynomial p More...
 
template<typename Poly >
PolynomialSet< Poly, Scalardivergence (PolynomialSet< Poly, Vectorial > const &p)
 compute the divergence of a vectorial polynomial set p More...
 
template<typename T >
type_traits< T >::real_type dot (boost::shared_ptr< Vector< T > > const &v1, boost::shared_ptr< Vector< T > > const &v2)
 
template<typename T >
type_traits< T >::real_type dot (Vector< T > const &v1, Vector< T > const &v2)
 
FEELPP_NO_EXPORT void dump (RegionTree::element_base *p, int level, size_type &count)
 
template<typename Poly , template< uint16_type > class Type>
Polynomial< Poly, Type > dx (Polynomial< Poly, Type > const &p)
 compute $\frac{\partial \cdot}{\partial x}$ of a polynomial p More...
 
template<typename Poly , template< uint16_type > class Type>
PolynomialSet< Poly, Type > dx (PolynomialSet< Poly, Type > const &p)
 compute $\frac{\partial \cdot}{\partial x}$ of a polynomial set p More...
 
template<typename Poly , template< uint16_type > class Type>
Polynomial< Poly, Type > dy (Polynomial< Poly, Type > const &p)
 compute $\frac{\partial \cdot}{\partial y}$ of a polynomial p More...
 
template<typename Poly , template< uint16_type > class Type>
PolynomialSet< Poly, Type > dy (PolynomialSet< Poly, Type > const &p)
 compute $\frac{\partial \cdot}{\partial y}$ of a polynomial set p More...
 
template<typename Poly , template< uint16_type > class Type>
Polynomial< Poly, Type > dz (Polynomial< Poly, Type > const &p)
 compute $\frac{\partial \cdot}{\partial z}$ of a polynomial p More...
 
template<typename Poly , template< uint16_type > class Type>
PolynomialSet< Poly, Type > dz (PolynomialSet< Poly, Type > const &p)
 compute $\frac{\partial \cdot}{\partial z}$ of a polynomial set p More...
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_EDGES >, typename
MeshTraits< MeshType >
::pid_edge_const_iterator,
typename MeshTraits< MeshType >
::pid_edge_const_iterator > 
edges (MeshType const &mesh)
 
template<typename ModelType >
boost::shared_ptr
< EimFunctionNoSolve
< ModelType > > 
eim_no_solve (boost::shared_ptr< ModelType > model)
 
Feel::po::options_description eimOptions (std::string const &prefix)
 
template<typename ElementType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
std::list< ElementType >
::const_iterator, typename
std::list< ElementType >
::const_iterator > 
element (ElementType const &elt)
 
template<typename ElementType >
ElementType element_div (ElementType const &v1, ElementType const &v2)
 
template<typename T >
VectorEigen< T > element_product (VectorEigen< T > const &v1, VectorEigen< T > const &v2)
 
template<typename T >
VectorEigen< T > element_product (boost::shared_ptr< VectorEigen< T > > const &v1, boost::shared_ptr< VectorEigen< T > > const &v2)
 
template<typename T >
VectorUblas< T > element_product (VectorUblas< T > const &v1, VectorUblas< T > const &v2)
 
template<typename T >
VectorUblas< T > element_product (boost::shared_ptr< VectorUblas< T > > const &v1, boost::shared_ptr< VectorUblas< T > > const &v2)
 
template<typename ElementType >
ElementType element_product (ElementType const &v1, ElementType const &v2)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::element_const_iterator,
typename MeshTraits< MeshType >
::element_const_iterator > 
elements (MeshType const &mesh)
 
NdebugStream & endl (NdebugStream &s)
 
DebugStream Error (int area)
 
DebugStream Error (bool cond, int area)
 
po::options_description error_options (std::string const &prefix)
 
template<class T >
void Exchange (T &a, T &b)
 
template<class Expr >
ADExpr< AdFuncExp< ADExpr
< Expr > > > 
exp (const ADExpr< Expr > &expr)
 
template<class T , int Nvar, int Order, int Var>
ADExpr< AdFuncExp< ADType< T,
Nvar, Order, Var > > > 
exp (const ADType< T, Nvar, Order, Var > &x)
 
template<typename ElementType , typename CoeffType >
ElementType expansion (std::vector< ElementType > const &b, CoeffType const &c, int M=-1)
 
po::options_description exporter_options (std::string const &prefix)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::pid_face_const_iterator,
typename MeshTraits< MeshType >
::pid_face_const_iterator > 
faces (MeshType const &mesh)
 
DebugStream Fatal (int area)
 
DebugStream Fatal (bool cond, int area)
 
po::options_description feel_options (std::string const &prefix)
 
po::options_description file_options (std::string const &appname)
 
NdebugStream & flush (NdebugStream &s)
 
template<typename FunctionSpaceType , typename IteratorRange , typename periodicity_type = NoPeriodicity>
boost::shared_ptr
< ReinitializerFMS
< FunctionSpaceType,
IteratorRange,
periodicity_type > > 
fms (boost::shared_ptr< FunctionSpaceType > const &Xh, IteratorRange r, periodicity_type p=NoPeriodicity())
 
 for (int q=1;q< Qa();++q)
 
template<typename X1 , typename X2 >
vf::detail::BilinearForm< X1, X2 > form (boost::shared_ptr< X1 > const &__X1, boost::shared_ptr< X2 > const &__X2, boost::shared_ptr< MatrixSparse< double > > __M, size_type rowstart=0, size_type colstart=0, bool init=false, bool do_threshold=false, typename X1::value_type threshold=type_traits< double >::epsilon(), size_type pattern=Pattern::COUPLED)
 
template<typename X1 , typename RepType >
vf::detail::LinearForm< X1,
RepType, RepType > 
form (boost::shared_ptr< X1 > const &__X1, boost::shared_ptr< RepType > __M, size_type rowstart=0, bool init=false, bool do_threshold=false, typename X1::value_type threshold=type_traits< typename RepType::value_type >::epsilon())
 
po::options_description functions_options (std::string const &prefix)
 
po::options_description generic_options ()
 
template<typename BareItem >
size_type getId (std::pair< BareItem, size_type > const &i)
 
template<typename BareItem >
BareItem getItem (std::pair< BareItem, size_type > const &i)
 
po::options_description ginac_options (std::string const &prefix)
 
po::options_description gmsh_domain_options (std::string const &prefix)
 
po::options_description gmsh_options (std::string const &prefix)
 
template<typename Poly >
Polynomial< Poly, Vectorialgradient (Polynomial< Poly, Scalar > const &p)
 compute the gradient of a scalar polynomial p More...
 
template<typename Poly >
Polynomial< Poly, Tensor2gradient (Polynomial< Poly, Vectorial > const &p)
 compute the gradient of a vectorial polynomial p More...
 
template<typename Poly >
PolynomialSet< Poly, Vectorialgradient (PolynomialSet< Poly, Scalar > const &p)
 compute the gradient of a scalar polynomial set More...
 
template<typename Poly >
PolynomialSet< Poly, Tensor2gradient (PolynomialSet< Poly, Vectorial > const &p)
 compute the gradient of a vectorial polynomial set More...
 
template<typename Poly >
PolynomialSet< Poly, Tensor2hessian (PolynomialSet< Poly, Scalar > const &p)
 compute the gradient of a vectorial polynomial set More...
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::element_const_iterator,
typename MeshTraits< MeshType >
::element_const_iterator > 
idedelements (MeshType const &mesh, flag_type flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::face_const_iterator,
typename MeshTraits< MeshType >
::face_const_iterator > 
idedfaces (MeshType const &mesh, size_type id)
 
template<typename T >
type_traits< T >::real_type inner_product (Vector< T > const &v1, Vector< T > const &v2)
 
template<typename T >
type_traits< T >::real_type inner_product (boost::shared_ptr< Vector< T > > const &v1, boost::shared_ptr< Vector< T > > const &v2)
 
template<typename Poly , template< uint16_type > class PsetType>
Poly::value_type integrate (Polynomial< Poly, PsetType > const &p)
 integrate a polynomial over a convex More...
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_EDGES >, typename
MeshTraits< MeshType >
::location_edge_const_iterator,
typename MeshTraits< MeshType >
::location_edge_const_iterator > 
internaledges (MeshType const &mesh)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::location_element_const_iterator,
typename MeshTraits< MeshType >
::location_element_const_iterator > 
internalelements (MeshType const &mesh)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::location_face_const_iterator,
typename MeshTraits< MeshType >
::location_face_const_iterator > 
internalfaces (MeshType const &mesh)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_POINTS >, typename
MeshTraits< MeshType >
::location_point_const_iterator,
typename MeshTraits< MeshType >
::location_point_const_iterator > 
internalpoints (MeshType const &mesh)
 
template<typename SpaceType , typename FunctionType >
void interpolate (boost::shared_ptr< SpaceType > const &space, FunctionType const &f, typename SpaceType::element_type &interp, int same_mesh=INTERPOLATE_DIFFERENT_MESH)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::interprocess_face_const_iterator,
typename MeshTraits< MeshType >
::interprocess_face_const_iterator > 
interprocessfaces (MeshType const &mesh)
 
template<int Dim, typename Matrix >
void inverse (Matrix const &M, Matrix &Minv)
 
template<int Dim, typename Matrix >
void inverse (Matrix const &__restrict__ M, Matrix &__restrict__ Minv, typename Matrix::value_type const &J)
 
template<uint16_type N, typename T >
void JacobiBatchDerivation (ublas::matrix< T > &res, T a, T b, ublas::vector< T > const &__pts, mpl::bool_< true >)
 
template<uint16_type N, typename T >
void JacobiBatchDerivation (ublas::matrix< T > &, T, T, ublas::vector< T > const &, mpl::bool_< false >)
 
template<uint16_type N, typename T >
ublas::matrix< T > JacobiBatchDerivation (T a, T b, ublas::vector< T > const &__pts)
 
template<uint16_type N, typename T >
ublas::matrix< T > JacobiBatchEvaluation (T a, T b, ublas::vector< T > const &__pts)
 
template<class Convex , uint16_type Order, template< class, uint16_type, class > class PointSetType, typename value_type >
value_type lebesgueConstant ()
 
DebugStream Log (int area, DebugStream::stprintf func)
 
DebugStream Log (bool cond, int area, DebugStream::stprintf)
 
template<class Expr >
ADExpr< AdFuncLog< ADExpr
< Expr > > > 
log (const ADExpr< Expr > &expr)
 
template<class T , int Nvar, int Order, int Var>
ADExpr< AdFuncLog< ADType< T,
Nvar, Order, Var > > > 
log (const ADType< T, Nvar, Order, Var > &x)
 
template<class Expr >
ADExpr< AdFuncLog10< ADExpr
< Expr > > > 
log10 (const ADExpr< Expr > &expr)
 
template<class T , int Nvar, int Order, int Var>
ADExpr< AdFuncLog10< ADType< T,
Nvar, Order, Var > > > 
log10 (const ADType< T, Nvar, Order, Var > &x)
 
AboutData makeAbout ()
 Create the About data of the OpusApp.
 
std::pair< BareEdge, bool > makeBareEdge (size_type const i, size_type const j)
 It creates a BareEdge end returns the orientation of the created edge with respect to the given data. More...
 
std::pair< BareFace, bool > makeBareFace (size_type const i, size_type const j, size_type const k)
 It creates Bare Face objects from three Point size_type's. More...
 
std::pair< BareFace, bool > makeBareFace (size_type const i, size_type const j, size_type const k, size_type const l)
 It creates Bare Face objects from four Point size_type's. More...
 
std::pair< BareEdge, bool > makeBareItem (size_type i, size_type j)
 
std::pair< BareFace, bool > makeBareItem (size_type i, size_type j, size_type k)
 
std::pair< BareFace, bool > makeBareItem (size_type i, size_type j, size_type k, size_type l)
 
std::pair< BarePoint, bool > makeBarePoint (size_type const i)
 
po::options_description makeOptions ()
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::marker2_element_const_iterator,
typename MeshTraits< MeshType >
::marker2_element_const_iterator > 
marked2elements (MeshType const &mesh, flag_type flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::marker2_element_const_iterator,
typename MeshTraits< MeshType >
::marker2_element_const_iterator > 
marked2elements (MeshType const &mesh, std::string const &flag)
 
template<typename MeshType >
std::list< boost::tuple
< mpl::size_t< MESH_ELEMENTS >
, typename MeshTraits
< MeshType >
::marker2_element_const_iterator,
typename MeshTraits< MeshType >
::marker2_element_const_iterator > > 
marked2elements (MeshType const &mesh, std::initializer_list< boost::any > const &flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::marker2_face_const_iterator,
typename MeshTraits< MeshType >
::marker2_face_const_iterator > 
marked2faces (MeshType const &mesh, flag_type __marker)
 
template<typename MeshType >
std::list< boost::tuple
< mpl::size_t< MESH_FACES >
, typename MeshTraits
< MeshType >
::marker2_face_const_iterator,
typename MeshTraits< MeshType >
::marker2_face_const_iterator > > 
marked2faces (MeshType const &mesh, std::initializer_list< boost::any > __markers)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::marker2_face_const_iterator,
typename MeshTraits< MeshType >
::marker2_face_const_iterator > 
marked2faces (MeshType const &mesh, std::string const &__marker)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::marker3_element_const_iterator,
typename MeshTraits< MeshType >
::marker3_element_const_iterator > 
marked3elements (MeshType const &mesh, flag_type flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::marker3_element_const_iterator,
typename MeshTraits< MeshType >
::marker3_element_const_iterator > 
marked3elements (MeshType const &mesh, std::string const &flag)
 
template<typename MeshType >
std::list< boost::tuple
< mpl::size_t< MESH_ELEMENTS >
, typename MeshTraits
< MeshType >
::marker3_element_const_iterator,
typename MeshTraits< MeshType >
::marker3_element_const_iterator > > 
marked3elements (MeshType const &mesh, std::initializer_list< boost::any > const &flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::marker3_face_const_iterator,
typename MeshTraits< MeshType >
::marker3_face_const_iterator > 
marked3faces (MeshType const &mesh, flag_type __marker)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::marker3_face_const_iterator,
typename MeshTraits< MeshType >
::marker3_face_const_iterator > 
marked3faces (MeshType const &mesh, std::string const &__marker)
 
template<typename MeshType >
std::list< boost::tuple
< mpl::size_t< MESH_FACES >
, typename MeshTraits
< MeshType >
::marker3_face_const_iterator,
typename MeshTraits< MeshType >
::marker3_face_const_iterator > > 
marked3faces (MeshType const &mesh, std::initializer_list< boost::any > __markers)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_EDGES >, typename
MeshTraits< MeshType >
::marker_edge_const_iterator,
typename MeshTraits< MeshType >
::marker_edge_const_iterator > 
markededges (MeshType const &mesh, flag_type __marker)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_EDGES >, typename
MeshTraits< MeshType >
::marker_edge_const_iterator,
typename MeshTraits< MeshType >
::marker_edge_const_iterator > 
markededges (MeshType const &mesh, std::string const &__marker)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::marker_element_const_iterator,
typename MeshTraits< MeshType >
::marker_element_const_iterator > 
markedelements (MeshType const &mesh, std::string const &flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::marker_element_const_iterator,
typename MeshTraits< MeshType >
::marker_element_const_iterator > 
markedelements (MeshType const &mesh, const char *flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_ELEMENTS >, typename
MeshTraits< MeshType >
::marker_element_const_iterator,
typename MeshTraits< MeshType >
::marker_element_const_iterator > 
markedelements (MeshType const &mesh, boost::any const &flag)
 
template<typename MeshType >
std::list< boost::tuple
< mpl::size_t< MESH_ELEMENTS >
, typename MeshTraits
< MeshType >
::marker_element_const_iterator,
typename MeshTraits< MeshType >
::marker_element_const_iterator > > 
markedelements (MeshType const &mesh, std::initializer_list< boost::any > const &flag)
 
template<typename MeshType >
std::list< boost::tuple
< mpl::size_t< MESH_ELEMENTS >
, typename MeshTraits
< MeshType >
::marker_element_const_iterator,
typename MeshTraits< MeshType >
::marker_element_const_iterator > > 
markedelements (MeshType const &mesh, std::list< std::string > const &flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::marker_face_const_iterator,
typename MeshTraits< MeshType >
::marker_face_const_iterator > 
markedfaces (MeshType const &mesh)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::marker_face_const_iterator,
typename MeshTraits< MeshType >
::marker_face_const_iterator > 
markedfaces (MeshType const &mesh, std::string const &__marker)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::marker_face_const_iterator,
typename MeshTraits< MeshType >
::marker_face_const_iterator > 
markedfaces (MeshType const &mesh, const char *__marker)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_FACES >, typename
MeshTraits< MeshType >
::marker_face_const_iterator,
typename MeshTraits< MeshType >
::marker_face_const_iterator > 
markedfaces (MeshType const &mesh, boost::any const &__marker)
 
template<typename MeshType >
std::list< boost::tuple
< mpl::size_t< MESH_FACES >
, typename MeshTraits
< MeshType >
::marker_face_const_iterator,
typename MeshTraits< MeshType >
::marker_face_const_iterator > > 
markedfaces (MeshType const &mesh, std::initializer_list< boost::any > __markers)
 
template<typename MeshType >
std::list< boost::tuple
< mpl::size_t< MESH_FACES >
, typename MeshTraits
< MeshType >
::marker_face_const_iterator,
typename MeshTraits< MeshType >
::marker_face_const_iterator > > 
markedfaces (MeshType const &mesh, std::list< std::string > __markers)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_POINTS >, typename
MeshTraits< MeshType >
::marker_point_const_iterator,
typename MeshTraits< MeshType >
::marker_point_const_iterator > 
markedpoints (MeshType const &mesh, size_type flag)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_POINTS >, typename
MeshTraits< MeshType >
::marker_point_const_iterator,
typename MeshTraits< MeshType >
::marker_point_const_iterator > 
markedpoints (MeshType const &mesh, std::string const &flag)
 
std::vector< MeshMarkerName > markerMap (int Dim)
 
po::options_description material_options (std::string const &prefix)
 
MatSolverPackageType matSolverPackageEnumType (std::string const &type)
 
template<class T >
Max (const T &a, const T &b)
 
template<class T >
Max (const T &a, const T &b, const T &c)
 
template<typename MeshType >
auto measurePointElements (boost::shared_ptr< FunctionSpace< MeshType, bases< Lagrange< MeshType::nOrder, Scalar > > > > &_space) -> decltype(_space->element())
 
template<typename Shape , typename T , int Tag1, int Tag2 = Tag1, int TheTag = Tag1>
boost::shared_ptr< Mesh< Shape,
T, TheTag > > 
merge (boost::shared_ptr< Mesh< Shape, T, Tag1 > > m1, boost::shared_ptr< Mesh< Shape, T, Tag2 > > m2)
 
po::options_description mesh_options (int Dim, std::string const &prefix="")
 
template<typename MeshType , typename DisplType >
boost::shared_ptr< MeshType > meshMove (boost::shared_ptr< MeshType > &m, DisplType const &u)
 
template<typename MeshType >
size_type meshrank (MeshType const &mesh, mpl::bool_< true >)
 
template<typename MeshType >
size_type meshrank (MeshType const &mesh, mpl::bool_< false >)
 
template<typename T >
Geo0D< 1, T > middle (Geo0D< 1, T > const &p1, Geo0D< 1, T > const &p2)
 
template<typename T >
Geo0D< 2, T > middle (Geo0D< 2, T > const &p1, Geo0D< 2, T > const &p2)
 
template<typename T >
Geo0D< 3, T > middle (Geo0D< 3, T > const &p1, Geo0D< 3, T > const &p2)
 
template<class T >
Min (const T &a, const T &b)
 
template<class T >
Min (const T &a, const T &b, const T &c)
 
template<typename ElementRange , typename eltType , typename ExprType , typename vectorType >
void modifVec (ElementRange const &__r, eltType &u, vectorType &UnVec, ExprType expr)
 
template<typename eltType , typename ExprType , typename vectorType >
void modifVec222 (eltType &u, vectorType &UnVec, ExprType expr, std::string marker)
 
FEELPP_NO_EXPORT
po::options_description 
mpiOptions ()
 
template<typename MT , typename Iterator >
size_type nelements (boost::tuple< MT, Iterator, Iterator > const &its, bool global=false)
 
template<typename MT , typename Iterator >
size_type nelements (std::list< boost::tuple< MT, Iterator, Iterator > > const &its, bool global=false)
 
po::options_description nlsolver_options ()
 
gmsh_ptrtype nonOverlapGeometryLeft (int Dim, double hsize)
 
gmsh_ptrtype nonOverlapGeometryRight (int Dim, double hsize)
 
template<int Order, typename MeshType >
boost::shared_ptr
< FunctionSpace< MeshType,
bases
< OrthonormalPolynomialSet
< Order, Scalar > > > > 
Odh (boost::shared_ptr< MeshType > mesh)
 
po::options_description on_options (std::string const &prefix)
 
bool operator!= (const TypeInfo &lhs, const TypeInfo &rhs)
 
bool operator!= (const BareEdge &p1, const BareEdge &p2)
 
bool operator!= (const BareFace &p1, const BareFace &p2)
 
template<class T >
ADExpr< ADUnaryPlus< ADExpr< T > > > operator+ (const ADExpr< T > &expr)
 
template<typename fs_type >
void operator++ (boost::shared_ptr< Aitken< fs_type > > &aitk)
 
template<class T >
ADExpr< ADUnaryMinus< ADExpr
< T > > > 
operator- (const ADExpr< T > &expr)
 
template<typename Poly , template< uint16_type > class PolySetType>
Polynomial< Poly, PolySetType > operator- (Polynomial< Poly, PolySetType > const &p1, Polynomial< Poly, PolySetType > const &p2)
 
bool operator< (const TypeInfo &lhs, const TypeInfo &rhs)
 
bool operator< (const BareEdge &e1, const BareEdge &e2)
 
template<typename MeshType , int N>
FEELPP_EXPORT bool operator< (TimeSet< MeshType, N > const &__ts1, TimeSet< MeshType, N > const &__ts2)
 
template<typename MeshType , int N>
FEELPP_EXPORT bool operator< (boost::shared_ptr< TimeSet< MeshType, N > > const &__ts1, boost::shared_ptr< TimeSet< MeshType, N > > const &__ts2)
 
template<typename MeshType , int N>
FEELPP_NO_EXPORT bool operator< (typename TimeSet< MeshType, N >::step_type const &__s1, typename TimeSet< MeshType, N >::step_type const &__s2)
 
template<typename MeshType , int N>
FEELPP_NO_EXPORT bool operator< (typename TimeSet< MeshType, N >::step_ptrtype const &__s1, typename TimeSet< MeshType, N >::step_ptrtype const &__s2)
 
template<typename T , int N1 = Eigen::Dynamic, int N2 = Eigen::Dynamic>
DebugStream & operator<< (DebugStream &__os, Eigen::Matrix< T, N1, N2 > const &__n)
 
template<typename T , int N1 = Eigen::Dynamic, int N2 = Eigen::Dynamic>
NdebugStream & operator<< (NdebugStream &__os, Eigen::Matrix< T, N1, N2 > const &)
 
template<typename Geo , uint16_type Dim, uint16_type Order, uint16_type RDim, typename T >
std::ostream & operator<< (std::ostream &os, Reference< Geo, Dim, Order, RDim, T > const &ref)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const MatrixSparse< T > &m)
 
DebugStream & operator<< (DebugStream &__os, node< real64_type >::type const &__n)
 
template<typename T >
DebugStream & operator<< (DebugStream &__s, T const *__t)
 
NdebugStream & operator<< (NdebugStream &os, node< real64_type >::type const &)
 
template<typename T >
DebugStream & operator<< (DebugStream &__os, ublas::vector< T > const &__n)
 
template<typename T >
NdebugStream & operator<< (NdebugStream &__os, ublas::vector< T > const &)
 
template<typename T , typename Orient >
DebugStream & operator<< (DebugStream &__os, ublas::matrix< T, Orient > const &__n)
 
template<typename T , typename Orient >
NdebugStream & operator<< (NdebugStream &__os, ublas::matrix< T, Orient > const &)
 
std::ostream & operator<< (std::ostream &os, AboutData const &)
 
template<uint16_type Dim, typename T >
DebugStream & operator<< (DebugStream &__os, Geo0D< Dim, T > const &__n)
 
template<uint16_type Dim, typename T >
NdebugStream & operator<< (NdebugStream &__os, Geo0D< Dim, T > const &__n)
 
template<uint16_type Dim, typename GEOSHAPE , typename T , typename POINTTYPE >
DebugStream & operator<< (DebugStream &__os, GeoND< Dim, GEOSHAPE, T, POINTTYPE > const &__n)
 
template<uint16_type Dim, typename GEOSHAPE , typename T , typename POINTTYPE >
NdebugStream & operator<< (NdebugStream &__os, GeoND< Dim, GEOSHAPE, T, POINTTYPE > const &__n)
 
template<uint16_type Dim, typename GEOSHAPE , typename T , typename POINTTYPE >
std::ostream & operator<< (std::ostream &__os, GeoND< Dim, GEOSHAPE, T, POINTTYPE > const &__n)
 
template<typename T , int M, int N>
std::ostream & operator<< (std::ostream &os, detail::ID< T, M, N > const &id)
 
bool operator<= (const TypeInfo &lhs, const TypeInfo &rhs)
 
bool operator<= (const BareEdge &e1, const BareEdge &e2)
 
bool operator== (const TypeInfo &lhs, const TypeInfo &rhs)
 
bool operator== (const BareEdge &p1, const BareEdge &p2)
 
bool operator== (const BareFace &p1, const BareFace &p2)
 
bool operator> (const TypeInfo &lhs, const TypeInfo &rhs)
 
bool operator> (const BareEdge &e1, const BareEdge &e2)
 
bool operator>= (const TypeInfo &lhs, const TypeInfo &rhs)
 
bool operator>= (const BareEdge &e1, const BareEdge &e2)
 
template<typename space_type >
boost::shared_ptr
< OperatorSteklovPc
< space_type > > 
operatorSteklPc (boost::shared_ptr< space_type > const &space, typename OperatorSteklovPc< space_type >::backend_ptrtype const &backend=Backend< double >::build(BACKEND_PETSC))
 
template<typename self_type >
boost::shared_ptr
< OperatorTrace< self_type > > 
operatorTrace (boost::shared_ptr< self_type > const &domainspace)
 
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange , typename InterpType >
boost::shared_ptr
< OperatorInterpolation
< DomainSpaceType,
ImageSpaceType, typename
Feel::detail::opinterprangetype
< IteratorRange >::type,
InterpType > > 
opInterp (boost::shared_ptr< DomainSpaceType > const &domainspace, boost::shared_ptr< ImageSpaceType > const &imagespace, IteratorRange const &r, typename OperatorInterpolation< DomainSpaceType, ImageSpaceType, typename Feel::detail::opinterprangetype< IteratorRange >::type, InterpType >::backend_ptrtype const &backend, InterpType const &interptype, bool ddmethod)
 
template<typename space_type >
boost::shared_ptr
< OperatorLagrangeP1
< space_type > > 
opLagrangeP1_impl (boost::shared_ptr< space_type > const &Xh, typename OperatorLagrangeP1< space_type >::backend_ptrtype const &backend, std::vector< WorldComm > const &worldsComm, std::string pathMeshLagP1, std::string prefix, bool rebuild, bool parallel)
 
po::options_description opusapp_options (std::string const &prefix)
 
po::options_description oseen_options (std::string const &prefix, OseenDefaults defaults)
 
template<int Order, typename MeshType >
boost::shared_ptr
< FunctionSpace< MeshType,
bases< Lagrange< Order, Scalar,
Continuous > >, Periodicity
< NoPeriodicity > > > 
Pch (boost::shared_ptr< MeshType > mesh)
 
template<int Order, typename MeshType >
boost::shared_ptr
< FunctionSpace< MeshType,
bases< Lagrange< Order,
Vectorial > > > > 
Pchv (boost::shared_ptr< MeshType > mesh)
 
template<int Order, typename MeshType >
boost::shared_ptr
< FunctionSpace< MeshType,
bases< Lagrange< Order, Scalar,
Discontinuous > > > > 
Pdh (boost::shared_ptr< MeshType > mesh)
 
template<typename A0 >
Periodicity< A0 > periodicity (A0 const &a0)
 
template<typename A0 , typename A1 >
Periodicity< A0, A1 > periodicity (A0 const &a0, A1 const &a1)
 
template<typename A0 , typename A1 , typename A2 >
Periodicity< A0, A1, A2 > periodicity (A0 const &a0, A1 const &a1, A2 const &a2)
 
NdebugStream & perror (NdebugStream &s)
 
std::string PetscConvertKSPReasonToString (KSPConvergedReason reason)
 
std::string PetscConvertSNESReasonToString (SNESConvergedReason reason)
 
MatStructure PetscGetMatStructureEnum (Feel::MatrixStructure matStruc)
 
void PetscPCFactorSetMatSolverPackage (PC &pc, MatSolverPackageType mspackt)
 
po::options_description pfemapp_options (std::string const &prefix)
 
Feel::po::options_description podOptions (std::string const &prefix)
 
template<typename MeshType >
boost::tuple< mpl::size_t
< MESH_POINTS >, typename
MeshTraits< MeshType >
::point_const_iterator,
typename MeshTraits< MeshType >
::point_const_iterator > 
points (MeshType const &mesh)
 
std::string prefixvm (std::string const &prefix, std::string const &opt, std::string const &sep)
 
template<typename StatsIterator >
void printData (std::ostream &out, StatsIterator statsit, StatsIterator statsen, std::string const &key, size_type stats=Application::ALL|Application::HEADER)
 
template<typename StatsIterator >
void printErrors (std::ostream &out, StatsIterator statsit, StatsIterator statsen, std::string const &key, size_type stats=Application::ALL|Application::HEADER)
 
template<typename StatsIterator >
void printNumbers (std::ostream &out, StatsIterator statsit, StatsIterator statsen, std::string const &key, size_type stats=Application::ALL|Application::HEADER)
 
template<typename StatsIterator >
void printTime (std::ostream &out, StatsIterator statsit, StatsIterator statsen, std::string const &key, size_type stats=Application::ALL|Application::HEADER)
 
template<typename Pset , typename Func , typename IM >
Polynomial< Pset, Scalarproject (Pset const &pset, Func const &f, IM const &im)
 
template<typename TDomainSpace , typename TDualImageSpace >
boost::shared_ptr< Projector
< TDomainSpace,
TDualImageSpace > > 
projector (boost::shared_ptr< TDomainSpace > const &domainspace, boost::shared_ptr< TDualImageSpace > const &imagespace, typename Projector< TDomainSpace, TDualImageSpace >::backend_ptrtype const &backend=Backend< double >::build(BACKEND_PETSC), ProjectorType proj_type=L2, double epsilon=0.01, double gamma=20, DirichletType dirichlet_type=WEAK)
 
template<typename MeshTestType , typename MeshTrialType , typename IteratorRange , typename Im , typename Expr >
boost::shared_ptr
< QuadPtLocalization< typename
Feel::detail::quadptlocrangetype
< IteratorRange >::type, Im,
Expr > > 
quadPtLocPtr (boost::shared_ptr< MeshTestType > meshTest, boost::shared_ptr< MeshTrialType > meshTrial, IteratorRange const &elts, Im const &im, Expr const &expr)
 
template<typename MeshTestType , typename IteratorRange , typename Im , typename Expr >
boost::shared_ptr
< QuadPtLocalization< typename
Feel::detail::quadptlocrangetype
< IteratorRange >::type, Im,
Expr > > 
quadPtLocPtr (boost::shared_ptr< MeshTestType > meshTest, IteratorRange const &elts, Im const &im, Expr const &expr)
 
template<typename SpaceType , typename Expr >
SpaceType::element_type region (boost::shared_ptr< SpaceType > const &space, Expr const &expr)
 
template<typename SpaceType >
SpaceType::element_type regionMarker (boost::shared_ptr< SpaceType > const &space)
 
template<typename SpaceType >
SpaceType::element_type regionMarker2 (boost::shared_ptr< SpaceType > const &space)
 
template<typename SpaceType >
SpaceType::element_type regionMarker3 (boost::shared_ptr< SpaceType > const &space)
 
template<typename SpaceType >
SpaceType::element_type regionProcess (boost::shared_ptr< SpaceType > const &space)
 
template<typename SpaceType , typename Expr >
SpaceType::element_type regionv (boost::shared_ptr< SpaceType > const &space, Expr const &expr)
 
scale (this->thetaq(0))
 
FEELPP_NO_EXPORT
po::options_description 
serialOptions ()
 
BareEdge setBareEdge (size_type const i, size_type const j)
 It creates a BareEdge, ignoring orientation. More...
 
BareEdge setBareEdgeNo (size_type const i, size_type const j)
 It creates a non-standard BareEdge. More...
 
template<class Expr >
ADExpr< ADFuncSin< ADExpr
< Expr > > > 
sin (const ADExpr< Expr > &expr)
 
template<class T , int Nvar, int Order, int Var>
ADExpr< ADFuncSin< ADType< T,
Nvar, Order, Var > > > 
sin (const ADType< T, Nvar, Order, Var > &x)
 
po::options_description solvereigen_options (std::string const &prefix)
 
po::options_description solvereigenslepc_options (std::string const &prefix)
 
FEELPP_NO_EXPORT bool splitTest (const RegionTree::pbox_container_type &b, const node_type &bmin, const node_type &bmax, size_type dir, scalar_type &split_v)
 
template<typename MatrixType >
void spy (MatrixType const &__m, std::string const &filename)
 
template<class Expr >
ADExpr< ADFuncSqrt< ADExpr
< Expr > > > 
sqrt (const ADExpr< Expr > &expr)
 
template<class T , int Nvar, int Order, int Var>
ADExpr< ADFuncSqrt< ADType< T,
Nvar, Order, Var > > > 
sqrt (const ADType< T, Nvar, Order, Var > &x)
 
void stencilManagerAdd (StencilManagerImpl::key_type const &key, StencilManagerImpl::graph_ptrtype graph)
 function that add an entry in the StencilManager
 
void stencilManagerGarbage (StencilManagerImpl::key_type const &key)
 function that cleans up one entry the StencilManager
 
void stencilManagerGarbageCollect ()
 function that cleans up the StencilManager any time stencil() is called
 
void stencilManagerPrint ()
 print entries stored in stencil manager
 
template<int I, int J, typename IteratorRange >
fusion::pair< fusion::pair
< mpl::int_< I >, mpl::int_< J >
>, IteratorRange > 
stencilRange (IteratorRange const &r)
 
stencilRangeMap0Type stencilRangeMap ()
 
template<typename ThePair1Type >
stencilRangeMap1Type
< ThePair1Type > 
stencilRangeMap (ThePair1Type const &p)
 
template<typename ThePair1Type , typename ThePair2Type >
stencilRangeMap2Type
< ThePair1Type, ThePair2Type > 
stencilRangeMap (ThePair1Type const &p1, ThePair2Type const &p2)
 
template<typename EltType >
fusion::result_of::accumulate
< typename
EltType::functionspace_type::functionspace_vector_type,
fusion::vector
<>, detail::CreateElementVector
< EltType > >::type 
subelements (EltType const &e, std::vector< std::string > const &n)
 
template<int Dim>
std::vector< symbol > symbols ()
 
std::vector< symbol > symbols (std::initializer_list< std::string > l)
 
std::vector< symbol > symbols (std::vector< std::string > l)
 
template<>
std::vector< symbol > symbols< 1 > ()
 
template<>
std::vector< symbol > symbols< 2 > ()
 
template<>
std::vector< symbol > symbols< 3 > ()
 
template<class Expr >
ADExpr< ADFuncTan< ADExpr
< Expr > > > 
tan (const ADExpr< Expr > &expr)
 
template<class T , int Nvar, int Order, int Var>
ADExpr< ADFuncTan< ADType< T,
Nvar, Order, Var > > > 
tan (const ADType< T, Nvar, Order, Var > &x)
 
template<int Order, typename MeshType >
boost::shared_ptr
< FunctionSpace< MeshType,
bases< Lagrange< Order+1,
Vectorial >, Lagrange< Order,
Scalar > > > > 
THch (boost::shared_ptr< MeshType > mesh)
 
template<typename RefEntity >
void toPython (RefEntity const &e, std::string str="simplex")
 
template<int Ngeo = 1>
boost::shared_ptr< Mesh
< Simplex< 2, Ngeo > > > 
unitCircle (double h=option(_name="gmsh.hsize").template as< double >())
 
boost::shared_ptr< Mesh
< Simplex< 3 > > > 
unitCube (double h)
 
template<typename P , template< uint16_type > class Type, template< class, template< uint16_type > class > class Poly1, template< class, template< uint16_type > class > class Poly2>
PolynomialSet< P, Type > unite (Poly1< P, Type > const &pset1, Poly2< P, Type > const &pset2)
 union of two polynomial sets P1 and P2 : $ P_1 \oplus P_2$ More...
 
template<int Dim, typename Convex = Simplex<Dim>>
boost::shared_ptr< Mesh< Convex > > unitHypercube (double h=option(_name="gmsh.hsize").template as< double >())
 
detail boost::shared_ptr< Mesh
< Simplex< 1 > > > 
unitSegment (double h)
 
template<int Ngeo = 1>
boost::shared_ptr< Mesh
< Simplex< 3, Ngeo > > > 
unitSphere (double h=option(_name="gmsh.hsize").template as< double >())
 
boost::shared_ptr< Mesh
< Simplex< 2 > > > 
unitSquare (double h)
 
void updateBackendPreconditionerOptions (po::options_description &_options, std::string const &prefix)
 
std::vector< ptree::ptree > & updateStats (std::vector< ptree::ptree > &stats)
 
DebugStream Warning (int area)
 
DebugStream Warning (bool cond, int area)
 
Constructors, destructor
 Elements (WorldComm const &worldComm=Environment::worldComm())
 
 Elements (Elements const &f)
 
virtual ~Elements ()
 
Operator overloads
Elements & operator= (Elements const &e)
 
Accessors
elements_type const & elements () const
 
virtual bool isEmpty () const
 
WorldComm const & worldCommElements () const
 
bool isBoundaryElement (element_type const &e) const
 
bool isBoundaryElement (size_type const &id) const
 
element_iterator elementIterator (size_type i) const
 
element_iterator elementIterator (size_type i, size_type p) const
 
element_type const & element (size_type i) const
 
element_type const & element (size_type i, size_type p) const
 
bool hasElement (size_type i) const
 
element_iterator beginElement ()
 
element_iterator endElement ()
 
parts_const_iterator_type beginParts () const
 
parts_const_iterator_type endParts () const
 
std::pair< element_iterator,
element_iterator > 
elementsRange ()
 
element_iterator beginElementWithId (size_type m)
 
element_iterator endElementWithId (size_type m)
 
marker_element_const_iterator beginElementWithMarker (size_type m) const
 
marker2_element_const_iterator beginElementWithMarker2 (size_type m) const
 
marker3_element_const_iterator beginElementWithMarker3 (size_type m) const
 
marker_element_const_iterator endElementWithMarker (size_type m) const
 
marker2_element_const_iterator endElementWithMarker2 (size_type m) const
 
marker3_element_const_iterator endElementWithMarker3 (size_type m) const
 
std::pair
< marker_element_const_iterator,
marker_element_const_iterator > 
elementsWithMarker (size_type m, size_type p) const
 
std::pair
< marker2_element_const_iterator,
marker2_element_const_iterator > 
elementsWithMarker2 (size_type m, size_type p) const
 
std::pair
< marker3_element_const_iterator,
marker3_element_const_iterator > 
elementsWithMarker3 (size_type m, size_type p) const
 
element_iterator beginElementWithProcessId (size_type m)
 
element_iterator endElementWithProcessId (size_type m)
 
std::pair
< element_const_iterator,
element_const_iterator > 
elementsWithProcessId (size_type m) const
 
elements_type::template
nth_index< 0 >::type & 
elementsById ()
 
marker_elements & elementsByMarker ()
 
marker2_elements & elementsByMarker2 ()
 
marker3_elements & elementsByMarker3 ()
 
pid_elements & elementsByProcessId ()
 
std::pair
< location_element_const_iterator,
location_element_const_iterator > 
boundaryElements (uint16_type entity_min_dim, uint16_type entity_max_dim, size_type p) const
 
std::pair
< location_element_const_iterator,
location_element_const_iterator > 
boundaryElements (size_type p) const
 
std::pair
< location_element_const_iterator,
location_element_const_iterator > 
internalElements (size_type p) const
 
location_elements & elementsByLocation ()
 
location_element_iterator beginInternalElement ()
 
location_element_iterator endInternalElement ()
 
location_element_iterator beginElementOnBoundary ()
 
location_element_iterator endElementOnBoundary ()
 
ghostcell_element_iterator beginGhostElement ()
 
ghostcell_element_iterator endGhostElement ()
 
Methods
element_type const & addElement (element_type &f)
 
template<typename ElementVecType >
void updateMarker2 (ElementVecType const &evec)
 
template<typename ElementVecType >
void updateMarker3 (ElementVecType const &evec)
 
template<typename IteratorRange >
void updateMarker2WithRangeElements (IteratorRange const &range, flag_type flag)
 
template<typename IteratorRange >
void updateMarker3WithRangeElements (IteratorRange const &range, flag_type flag)
 
void updateMarkersFromFaces ()
 
void setWorldCommElements (WorldComm const &_worldComm)
 

Variables

mesh_3d_ptrtypeLS ___mesh_3d_LS
 
mesh_ptrtypeLS ___mesh_LS
 
A = *M_Aq[0]
 
BlocksStencilPattern default_block_pattern
 
const size_type EXTRACTION_KEEP_ALL_IDS
 
const size_type EXTRACTION_KEEP_EDGES_IDS = ( 1<<1 )
 
const size_type EXTRACTION_KEEP_FACES_IDS = ( 1<<2 )
 
const size_type EXTRACTION_KEEP_MESH_RELATION = ( 1<<4 )
 
const size_type EXTRACTION_KEEP_POINTS_IDS = ( 1<<0 )
 
const size_type EXTRACTION_KEEP_VOLUMES_IDS = ( 1<<3 )
 
const double factor_from_eps = 50
 
const float factor_from_eps_fl = 50
 
const char * FEELPP_GMSH_FORMAT_VERSION = "2.2"
 
const GMSH_PARTITIONER GMSH_PARTITIONER_DEFAULT = GMSH_PARTITIONER_CHACO
 
const mpl::int_
< COMPONENT_IN_COMPONENT > 
INDEX_COMPONENT_IN_COMPONENT = mpl::int_<COMPONENT_IN_COMPONENT>()
 
const mpl::int_
< COMPONENT_IN_COMPONENT_FUNCTION_INDEX > 
INDEX_COMPONENT_IN_COMPONENT_FUNCTION_INDEX = mpl::int_<COMPONENT_IN_COMPONENT_FUNCTION_INDEX>()
 
const mpl::int_< FUNCTION_INDEX > INDEX_FUNCTION_INDEX = mpl::int_<FUNCTION_INDEX>()
 
const mpl::int_< GLOBAL_COMPONENT > INDEX_GLOBAL_COMPONENT = mpl::int_<GLOBAL_COMPONENT>()
 
const mpl::int_
< GLOBAL_FUNCTION_INDEX > 
INDEX_GLOBAL_FUNCTION_INDEX = mpl::int_<GLOBAL_FUNCTION_INDEX>()
 
const mpl::int_
< PER_COMPONENT_FUNCTION_INDEX > 
INDEX_PER_COMPONENT_FUNCTION_INDEX = mpl::int_<PER_COMPONENT_FUNCTION_INDEX>()
 
const int64_type invalid_flag_type_value = std::numeric_limits<int32_type>::min()
 
decltype(elements(___mesh_3d_LS))
typedef 
itRange_3d_LS
 
decltype(elements(___mesh_LS))
typedef 
itRangeLS
 
elements_type M_elements
 
parts_map_type M_parts
 
WorldComm M_worldCommElements
 
const bool material_air = MaterialLib::factory_type::instance().registerProduct( "Air", &detail::createMaterial<Air> )
 
const bool material_castiron = MaterialLib::factory_type::instance().registerProduct( "CastIron", &detail::createMaterial<CastIron> )
 
const auto MATSOLVER_DEFAULT = MATSOLVER_PETSC
 
const uint16_type MESH_ALL_COMPONENTS = MESH_UPDATE_EDGES | MESH_UPDATE_FACES | MESH_CHECK | MESH_PARTITION | MESH_RENUMBER
 
const uint16_type MESH_COMPONENTS_DEFAULTS = MESH_RENUMBER | MESH_CHECK
 
const double Pi = 3.14159265358979323846264338328
 
const double pi = constants::pi<double>()
 
const double TGV = 1e20
 
const double two_pi = constants::two_pi<double>()
 
Constants
const uint8_type invalid_uint8_type_value = uint8_type( -1 )
 
const uint16_type invalid_uint16_type_value = uint16_type( -1 )
 
const uint32_type invalid_uint32_type_value = uint32_type( -1 )
 
const uint64_type invalid_uint64_type_value = uint64_type( -1 )
 
const dim_type invalid_dim_type_value = dim_type( -1 )
 
const size_type invalid_size_type_value = size_type( -1 )
 

Detailed Description

[marker1]

Namespace for general FEEL functions.

Special routines to read meshes and special structures for sides and faces handling

Classes BareFace and BareEdge have been created to give an UNIQUE Representation for mesh faces and edges and thus allow the construction of global tables or Fields.

file GeoEntity.h

include linear algebra backend include function space class include gmsh mesh importer include the header for the variational formulation language (vf) aka FEEL++

Typedef Documentation

typedef ublas::symmetric_matrix<double, ublas::lower, ublas::row_major, ublas::bounded_array<double, 9> > Feel::hessian_node_type

hessian type

boost::shared_ptr< RegionTree > Feel::region_tree_ptrtype

pointer type for Region Tree.

typedef Singleton< Factory< Simget, std::string > > Feel::SimgetFactory

Simget factory

Enumeration Type Documentation

anonymous enum
Enumerator
FUNCTIONAL 

functional identifier

EQUALITIES 

equalities identifier

INEQUALITIES 

inequalities identifier

Backend types

At the moment, we support GMM(serial), PETSC and TRILINOS(serial and parallel)

BFGS algorithm (Broyden, Fletcher, Goldfarb, Shanno) Quasi Newton method for optimization problems. with Wolfe Line search.

Ripped from getfem++ by Y. Renard

CRBErrorType Determine the type of error estimation used

  • CRB_RESIDUAL : use the residual error estimation without algorithm SCM
  • CRB_RESIDUAL_SCM : use the residual error estimation and also algorithm SCM
  • CRB_NO_RESIDUAL : in this case we don't compute error estimation
  • CRB_EMPIRICAL : compute |S_n - S_{n-1}| where S_n is the output obtained by using a reduced basis with n elements

Area debugging tool.

VLOG(1) provides a debug stream to which you can pass a number, say 100, associated to an area of the code, say a class A. In the implementation of the class A, you use debug statement like

void A::f() { DVLOG(2) << "A::f() is called.\n"; do something here }

Now the debug message "A::f() is called." will be seen only if the area 100 is defined in the environment(shell) variable DEBUG while executing a program A::f() is called runWithA that makes use of our class A.

runwithA

–> no debug message related to A

export DEBUG="100" runwithA

A::f() is called.

With this tool you can select the area you want to debug explicitly while keeping the others hidden.

Author
Christophe Prud'homme (chris.nosp@m.toph.nosp@m.e.pru.nosp@m.dhom.nosp@m.me@fe.nosp@m.elpp.nosp@m..org)

Defines an enum for eigenproblem types. This can be Hermitian (HEP), generalized Hermitian (GHEP), non-Hermitian (NHEP), generalized non-Hermitian (GNHEP) and Generalized Non-Hermitian GNHEP with positive (semi-)definite B

Defines an enum for iterative eigenproblem solver types

Enumerator
MESH_ELEMENTS 

elements

MESH_FACES 

faces

MESH_INTERNAL_FACES 

internal faces

MESH_EDGES 

edges

MESH_INTERNAL_EDGES 

internal edges

MESH_POINTS 

points

Defines an enum for field split types

Enumerator
MESH_ENTITY_INTERNAL 

internal entity

MESH_ENTITY_BOUNDARY 

boundary entity

enumerate the various elements available in gmsh

Enumerator
GMSH_LINE 

Line (2 nodes).

GMSH_TRIANGLE 

Triangle (3 nodes).

GMSH_QUADRANGLE 

Quadrangle (4 nodes).

GMSH_TETRAHEDRON 

Tetrahedron (4 nodes).

GMSH_HEXAHEDRON 

Hexahedron (8 nodes).

GMSH_PRISM 

Prism (6 nodes).

GMSH_PYRAMID 

Pyramid (5 nodes).

GMSH_LINE_2 

Second order line (3 nodes: 2 associated.

GMSH_TRIANGLE_2 

Second order triangle (6 nodes: 3.

GMSH_QUADRANGLE_2 

Second order quadrangle (9 nodes: 4.

GMSH_TETRAHEDRON_2 

Second order tetrahedron (10 nodes:

GMSH_HEXAHEDRON_2 

Second order hexahedron (27 nodes: 8.

GMSH_PRISM_2 

Second order prism (18 nodes: 6 associated.

GMSH_PYRAMID_2 

Second order pyramid (14 nodes: 5.

GMSH_POINT 

Point (1 node).

GMSH_TRIANGLE_INCOMPLETE_3 

triangle of order 3

GMSH_TRIANGLE_3 

triangle of order 3

GMSH_TRIANGLE_INCOMPLETE_4 

triangle of order 4

GMSH_TRIANGLE_4 

triangle of order 4

GMSH_TRIANGLE_INCOMPLETE_5 

triangle of order 5

GMSH_TRIANGLE_5 

triangle of order 5

GMSH_LINE_3 

line of order 3

GMSH_LINE_4 

line of order 4

GMSH_LINE_5 

line of order 5

GMSH_TETRAHEDRON_3 

tetra of order 3

GMSH_TETRAHEDRON_4 

tetra of order 4

GMSH_TETRAHEDRON_5 

tetra of order 5

Enumerator
HERMITIAN 

hermitian : $A^* = A$

NON_HERMITIAN 

non hermitian : $A^* != A$

POSITIVE_DEFINITE 

positive definite matrix : $v^* A v > 0 $ for all non-zero v

SINGULAR 

singular matrix : $det(A)=0$ and 0 is an eigenvalue

DENSE 

dense matrix

indicates the structure of the matrix versus preconditioner

Components of a mesh that can be enabled or disabled when calling updateForUse()

Context for 'on' operation on sparse matrices

Enumerator
ON_NONE 

none

ON_ELIMINATION 

elimination

ON_PENALISATION 

penalisation

ON_ELIMINATION_KEEP_DIAGONAL 

enables elimination and keep diagonal entry(ie don't put 1), modify rhs accordingly

ON_ELIMINATION_SYMMETRIC 

enables elimination and make a symmetric elimination

Defines an enum for the position of the spectrum, i.e. the eigenvalues to be computed.

Defines an enum for preconditioner types

Enumerator
GEOMETRY_POINT 

point entity

GEOMETRY_LINE 

line entity

GEOMETRY_SURFACE 

surface entity

GEOMETRY_VOLUME 

volume entity

GEOMETRY_4 

hypercube entity

GEOMETRY_5 

hypercube entity

Define an enum for non linear solver type if SELECT_IN_ARGLIST the choice is done by the arguments in the line command

Defines an enum for various linear solver packages. This allows for run-time switching between solver packages

Defines an enum for iterative solver types

Spectral transform type

Function Documentation

element_type const& Feel::addElement ( element_type &  f)

add a new element in the mesh

Parameters
fa new point
Returns
the new point from the list
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::element_const_iterator, typename MeshTraits<MeshType>::element_const_iterator> Feel::allelements ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over elements with pid flag
po::options_description Feel::backend_options ( std::string const &  prefix)
Returns
the command lines options of the petsc backend
Parameters
prefixprefix given to the backend option
Returns
backend command line options description
po::options_description Feel::backendeigen_options ( std::string const &  prefix)
Returns
the command lines options of the eigen backend
po::options_description Feel::backendpetsc_options ( std::string const &  prefix)
Returns
the command lines options of the petsc backend
po::options_description Feel::bdf_options ( std::string const &  prefix)
Returns
the command lines options for BDF

command line options for BDF

location_element_iterator Feel::beginElementOnBoundary ( )

get the begin() iterator on all the boundary elements

Returns
the begin() iterator on all the boundary elements
marker_element_const_iterator Feel::beginElementWithMarker ( size_type  m) const
Returns
the iterator begin over the elements with Marker1 m
marker2_element_const_iterator Feel::beginElementWithMarker2 ( size_type  m) const
Returns
the iterator begin over the elements with Marker2 m
marker3_element_const_iterator Feel::beginElementWithMarker3 ( size_type  m) const
Returns
the iterator begin over the elements with Marker3 m
ghostcell_element_iterator Feel::beginGhostElement ( )

get the begin() iterator on all ghost elements

Returns
the begin() iterator on all ghost elements
location_element_iterator Feel::beginInternalElement ( )

get the begin() iterator on all the internal elements

Returns
the begin() iterator on all the internal elements

References invalid_uint16_type_value.

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_EDGES>, typename MeshTraits<MeshType>::location_edge_const_iterator, typename MeshTraits<MeshType>::location_edge_const_iterator> Feel::boundaryedges ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over all boundary edges of the mesh
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::location_element_const_iterator, typename MeshTraits<MeshType>::location_element_const_iterator> Feel::boundaryelements ( MeshType const &  mesh,
uint16_type  entity_min_dim = 0,
uint16_type  entity_max_dim = 2 
)
Returns
a pair of iterators to iterate over elements of the mesh which share a face with the boundary
std::pair<location_element_const_iterator, location_element_const_iterator> Feel::boundaryElements ( uint16_type  entity_min_dim,
uint16_type  entity_max_dim,
size_type  p 
) const
Returns
the range of iterator (begin,end) over the boundary element on processor p
std::pair<location_element_const_iterator, location_element_const_iterator> Feel::boundaryElements ( size_type  p) const
Returns
the range of iterator (begin,end) over the boundary element on processor p

References boundaryElements().

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_FACES>, typename MeshTraits<MeshType>::location_face_const_iterator, typename MeshTraits<MeshType>::location_face_const_iterator> Feel::boundaryfaces ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over all boundary faces of the mesh
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_POINTS>, typename MeshTraits<MeshType>::location_point_const_iterator, typename MeshTraits<MeshType>::location_point_const_iterator> Feel::boundarypoints ( MeshType const &  mesh)
Returns
the range of iterators [begin,end] over the boundary points of the mesh
Warning
this filter is not parallelized
template<typename Poly >
Polynomial<Poly, Vectorial> Feel::curl ( Polynomial< Poly, Vectorial > const &  p)

compute the curl of a vectorial polynomial p

Returns
the curl of the vectorial polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::coeff(), and project().

template<typename Poly >
PolynomialSet<Poly, Vectorial> Feel::curl ( PolynomialSet< Poly, Vectorial > const &  p)

compute the curl of a vectorial polynomial set p

Returns
the curl of the vectorial polynomial

References Feel::PolynomialSet< Poly, PolySetType >::coeff(), Feel::PolynomialSet< Poly, PolySetType >::derivate(), and project().

template<typename Poly >
Polynomial<Poly, Vectorial> Feel::curlt ( Polynomial< Poly, Vectorial > const &  p)

compute the transpose of the curl of a vectorial polynomial p

Note
swap the signs of the curl matrix operator
Returns
the transpose of the curl of the vectorial polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::coeff(), and project().

template<typename Poly >
PolynomialSet<Poly, Vectorial> Feel::curlt ( PolynomialSet< Poly, Vectorial > const &  p)

compute the transpose of the curl of a vectorial polynomial p

Note
swap the signs of the curl matrix operator
Returns
the transpose of the curl of the vectorial polynomial

References Feel::PolynomialSet< Poly, PolySetType >::coeff(), Feel::PolynomialSet< Poly, PolySetType >::derivate(), and project().

template<typename Poly >
Polynomial<Poly, Scalar> Feel::divergence ( Polynomial< Poly, Vectorial > const &  p)

compute the divergence of a vectorial polynomial p

Returns
the divergence of the vectorial polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::basis(), and Feel::Polynomial< Poly, PolySetType, Container >::coeff().

template<typename Poly >
PolynomialSet<Poly, Scalar> Feel::divergence ( PolynomialSet< Poly, Vectorial > const &  p)

compute the divergence of a vectorial polynomial set p

Returns
the divergence of the vectorial polynomial set

References Feel::PolynomialSet< Poly, PolySetType >::basis(), and Feel::PolynomialSet< Poly, PolySetType >::coeff().

template<typename Poly , template< uint16_type > class Type>
Polynomial<Poly, Type> Feel::dx ( Polynomial< Poly, Type > const &  p)

compute $\frac{\partial \cdot}{\partial x}$ of a polynomial p

Returns
the gradient of the scalar polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::basis(), and Feel::Polynomial< Poly, PolySetType, Container >::coeff().

template<typename Poly , template< uint16_type > class Type>
PolynomialSet<Poly, Type> Feel::dx ( PolynomialSet< Poly, Type > const &  p)

compute $\frac{\partial \cdot}{\partial x}$ of a polynomial set p

Returns
the gradient of the scalar polynomial

References Feel::PolynomialSet< Poly, PolySetType >::basis(), and Feel::PolynomialSet< Poly, PolySetType >::coeff().

template<typename Poly , template< uint16_type > class Type>
Polynomial<Poly, Type> Feel::dy ( Polynomial< Poly, Type > const &  p)

compute $\frac{\partial \cdot}{\partial y}$ of a polynomial p

Returns
the gradient of the scalar polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::basis(), and Feel::Polynomial< Poly, PolySetType, Container >::coeff().

template<typename Poly , template< uint16_type > class Type>
PolynomialSet<Poly, Type> Feel::dy ( PolynomialSet< Poly, Type > const &  p)

compute $\frac{\partial \cdot}{\partial y}$ of a polynomial set p

Returns
the gradient of the scalar polynomial

References Feel::PolynomialSet< Poly, PolySetType >::basis(), and Feel::PolynomialSet< Poly, PolySetType >::coeff().

template<typename Poly , template< uint16_type > class Type>
Polynomial<Poly, Type> Feel::dz ( Polynomial< Poly, Type > const &  p)

compute $\frac{\partial \cdot}{\partial z}$ of a polynomial p

Returns
the gradient of the scalar polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::basis(), and Feel::Polynomial< Poly, PolySetType, Container >::coeff().

template<typename Poly , template< uint16_type > class Type>
PolynomialSet<Poly, Type> Feel::dz ( PolynomialSet< Poly, Type > const &  p)

compute $\frac{\partial \cdot}{\partial z}$ of a polynomial set p

Returns
the gradient of the scalar polynomial

References Feel::PolynomialSet< Poly, PolySetType >::basis(), and Feel::PolynomialSet< Poly, PolySetType >::coeff().

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_EDGES>, typename MeshTraits<MeshType>::pid_edge_const_iterator, typename MeshTraits<MeshType>::pid_edge_const_iterator> Feel::edges ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over edges of the mesh on processor __pid
Parameters
mesha mesh data structure
__pidprocess id
Returns
a pair of edge iterators (begin,end)
template<typename ElementType >
ElementType Feel::element_div ( ElementType const &  v1,
ElementType const &  v2 
)

Computes the element wise division of two vectors and eventually in parallel

Parameters
v1vector (eventually distributed)
v2vector (eventually distributed)
Returns
the element wise division product of v1 and v2
template<typename T >
VectorEigen<T> Feel::element_product ( VectorEigen< T > const &  v1,
VectorEigen< T > const &  v2 
)

Computes the element wise product of two vectors and eventually in parallel

Parameters
v1vector (eventually distributed)
v2vector (eventually distributed)
Returns
the element product of v1 and v2

References Feel::VectorEigen< T >::vec().

template<typename T >
VectorEigen<T> Feel::element_product ( boost::shared_ptr< VectorEigen< T > > const &  v1,
boost::shared_ptr< VectorEigen< T > > const &  v2 
)

Computes the element wise product of two vectors and eventually in parallel

Parameters
v1vector (eventually distributed)
v2vector (eventually distributed)
Returns
the inner product of v1 and v2
template<typename T >
VectorUblas<T> Feel::element_product ( VectorUblas< T > const &  v1,
VectorUblas< T > const &  v2 
)

Computes the element wise product of two vectors and eventually in parallel

Parameters
v1vector (eventually distributed)
v2vector (eventually distributed)
Returns
the element product of v1 and v2
template<typename T >
VectorUblas<T> Feel::element_product ( boost::shared_ptr< VectorUblas< T > > const &  v1,
boost::shared_ptr< VectorUblas< T > > const &  v2 
)

Computes the element wise product of two vectors and eventually in parallel

Parameters
v1vector (eventually distributed)
v2vector (eventually distributed)
Returns
the inner product of v1 and v2

References element_product().

template<typename ElementType >
ElementType Feel::element_product ( ElementType const &  v1,
ElementType const &  v2 
)

Computes the element wise product of two vectors and eventually in parallel

Parameters
v1vector (eventually distributed)
v2vector (eventually distributed)
Returns
the element wise product of v1 and v2
elements_type const& Feel::elements ( ) const
Returns
the elements container
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::element_const_iterator, typename MeshTraits<MeshType>::element_const_iterator> Feel::elements ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over elements with pid flag

References elements().

elements_type::template nth_index<0>::type& Feel::elementsById ( )

get the elements container by id

Returns
the element container by id
location_elements& Feel::elementsByLocation ( )

get the elements container using the location view

Returns
the element container using location view
marker_elements& Feel::elementsByMarker ( )

get the elements container using the Marker1 view

Returns
the element container using Marker1 view
marker2_elements& Feel::elementsByMarker2 ( )

get the elements container using the Marker2 view

Returns
the element container using Marker2 view
marker3_elements& Feel::elementsByMarker3 ( )

get the elements container using the Marker3 view

Returns
the element container using Marker3 view
pid_elements& Feel::elementsByProcessId ( )

get the elements container using the process id view

Returns
the element container using process id view

get the elements container using the process id view

Returns
the element container using marker view
std::pair<element_iterator, element_iterator> Feel::elementsRange ( )
Returns
the range of iterator (begin,end) over the elements with marker m on processor p
std::pair<marker_element_const_iterator, marker_element_const_iterator> Feel::elementsWithMarker ( size_type  m,
size_type  p 
) const
Returns
the range of iterator (begin,end) over the elements with Marker1 m on processor p
std::pair<marker2_element_const_iterator, marker2_element_const_iterator> Feel::elementsWithMarker2 ( size_type  m,
size_type  p 
) const
Returns
the range of iterator (begin,end) over the elements with Marker2 m on processor p
std::pair<marker3_element_const_iterator, marker3_element_const_iterator> Feel::elementsWithMarker3 ( size_type  m,
size_type  p 
) const
Returns
the range of iterator (begin,end) over the elements with Marker3 m on processor p
location_element_iterator Feel::endElementOnBoundary ( )

get the end() iterator on all the boundary elements

Returns
the end() iterator on all the boundary elements
marker_element_const_iterator Feel::endElementWithMarker ( size_type  m) const
Returns
the iterator end over the elements with Marker1 m
marker2_element_const_iterator Feel::endElementWithMarker2 ( size_type  m) const
Returns
the iterator end over the elements with Marker2 m
marker3_element_const_iterator Feel::endElementWithMarker3 ( size_type  m) const
Returns
the iterator end over the elements with Marker3 m
ghostcell_element_iterator Feel::endGhostElement ( )

get the end() iterator on all ghost elements

Returns
the end() iterator on all ghost elements
location_element_iterator Feel::endInternalElement ( )

get the end() iterator on all the internal elements

Returns
the end() iterator on all the internal elements

References invalid_uint16_type_value.

po::options_description Feel::exporter_options ( std::string const &  prefix)
Returns
the command lines options for the exporter

command line options for exporter

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_FACES>, typename MeshTraits<MeshType>::pid_face_const_iterator, typename MeshTraits<MeshType>::pid_face_const_iterator> Feel::faces ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over faces of the mesh on processor __pid
Parameters
mesha mesh data structure
__pidprocess id
Returns
a pair of face iterators (begin,end)
template<typename Poly >
Polynomial<Poly, Vectorial> Feel::gradient ( Polynomial< Poly, Scalar > const &  p)

compute the gradient of a scalar polynomial p

Returns
the gradient of the scalar polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::basis(), and Feel::Polynomial< Poly, PolySetType, Container >::coeff().

template<typename Poly >
Polynomial<Poly, Tensor2> Feel::gradient ( Polynomial< Poly, Vectorial > const &  p)

compute the gradient of a vectorial polynomial p

Returns
the gradient of the vectorial polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::basis(), and Feel::Polynomial< Poly, PolySetType, Container >::coeff().

template<typename Poly >
PolynomialSet<Poly, Vectorial> Feel::gradient ( PolynomialSet< Poly, Scalar > const &  p)

compute the gradient of a scalar polynomial set

Returns
the gradient of the scalar polynomial set

References Feel::PolynomialSet< Poly, PolySetType >::basis(), Feel::PolynomialSet< Poly, PolySetType >::coeff(), and project().

template<typename Poly >
PolynomialSet<Poly, Tensor2> Feel::gradient ( PolynomialSet< Poly, Vectorial > const &  p)

compute the gradient of a vectorial polynomial set

Returns
the gradient of the vectorial polynomial set

References Feel::PolynomialSet< Poly, PolySetType >::basis(), Feel::PolynomialSet< Poly, PolySetType >::coeff(), and project().

bool Feel::hasElement ( size_type  i) const
Returns
true if element with id i is found, false otherwise
template<typename Poly >
PolynomialSet<Poly, Tensor2> Feel::hessian ( PolynomialSet< Poly, Scalar > const &  p)

compute the gradient of a vectorial polynomial set

Returns
the gradient of the vectorial polynomial set

References Feel::PolynomialSet< Poly, PolySetType >::coeff(), Feel::PolynomialSet< Poly, PolySetType >::d(), and project().

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::element_const_iterator, typename MeshTraits<MeshType>::element_const_iterator> Feel::idedelements ( MeshType const &  mesh,
flag_type  flag 
)
Returns
a pair of iterators to iterate over elements with id flag
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_FACES>, typename MeshTraits<MeshType>::face_const_iterator, typename MeshTraits<MeshType>::face_const_iterator> Feel::idedfaces ( MeshType const &  mesh,
size_type  id 
)
Returns
a pair of iterators to iterate over elements with id id
template<typename T >
type_traits<T>::real_type Feel::inner_product ( Vector< T > const &  v1,
Vector< T > const &  v2 
)

Computes the inner product of two vectors and eventually in parallel

Parameters
v1vector (eventually distributed)
v2vector (eventually distributed)
Returns
the inner product of v1 and v2
template<typename T >
type_traits<T>::real_type Feel::inner_product ( boost::shared_ptr< Vector< T > > const &  v1,
boost::shared_ptr< Vector< T > > const &  v2 
)

Computes the inner product of two vectors and eventually in parallel

Parameters
v1vector (eventually distributed)
v2vector (eventually distributed)
Returns
the inner product of v1 and v2

References inner_product().

template<typename Poly , template< uint16_type > class PsetType>
Poly::value_type Feel::integrate ( Polynomial< Poly, PsetType > const &  p)

integrate a polynomial over a convex

since we use a L2 orthonormal basis, the integral of the polynomial is equal to the first first coefficient of the polynomial

References Feel::Polynomial< Poly, PolySetType, Container >::coeff().

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_EDGES>, typename MeshTraits<MeshType>::location_edge_const_iterator, typename MeshTraits<MeshType>::location_edge_const_iterator> Feel::internaledges ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over all internal edges of the mesh
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::location_element_const_iterator, typename MeshTraits<MeshType>::location_element_const_iterator> Feel::internalelements ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over elements of the mesh which are stricly within the domain that is to say they do not share a face with the boundary
std::pair<location_element_const_iterator, location_element_const_iterator> Feel::internalElements ( size_type  p) const
Returns
the range of iterator (begin,end) over the internal element on processor p

References invalid_uint16_type_value.

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_FACES>, typename MeshTraits<MeshType>::location_face_const_iterator, typename MeshTraits<MeshType>::location_face_const_iterator> Feel::internalfaces ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over all internal faces of the mesh belong to process domain __pid
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_POINTS>, typename MeshTraits<MeshType>::location_point_const_iterator, typename MeshTraits<MeshType>::location_point_const_iterator> Feel::internalpoints ( MeshType const &  mesh)
Returns
the range of iterators [begin,end] over the internal(not on the boundary) points of the mesh
Warning
this filter is not parallelized
template<typename SpaceType , typename FunctionType >
void Feel::interpolate ( boost::shared_ptr< SpaceType > const &  space,
FunctionType const &  f,
typename SpaceType::element_type &  interp,
int  same_mesh = INTERPOLATE_DIFFERENT_MESH 
)

Given a space space using a lagrange basis, compute the interpolation interp of f belonging to another function space.

FunctionSpace<mesh_type,fusion::vector<Whatever> > Yh;
FunctionSpace<mesh_type,fusion::vector<Whatever> >::element_type f;
FunctionSpace<mesh_type,fusion::vector<Lagrange<> > > Xh;
FunctionSpace<mesh_type,fusion::vector<Lagrange<> > >::element_type u;
interpolate( Xh, f, u );
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_FACES>, typename MeshTraits<MeshType>::interprocess_face_const_iterator, typename MeshTraits<MeshType>::interprocess_face_const_iterator> Feel::interprocessfaces ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over all interprocess faces of the mesh belonging to process __pid
virtual bool Feel::isEmpty ( ) const
virtual
Returns
true if the container is empty, false otherwise
Feel::po::options_description Feel::makeOptions ( )
inline

This routine returns the list of options using the boost::program_options library. The data returned is typically used as an argument of a Feel::Application subclass.

Returns
the list of options
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::marker2_element_const_iterator, typename MeshTraits<MeshType>::marker2_element_const_iterator> Feel::marked2elements ( MeshType const &  mesh,
flag_type  flag 
)
Returns
a pair of iterators to iterate over elements of the mesh with Marker2 flag
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::marker2_element_const_iterator, typename MeshTraits<MeshType>::marker2_element_const_iterator> Feel::marked2elements ( MeshType const &  mesh,
std::string const &  flag 
)
Returns
a pair of iterators to iterate over elements of the mesh with Marker2 string

References marked2elements().

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::marker3_element_const_iterator, typename MeshTraits<MeshType>::marker3_element_const_iterator> Feel::marked3elements ( MeshType const &  mesh,
flag_type  flag 
)
Returns
a pair of iterators to iterate over elements of the mesh with Marker3 flag
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::marker3_element_const_iterator, typename MeshTraits<MeshType>::marker3_element_const_iterator> Feel::marked3elements ( MeshType const &  mesh,
std::string const &  flag 
)
Returns
a pair of iterators to iterate over elements of the mesh with Marker3 string

References marked3elements().

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_EDGES>, typename MeshTraits<MeshType>::marker_edge_const_iterator, typename MeshTraits<MeshType>::marker_edge_const_iterator> Feel::markededges ( MeshType const &  mesh,
flag_type  __marker 
)
Returns
a pair of iterators to iterate over edges of the mesh marked with __marker
Parameters
mesha mesh data structure
__markera marker that identifies edges
__pidprocess id
Returns
a pair of iterators (begin,end) for the set of marked edges
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::marker_element_const_iterator, typename MeshTraits<MeshType>::marker_element_const_iterator> Feel::markedelements ( MeshType const &  mesh,
std::string const &  flag 
)
Returns
a pair of iterators to iterate over elements of the mesh with marker flag
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_ELEMENTS>, typename MeshTraits<MeshType>::marker_element_const_iterator, typename MeshTraits<MeshType>::marker_element_const_iterator> Feel::markedelements ( MeshType const &  mesh,
const char *  flag 
)
Returns
a pair of iterators to iterate over elements of the mesh with marker flag

References markedelements().

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_FACES>, typename MeshTraits<MeshType>::marker_face_const_iterator, typename MeshTraits<MeshType>::marker_face_const_iterator> Feel::markedfaces ( MeshType const &  mesh)
Returns
a pair of iterators to iterate over faces of the mesh marked
Parameters
mesha mesh data structure
__pidprocess id
Returns
a pair of iterators (begin,end) for the set of marked faces
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_FACES>, typename MeshTraits<MeshType>::marker_face_const_iterator, typename MeshTraits<MeshType>::marker_face_const_iterator> Feel::markedfaces ( MeshType const &  mesh,
std::string const &  __marker 
)
Returns
a pair of iterators to iterate over faces of the mesh marked with __marker
Parameters
mesha mesh data structure
__markera marker that identifies faces
__pidprocess id
Returns
a pair of iterators (begin,end) for the set of marked faces

References markedfaces().

template<typename MeshType >
boost::tuple<mpl::size_t<MESH_POINTS>, typename MeshTraits<MeshType>::marker_point_const_iterator, typename MeshTraits<MeshType>::marker_point_const_iterator> Feel::markedpoints ( MeshType const &  mesh,
size_type  flag 
)
Returns
the range of iterators [begin,end] over the marked points with flag of the mesh
Warning
this filter is not parallelized
po::options_description Feel::material_options ( std::string const &  prefix)
Returns
the command lines options of the material library
template<typename MT , typename Iterator >
size_type Feel::nelements ( boost::tuple< MT, Iterator, Iterator > const &  its,
bool  global = false 
)
Returns
the number of elements given element iterators constructed using the mesh filters
Parameters
itsthe mesh iterators
globalall reduce number of elements if set to true

The following code prints in the logfile the number of elements in the mesh that are marked with marker1 equal to 1:

LOG(INFO) << "number of elements = " << nelements( markedelements(mesh,1) ) << "\n";
template<typename MT , typename Iterator >
size_type Feel::nelements ( std::list< boost::tuple< MT, Iterator, Iterator > > const &  its,
bool  global = false 
)
Returns
the number of elements given element iterators constructed using the mesh filters
Parameters
alist of mesh iterators
globalall reduce number of elements if set to true

The following code prints in the logfile the number of elements in the mesh that are marked with marker1 equal to 1:

LOG(INFO) << "number of elements = " << nelements( markedelements(mesh,{1,2,3}) ) << "\n";
po::options_description Feel::nlsolver_options ( )
Returns
the command lines options of the petsc backend

command line options for non linear solver

std::ostream& Feel::operator<< ( std::ostream &  os,
AboutData const &  about 
)

outpout stream an AboutData structure

Parameters
osostream to use to stream the about data
aboutdata to stream
Returns
the ostream
Elements& Feel::operator= ( Elements const &  e)

copy operator

template<typename space_type >
boost::shared_ptr< OperatorSteklovPc<space_type> > Feel::operatorSteklPc ( boost::shared_ptr< space_type > const &  space,
typename OperatorSteklovPc< space_type >::backend_ptrtype const &  backend = Backend<double>::build( BACKEND_PETSC ) 
)

this function returns a OperatorSteklovPc shared_ptr with

Parameters
pace
backend
template<typename self_type >
boost::shared_ptr< OperatorTrace<self_type> > Feel::operatorTrace ( boost::shared_ptr< self_type > const &  domainspace)

this function returns a OperatorTrace shared_ptr with

Parameters
traceSpace
template<typename space_type >
boost::shared_ptr<OperatorLagrangeP1<space_type> > Feel::opLagrangeP1_impl ( boost::shared_ptr< space_type > const &  Xh,
typename OperatorLagrangeP1< space_type >::backend_ptrtype const &  backend,
std::vector< WorldComm > const &  worldsComm,
std::string  pathMeshLagP1,
std::string  prefix,
bool  rebuild,
bool  parallel 
)
Returns
the P1 Lagrange adaptor associated to the space Xh
po::options_description Feel::opusapp_options ( std::string const &  prefix)
Returns
the command lines options of the petsc backend
po::options_description Feel::oseen_options ( std::string const &  prefix,
OseenDefaults  defaults 
)
Returns
the command lines options of the oseen solver
po::options_description Feel::pfemapp_options ( std::string const &  prefix)
Returns
the command lines options of the petsc backend
template<typename MeshType >
boost::tuple<mpl::size_t<MESH_POINTS>, typename MeshTraits<MeshType>::point_const_iterator, typename MeshTraits<MeshType>::point_const_iterator> Feel::points ( MeshType const &  mesh)
Returns
the range of iterators [begin,end] over the points of the mesh
Warning
this filter is not parallelized
template<typename Pset , typename Func , typename IM >
Polynomial<Pset, Scalar> Feel::project ( Pset const &  pset,
Func const &  f,
IM const &  im 
)

$ L_2$ Projection over the associated convex of a function f onto a scalar polynomial set.

Returns
the polynomial with the same basis as the polynomial set and with coeff $ \sum_q w_q f_q \phi_q $
template<typename TDomainSpace , typename TDualImageSpace >
boost::shared_ptr< Projector<TDomainSpace, TDualImageSpace> > Feel::projector ( boost::shared_ptr< TDomainSpace > const &  domainspace,
boost::shared_ptr< TDualImageSpace > const &  imagespace,
typename Projector< TDomainSpace, TDualImageSpace >::backend_ptrtype const &  backend = Backend<double>::build( BACKEND_PETSC ),
ProjectorType  proj_type = L2,
double  epsilon = 0.01,
double  gamma = 20,
DirichletType  dirichlet_type = WEAK 
)

this function returns a Projector shared_ptr with

Parameters
domainSpace
imageSpace
backend
po::options_description Feel::solvereigen_options ( std::string const &  prefix = "")

defines solver eigen options

The prefix parameter allows to set different eigensolver options for different eigensolver. It allows to distinguish between these options

// register two slepc eigensolver options
add_options( solvereigen_options( "eigen1" ) ).add_options( solvereigen_options( "eigen2" ));
// build an eigen solver associated with option set eigen1
Parameters
prefixprefix allows to prefix options
template<typename MatrixType >
void Feel::spy ( MatrixType const &  __m,
std::string const &  filename 
)

Dump vector to file in Matlab format and spy

template<int Ngeo = 1>
boost::shared_ptr<Mesh<Simplex<2,Ngeo> > > Feel::unitCircle ( double  h = option(_name="gmsh.hsize").template as<double>())
inline

build a mesh of the unit circle using triangles

boost::shared_ptr<Mesh<Simplex<3> > > Feel::unitCube ( double  h = option(_name="gmsh.hsize").as< double >())

build a mesh of the unit square [0,1]^3 using tetrahedrons

template<typename P , template< uint16_type > class Type, template< class, template< uint16_type > class > class Poly1, template< class, template< uint16_type > class > class Poly2>
PolynomialSet<P, Type> Feel::unite ( Poly1< P, Type > const &  pset1,
Poly2< P, Type > const &  pset2 
)

union of two polynomial sets P1 and P2 : $ P_1 \oplus P_2$

Returns
the union of the two sets by appending the coefficient and computing the range of the resulting set

References project(), Feel::SVD< MatrixA >::S(), Feel::Vector< T >::size(), and Feel::SVD< MatrixA >::V().

detail boost::shared_ptr<Mesh<Simplex<1> > > Feel::unitSegment ( double  h = option(_name="gmsh.hsize").as< double >())

build a mesh of the unit segment [0,1]

template<int Ngeo = 1>
boost::shared_ptr<Mesh<Simplex<3,Ngeo> > > Feel::unitSphere ( double  h = option(_name="gmsh.hsize").template as<double>())
inline

build a mesh of the unit circle using triangles

boost::shared_ptr<Mesh<Simplex<2> > > Feel::unitSquare ( double  h = option(_name="gmsh.hsize").as< double >())

build a mesh of the unit square [0,1]^2 using triangles

void Feel::updateMarkersFromFaces ( )

update the elements markers by setting them from the face markers associated to the elements warning the marker2 and marker3 must be > 0. if 2 several markers are find in elt, the element take the last find as marker

Variable Documentation

const size_type Feel::EXTRACTION_KEEP_ALL_IDS
Initial value:
= ( EXTRACTION_KEEP_POINTS_IDS |
EXTRACTION_KEEP_EDGES_IDS |
EXTRACTION_KEEP_FACES_IDS |
EXTRACTION_KEEP_VOLUMES_IDS )
const dim_type Feel::invalid_dim_type_value = dim_type( -1 )

Invalid dim type value

const size_type Feel::invalid_size_type_value = size_type( -1 )

Invalid size type value

const uint16_type Feel::invalid_uint16_type_value = uint16_type( -1 )

Invalid uint16_type value

const uint32_type Feel::invalid_uint32_type_value = uint32_type( -1 )

Invalid uint32_type value

const uint64_type Feel::invalid_uint64_type_value = uint64_type( -1 )

Invalid uint64_type value

const uint8_type Feel::invalid_uint8_type_value = uint8_type( -1 )

Invalid uint8_type value


Generated on Fri Oct 25 2013 14:24:28 for Feel++ by doxygen 1.8.4