 |
COOLFluiD
Release kernel
COOLFluiD is a Collaborative Simulation Environment (CSE) focused on complex MultiPhysics simulations.
|
|
COOLFluiD
Release kernel
COOLFluiD is a Collaborative Simulation Environment (CSE) focused on complex MultiPhysics simulations.
|
| ►Natest-ufem-navier-stokes-restart | |
| CTaylorGreen | |
| ►Natest-ufem-navier-stokes-taylor-green | |
| CTaylorGreen | |
| ►Nboost | External boost library namespace |
| Citerator_range | |
| ►Ncf3 | Top-level namespace for coolfluid |
| ►NBlockMeshReader | |
| CBlockData | Helper struct to read the data into vectors |
| CBlockMeshReader | |
| CLibBlockMeshReader | |
| ►NCGAL | Classes for CGAL mesh format operations |
| CImplicitFunction | |
| CLibCGAL | |
| CMeshParameters | Parameters for mesh generation, as defined in the CGAL manual |
| CSphereFunction | Sphere around the origin with radius r |
| CTetrahedralize | |
| ►Ncommon | Most basic kernel library |
| ►Ndetail | |
| CArrayToVector | A struct, since partial specializations of functions is not allowed |
| CArrayToVector< Handle< ComponentT > > | |
| CChangeArrayValue | Helper function to set the value |
| CChangeArrayValue< Handle< ComponentT > > | |
| CChangeArrayValue< int > | |
| CChangeArrayValue< Real > | |
| CChangeArrayValue< Uint > | |
| CDoArrayDiff | |
| CFromString | A struct, since partial specializations of functions is not allowed |
| CFromString< Handle< ComponentT > > | |
| CValue | |
| CValue< Handle< ComponentT > > | |
| ►NLinux | Specialized classes for interacting with Linux operating system |
| COSystemLayer | |
| ►NMacOSX | Specialized classes for interacting with Mac OSX operating system |
| COSystemLayer | |
| ►NPE | Classes offering a MPI interface for COOLFluiD |
| CBuffer | Buffer that can hold multiple data types, useful for MPI communication |
| CComm | |
| ►CCommPattern | |
| Cdist_struct | Helper struct for setup function |
| Ctemp_buffer_item | Typedef for the temporary buffer |
| CCommWrapper | Base wrapper class serving as interface |
| CCommWrapperMArray | Wrapper class for Table components |
| CCommWrapperMArray< T, 1 > | |
| CCommWrapperMArray< T, 2 > | |
| CCommWrapperPtr | Wrapper class for raw ptr arrays allocated by new[]/malloc/calloc |
| CCommWrapperVector | Wrapper class for std::vectors |
| CCommWrapperView | |
| Cget_mpi_op | ACCESS AND REGISTRATION MECHANISM |
| Cget_mpi_op< T, bitwise_and, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, bitwise_or, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, bitwise_xor, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, logical_and, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, logical_or, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, logical_xor, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, max, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, min, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, multiplies, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| Cget_mpi_op< T, plus, typename boost::enable_if< boost::is_arithmetic< T > >::type > | |
| CListeningInfo | Holds MPI listening information |
| CListeningThread | Listener for MPI messages |
| CManager | |
| CPackedObject | |
| CWorkerGroup | |
| ►NWin32 | Specialized classes for interacting with Win32 operating system |
| CLibLoader | Class to load libraries in the Win32 OS |
| COSystemLayer | |
| ►NXML | Classes that implement the XML protocol for use in COOLFluiD |
| CMap | |
| ►CProtocol | |
| CTags | |
| CSignalFrame | Manages a set of maps |
| CSignalOptions | Abstracts the use of XML when adding options to a signal frame |
| CXmlDoc | |
| CXmlNode | |
| CAction | Component that executes an action. Implementation of the IAction interface as a component, exposing the execute function as a signal |
| CActionDirector | |
| CAllocatedComponent | |
| CArrayBase | |
| ►CArrayBufferT | A Buffer that is constructed passing a boost::multi_array<T,2> table. This class allows to interface this table by using a buffer |
| CBuffer | |
| CArrayDiff | |
| CAssertionManager | Manager of behavior of assertions |
| CBadPointer | |
| CBadValue | |
| ►CBinaryDataReader | Component for writing binary data collected into a single file |
| CImplementation | |
| ►CBinaryDataWriter | Component for writing binary data collected into a single file |
| CImplementation | |
| CBuilder | Component that builds other components |
| CBuilderT | Component that builds other components of a given abstract type This is the actual builder for one concrete type |
| CBuildInfo | |
| CCAbstract | |
| CCastingFailed | |
| CCConcrete1 | |
| CCConcrete2 | |
| CCodeLocation | |
| CCodeProfiler | |
| CComponent | Base class for defining CF components |
| CComponentBuilder | Helper class to create the Builder and place it in the factory |
| CComponentHandle | Handle to ComponentT, constness determined by the constness of ParentT |
| CComponentIterator | ComponentIterator class, can linearize a complete tree of components |
| CComponentIteratorRange | |
| ►CComponentIteratorRangeSelector | Derive the correct range type based on the constness of ParentT, which should be the type of the parent component |
| Cimpl | |
| Cimpl< boost::false_type, dummy > | |
| Cimpl< boost::true_type, dummy > | |
| CComponentIteratorSelector | Derive the correct range type based on the constness of ParentT, which should be the type of the parent component |
| CComponentPtr | Shared pointer to ComponentT, constness determined by the constness of ParentT |
| CComponentReference | Reference to ComponentT, constness determined by the constness of ParentT |
| CConnection | |
| CConnectionManager | |
| CConstComponentIteratorRange | |
| CCore | |
| ►CDynArrayBufferT | |
| CBuffer | |
| CDynTable | |
| CEnumT | |
| CEnvironment | |
| CEventHandler | |
| CException | Base class for all Exceptions in CF |
| CExceptionManager | Manager of behavior of exceptions |
| CFactories | |
| CFactory | Component class for a factory which builds other components |
| CFactoryT | Component class for a factory which builds other components |
| CFailedAssertion | |
| CFailedToConverge | |
| CFileFormatError | |
| CFileSystemError | |
| CFloatingPointError | |
| CGroup | Component for grouping other components |
| CIAction | Abstract interface for actions. You probably want to use Action as a base to start from, since that implements IAction as a component |
| CIllegalCall | |
| CInvalidStructure | |
| CInvalidURI | Exception thrown when a string does not construct a valid path |
| Cis_connection | |
| Cis_signal | |
| CIsBuilderReducedName | Checks the builder reduced name matches The reduced name is the name without the namespace preceding it |
| CIsComponentName | |
| CIsComponentTag | |
| CIsComponentTrue | |
| CIsComponentType | |
| CJournal | |
| CLibCommon | |
| CLibLoader | |
| CLibLoadingError | Not deriving from common::Exception to avoid the automatic error output |
| CLibraries | |
| CLibrary | Component class for a library |
| CLink | |
| CList | Component holding a 1 dimensional array of a templated type |
| CListBufferIterator | |
| ►CListBufferT | A Buffer that is constructed passing a boost::multi_array<T,2> table. This class allows to interface this table by using a buffer |
| CBuffer | |
| CLocalDispatcher | Dispatches a signal locally |
| CLogger | Main class of the logging system |
| CLogLevelFilter | Filters log messages corresponding to their level |
| CLogStampFilter | Prepends a stamp to the log messages |
| CLogStream | Manages a log stream |
| CLogStringForwarder | |
| ►CMap | |
| CCompare | |
| CLessThan | |
| CNetworkInfo | |
| CNoProfiling | |
| CNotEnoughMemory | |
| CNotificationQueue | Manages a notification queue |
| CNotImplemented | |
| CNotSupported | |
| COption | Adds fonctionnalities to Property class |
| COptionArray | |
| COptionArrayBuilder | |
| COptionBuilder | Interface for option builders that can be registered with the factory |
| ►COptionComponent | |
| CValueExtractor | MPL functor to extract a value from an any |
| COptionComponentArrayBuilder | Builder for OptionArrays of this component |
| COptionComponentBuilder | Builder for OptionComponents |
| COptionFactory | Factory class to buikd options dynamically |
| COptionList | |
| COptionT | |
| COptionTBuilder | Builders for OptionT components |
| COptionURI | |
| COptionURIBuilder | |
| COSystem | |
| COSystemError | |
| COSystemLayer | |
| CParallelError | |
| CParsingFailed | |
| CPosixDlopenLibLoader | |
| CPrintTimingTree | Prints the timing tree for a root component |
| CPropertyList | |
| CProtocolError | |
| CRegisterComponent | Helper class to register typeinfo and option type of a component This is mostly useful for abstract component classes, as builders cannot be created for this |
| CRegisterOptionBuilder | Helper class to register builders |
| CRegistLibrary | Struct to force library registration |
| CRegistTypeInfo | |
| CSegmentationFault | |
| CSelectComponentWrapper | Helper struct to select the correct wrapper for a component |
| CSelectOptionType | |
| CSelectOptionType< char const * > | |
| CSelectOptionType< char[N] > | Allow string constants without enclosing them in std::string() |
| CSelectOptionType< Handle< T > > | Specialization for components |
| CSelectOptionType< std::vector< T > > | Specialization for arrays |
| CSelectOptionType< URI > | Specialization for URI |
| CSetupError | |
| CShouldNotBeHere | |
| CSignal | |
| CSignalDispatcher | API to dispatch a signal call |
| CSignalError | |
| CSignalHandler | |
| CStringConverter | Prevent a crash in the intel compiler |
| CTable | Component holding a 2 dimensional array of a templated type |
| CTableArray | |
| CTableConstRow | |
| CTableRow | |
| CTaggedObject | Manages tags |
| CTags | |
| CTimedComponent | Pure virtual interface for components that store timings |
| CTypeInfo | Handles type information This struct allows to associate a type to a string. It is a singleton |
| ►CURI | |
| ►CScheme | |
| CConvert | |
| CURLError | |
| CUUCount | Combination of a UUID and a count, together forming the equivalent of a 192-bit identifier |
| CValueExists | |
| CValueNotFound | |
| ►CWorkerStatus | |
| CConvert | |
| CXmlError | |
| ►Ndetail | |
| Cis_const_comptible | Helper struct to put const-correctness in a short expression |
| ►Nmath | Basic Classes for Mathematical applications used by COOLFluiD |
| ►NLSS | |
| ►Ndetail | |
| CAddNewParameter | |
| CAddParameter | |
| CGidConverter | |
| CUpdateParameterValue | |
| CBelosGMRESParameters | Encapsulate a Teuchos parameter list |
| CBlockAccumulator | |
| CCoordinatesStrategy | |
| ►CDirectStrategy | |
| CImplementation | |
| CEmptyLSSMatrix | |
| CEmptyLSSVector | |
| CEmptyStrategy | |
| CLibLSS | Class defines the initialization and termination of the library LSS |
| CMatrix | |
| CParameterList | Encapsulate a Teuchos parameter list |
| CParameterListDefaults | Encapsulate a Teuchos parameter list |
| ►CRCGStrategy | |
| CImplementation | |
| CSolutionStrategy | |
| CSolveLSS | |
| CSystem | |
| CThyraOperator | Abstract class for all Trilinos matrix operators |
| CThyraVector | Abstract class for all Trilinos matrix operators |
| CTrilinosCrsMatrix | |
| CTrilinosFEVbrMatrix | |
| ►CTrilinosStratimikosStrategy | |
| CImplementation | |
| CTrilinosVector | |
| CVector | |
| CZeroLSS | |
| CAnalyticalFunction | |
| CBoundingBox | Bounding box defined by minimum and maximum coordinates |
| CBracketMethod | |
| CBrent | |
| CDbrent | |
| CFloatingPoint | |
| CGolden | |
| CHilbert | Class to compute a global index given a coordinate, based on the Hilbert Spacefilling Curve |
| CIntegrate | |
| CLibMath | |
| COutOfBounds | Exception thrown when a certain value is not found in a storage or container |
| CVariableManager | |
| ►CVariablesDescriptor | |
| ►CDimensionalities | |
| CConvert | |
| CImplementation | |
| CVectorialFunction | |
| CZeroDeterminant | Exception thrown when a Zero determinant matrix is found |
| ►Nmesh | Basic Classes for Mesh applications used by COOLFluiD |
| ►Nactions | Action derived classes for mesh manipulations |
| ►Ndetail | |
| CDoDiff | |
| CWallProjection | Helper struct to handle projection to the wall near a given surface node |
| CAddPointRegion | |
| CBuildArea | |
| CBuildFaceNormals | |
| CBuildFaces | |
| CBuildVolume | |
| CComputeFieldGradient | Compute the gradient of a field |
| CCreateField | Create a field with given functions |
| CExtract | |
| CFaceCompare | |
| CGlobalConnectivity | |
| CGlobalNumbering | Create a global number for nodes and elements of the mesh |
| CGlobalNumberingElements | Create a global number for nodes and elements of the mesh |
| CGlobalNumberingNodes | Create a global number for nodes and elements of the mesh |
| CGrowOverlap | Grow the overlap of the mesh with one layer |
| CImportVariables | Import variables from another mesh |
| CInfo | |
| CInitFieldConstant | |
| CInitFieldFunction | Initialize a field with given functions |
| CInterpolate | Interpolate Fields with matching support |
| CIsElementRegion | |
| CIsGroup | |
| CLibActions | Class defines the initialization and termination of the library actions |
| CLinkPeriodicNodes | |
| CLoadBalance | Load Balance the mesh |
| CMakeBoundaryGlobal | |
| CMeshDiff | |
| CMeshInterpolator | |
| CPeriodicMeshPartitioner | |
| CRemoveGhostElements | |
| CRotate | |
| CShortestEdge | |
| CSurfaceIntegral | SurfaceIntegral Fields with matching support |
| CTranslate | |
| CVolumeIntegral | VolumeIntegral Fields with matching support |
| CWallDistance | |
| ►NBlockMesh | Library for I/O of the OpenFOAM BlockMesh dict files |
| ►CBlockArrays | |
| ►CImplementation | |
| CBlock | Encapsulate a single block, providing all data needed to produce the mesh connectivity |
| CBlockLayer | Represents a single layer across the mesh |
| CPatch | |
| CBlocksPartitioning | Helper struct to keep using the old partitioning method |
| CChannelGenerator | Generate parallel 3D channels with grading towards the wall |
| CLibBlockMesh | |
| ►Ncf3mesh | Library for I/O in the native CF3 mesh format |
| CLibCF3Mesh | |
| CReader | |
| CWriter | |
| ►NCGNS | Library for I/O of the CGNS format |
| CCGNSException | |
| CLibCGNS | |
| CReader | |
| ►CShared | |
| CCGNS_Base | |
| CCGNS_Boco | |
| CCGNS_Field | |
| CCGNS_File | |
| CCGNS_FlowSolution | |
| CCGNS_Section | |
| CCGNS_Size | |
| CCGNS_Zone | |
| CWriter | |
| ►Ndetail | |
| CComputeCentroid | Helper to compute the centroid |
| ►Ngausslegendre | Namespace holding GaussLegendre quadrature |
| ►CHexa | |
| CGaussLegendreQuadrature | |
| CHexa_traits | |
| CLibGaussLegendre | |
| ►CLine | |
| CGaussLegendreQuadrature | |
| CLine_traits | |
| ►CQuad | |
| CGaussLegendreQuadrature | |
| CQuad_traits | |
| ►Ngmsh | Library for I/O of the gmsh format |
| CLibGmsh | |
| ►CReader | |
| CField | |
| CRegionData | |
| CShared | |
| CWriter | |
| ►NIntegrators | Functions to provide integration over elements |
| CGaussIntegrator | |
| CGaussMappedCoords | Stores pre-computed mapped coords and weights for all gauss point locations |
| CGaussMappedCoordsImpl | Access to matrices with the mapped coords |
| CGaussMappedCoordsImpl< 1, GeoShape::HEXA > | |
| CGaussMappedCoordsImpl< 1, GeoShape::LINE > | |
| CGaussMappedCoordsImpl< 1, GeoShape::PRISM > | |
| CGaussMappedCoordsImpl< 1, GeoShape::QUAD > | |
| CGaussMappedCoordsImpl< 1, GeoShape::TETRA > | |
| CGaussMappedCoordsImpl< 1, GeoShape::TRIAG > | |
| CGaussMappedCoordsImpl< 2, GeoShape::PRISM > | |
| CGaussMappedCoordsImpl< 2, GeoShape::TETRA > | |
| CGaussMappedCoordsImpl< 2, GeoShape::TRIAG > | |
| CGaussMappedCoordsImpl< 3, GeoShape::TRIAG > | |
| CGaussMappedCoordsImpl< 4, GeoShape::TRIAG > | |
| CGaussMappedCoordsImpl< 5, GeoShape::TRIAG > | |
| CGaussMappedCoordsImpl< 777, GeoShape::LINE > | Trapezium rule integration. Uses the end points of the line |
| CGaussMappedCoordsImpl< Order, GeoShape::HEXA > | |
| CGaussMappedCoordsImpl< Order, GeoShape::LINE > | |
| CGaussMappedCoordsImpl< Order, GeoShape::QUAD > | |
| CGaussPoints | This file hides some implementation details of Gauss integration |
| CGaussPoints< 16 > | |
| CGaussPoints< 2 > | |
| CGaussPoints< 32 > | |
| CGaussPoints< 4 > | |
| CGaussPoints< 8 > | |
| ►NLagrangeP0 | Namespace holding LagrangeP0 shape functions and elements |
| CHexa | |
| CHexa_traits | |
| CLibLagrangeP0 | |
| CLine | |
| CLine_traits | |
| CPoint | |
| CPoint1D | 1D Lagrange P0 Point Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P0 (constant) point element |
| CPoint1D_traits | |
| CPoint2D | 2D Lagrange P0 Point Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P0 (constant) point element |
| CPoint2D_traits | |
| CPoint3D | 3D Lagrange P0 Point Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P0 (constant) point element |
| CPoint3D_traits | |
| CPoint_traits | |
| CPrism | |
| CPrism_traits | |
| CQuad | |
| CQuad_traits | |
| CTetra | |
| CTetra_traits | |
| CTriag | |
| CTriag_traits | |
| ►NLagrangeP1 | Namespace holding LagrangeP1 shape functions and elements |
| CElementTypeTriag2D | |
| CHexa | |
| CHexa3D | 2D Lagrange P1 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CHexa3D_traits | |
| CHexa_traits | |
| CLibLagrangeP1 | |
| CLine | |
| CLine1D | Lagrange P1 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CLine1D_traits | |
| CLine2D | Lagrange P1 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CLine2D_traits | |
| CLine3D | Lagrange P1 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CLine3D_traits | |
| CLine_traits | |
| CPoint | |
| CPoint_traits | |
| CPrism | |
| CPrism3D | 3D Lagrange P1 Triangular Prism Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CPrism3D_traits | |
| CPrism_traits | |
| CQuad | |
| ►CQuad2D | 2D Lagrange P1 Quadrilateral Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) quadrilateral element |
| CJacobianCoefficients | Convenience struct to easily access the elements that make up the jacobian |
| CQuad2D_traits | |
| ►CQuad3D | 2D Lagrange P1 Quadrilateral Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) quadrilateral element |
| CJacobianCoefficients | Convenience struct to easily access the elements that make up the jacobian |
| CQuad3D_traits | |
| CQuad_traits | |
| CTetra | |
| CTetra3D | 2D Lagrange P1 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CTetra3D_traits | |
| CTetra_traits | |
| CTriag | |
| CTriag2D | 2D Lagrange P1 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CTriag2D_traits | |
| CTriag3D | 3D Lagrange P1 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CTriag3D_traits | |
| CTriag_traits | |
| ►NLagrangeP2 | Namespace holding LagrangeP2 shape functions and elements |
| CLibLagrangeP2 | |
| CLine | |
| CLine1D | Lagrange P2 line (1D) Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P1 (linear) triangular element |
| CLine1D_traits | |
| CLine2D | Lagrange P2 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P2 (linear) triangular element |
| CLine2D_traits | |
| CLine_traits | |
| CPoint | |
| CPoint_traits | |
| CQuad | |
| CQuad2D | 2D Lagrange P2 Quadrilateral Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P2 (linear) quadrilateral element |
| CQuad2D_traits | |
| ►CQuad3D | 2D Lagrange P2 Quadrilateral Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P2 (bilinear) quadrilateral element.k |
| CJacobianCoefficients | Convenience struct to easily access the elements that make up the jacobian |
| CQuad3D_traits | |
| CQuad_traits | |
| CTriag | |
| CTriag2D | 2D Lagrange P2 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P2 (linear) triangular element |
| CTriag2D_traits | |
| CTriag_traits | |
| ►NLagrangeP2B | Namespace holding LagrangeP2B shape functions and elements |
| CLibLagrangeP2B | |
| CTriag | |
| CTriag2D | 2D Lagrange P2B Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P2B (linear) triangular element |
| CTriag2D_traits | |
| CTriag_traits | |
| ►NLagrangeP3 | Namespace holding LagrangeP3 shape functions and elements |
| CLibLagrangeP3 | |
| CLine | |
| CLine2D | Lagrange P3 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P3 (linear) triangular element |
| CLine2D_traits | |
| CLine_traits | |
| CQuad | |
| CQuad2D | 2D Lagrange P3 Quadrilateral Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P3 (linear) quadrilateral element |
| CQuad2D_traits | |
| CQuad_traits | |
| CTriag | |
| CTriag2D | 2D Lagrange P3 Triangular Element type This class provides the lagrangian shape function describing the representation of the solution and/or the geometry in a P3 (linear) triangular element |
| CTriag2D_traits | |
| CTriag_traits | |
| ►Nneu | Library for I/O of the neutral format |
| CLibNeu | |
| ►CReader | |
| CBCData | |
| CGroupData | |
| CHeaderData | |
| CShared | |
| CWriter | |
| ►Nptscotch | Library for PTScotch mesh partitioning and load balancing |
| CLibPTScotch | |
| CPartitioner | |
| ►Nsmurf | Library for I/O of the smurf format |
| CLibSmurf | |
| CReader | |
| CShared | |
| CWriter | |
| ►Ntecplot | Library for I/O of the tecplot format |
| CLibTecplot | |
| CShared | |
| CWriter | |
| ►NVTKLegacy | Library for I/O of the VTK legacy format |
| CLibVTKLegacy | |
| CWriter | |
| ►NVTKXML | Library for I/O of the VTK XML format |
| ►Ndetail | |
| CCompressedStream | |
| CCompressedStreamHeader | |
| CLibVTKXML | |
| CWriter | |
| ►Nzoltan | Library for zoltan mesh partitioning and load balancing |
| CLibZoltan | |
| CPartitioner | |
| CAInterpolator | A Interpolator base component |
| CAPointInterpolator | PointInterpolator to interpolate a field to a point |
| CBoundingBox | Wrapped math::BoundingBox, with extra functionality |
| CCellFaces | |
| CCells | |
| CConnectivity | |
| CContinuousDictionary | |
| CDerivativeInPoint | |
| CDictionary | |
| CDiscontinuousDictionary | |
| ►CDomain | |
| CImplementation | |
| CEdges | |
| CElementFinder | Base class for finding an element given a coordinate |
| CElementFinderOcttree | Find elements using an octtree |
| CElementNodeView | View of nodal data, allowing modification of the referenced data |
| CElementNodeView< NbNodes, 1, 1 > | Specialization for single Real values |
| CElements | |
| CElementType | |
| CElementTypeBase | Fallback class if a concrete Element Type doesn't implement a static function |
| CElementTypeFaceConnectivity | Stores connectivity information about the faces that form the cell boundary |
| CElementTypeT | Translation class to link concrete static implementations to the dynamic API |
| CEntities | |
| CEntity | Low storage struct to uniquely identify one element |
| CFace2Cell | |
| CFaceCellConnectivity | |
| CFaceConnectivity | |
| CFaces | |
| CField | |
| ►CFieldManager | |
| CImplementation | |
| CGenerateLine3D | |
| CGeneratePlane3D | |
| ►CGeoShape | |
| CConvert | |
| CInterpolateInPoint | |
| CInterpolationFunction | |
| CInterpolator | Interpolator component delegating interpolation to a PointInterpolator strategy |
| CInterpolatorT | Compile-time configured strategy for interpolation |
| ►CIsCellType | Compile-time predicate to determine if the given shape function represents a volume element, i.e. dimensions == dimensionality |
| Capply | |
| ►CIsCompatibleWith | |
| Capply | |
| ►CIsEdgeType | Compile-time predicate to determine if the given shape function represents a volume element, i.e. dimensions == dimensionality |
| Capply | |
| CIsElementsSurface | |
| CIsElementsVolume | |
| CIsElementType | |
| ►CIsFaceType | Compile-time predicate to determine if the given shape function represents a volume element, i.e. dimensions == dimensionality |
| Capply | |
| ►CIsMinimalOrder | Compile-time predicate to determine if the given shape function or element type has at least the given order |
| Capply | |
| CLibMesh | |
| CLoadMesh | |
| CMatchedMeshInterpolator | Interpolator component that interpolates fields between spaces in the same mesh |
| CMergedParallelDistribution | |
| CMesh | |
| CMeshAdaptor | Class to adapt the mesh |
| CMeshElements | |
| CMeshGenerator | |
| CMeshMetadata | Storage for metadata related to the mesh |
| CMeshPartitioner | |
| CMeshReader | |
| CMeshTransformer | |
| CMeshTriangulator | |
| ►CMeshWriter | |
| CEntitiesFilter | Predicate to check if a Entities component is to be included |
| CRegionFilter | Predicate to check if a component directly contains any Entities component |
| CNode2FaceCellConnectivity | |
| CNodeConnectivity | |
| CNodeElementConnectivity | |
| COcttree | |
| CPackedElement | Class that contains all stand-alone global information of an element |
| CPackedNode | Class that contains all stand-alone global information of point in a dictionary |
| CParallelDistribution | |
| CPointInterpolator | A general configurable point interpolator |
| CPointInterpolatorT | A compile-time configured point interpolator, making sure that element-finder, stencil computer, and interpolation function match together |
| CPseudoLaplacianLinearInterpolation | Pseudo-Laplacian Weighted Linear Interpolation function |
| CQuadrature | |
| CQuadratureBase | Fallback class if a concrete Quadrature doesn't implement a static function |
| CQuadratureT | Translation class to link concrete static implementations to the dynamic API |
| CReconstructPoint | |
| CRegion | |
| CShapeFunction | |
| CShapeFunctionBase | Fallback class if a concrete ShapeFunction doesn't implement a static function |
| CShapeFunctionInterpolation | |
| CShapeFunctionT | Translation class to link concrete static implementations to the dynamic API |
| CSimpleMeshGenerator | Generate a simple carthesian P1 mesh without grading |
| CSpace | Space component class |
| CSpaceElem | |
| CSpaceInterpolator | Interpolator component that interpolates fields between spaces in the same mesh |
| CStencilComputer | Base class for stencil computers |
| CStencilComputerOcttree | |
| CStencilComputerOneCell | A StencilComputer returning one cell |
| CStencilComputerRings | Compute the stencil around an element, consisting of rings of neighboring cells |
| CTags | |
| CUnifiedData | |
| CWriteMesh | |
| ►Nphysics | Basic Classes for Physics applications used by CF |
| ►Neuler | Physics Euler classes |
| ►Neuler1d | |
| CData | |
| ►Neuler2d | |
| CData | |
| CLibEuler | |
| ►NLinEuler | Linearized Euler equations for sound propagation |
| CCons2D | |
| CCons3D | |
| CLibLinEuler | |
| ►CLinEuler2D | |
| CProperties | Physical properties |
| ►CLinEuler3D | |
| CProperties | Physical properties |
| ►Nlineuler | |
| ►Nlineuler2d | |
| CData | |
| ►Nnavierstokes | |
| ►Nnavierstokes1d | |
| CData | |
| ►Nnavierstokes2d | |
| CData | |
| ►NScalar | Scalar transport equations |
| CBurgers2D | |
| CDiffusion2D | |
| CLibScalar | |
| CLinearAdv1D | |
| CLinearAdv2D | |
| CLinearAdv3D | |
| CLinearAdvSys2D | |
| CRotationAdv2D | |
| ►CScalar1D | |
| CProperties | Physical properties |
| ►CScalar2D | |
| CProperties | Physical properties |
| ►CScalar3D | |
| CProperties | Physical properties |
| ►CScalarSys2D | |
| CProperties | Physical properties |
| ►CDynamicModel | |
| CImplementation | |
| CProperties | Physical properties |
| CDynamicVars | |
| CLibPhysics | |
| CMatrixTypes | |
| CPhysModel | |
| CProperties | |
| CUnaryRealOp | |
| CVariables | |
| CVariablesT | |
| ►Npython | Basic Classes for Python wrapper classes used by CF |
| CAnyListToPython | Conversion for lists |
| CAnyToPython | Conversion from any to python for basic types |
| CChildListWrapper | |
| ►CComponentWrapper | Wrapper class for components |
| CImplementation | |
| CCoreWrapper | |
| CLibPython | |
| CList | Tables can be used as python lists |
| CListMethods | Extra methods for Table |
| CMath | |
| Cmatrix_array_mapper | |
| CNetworkXPython | |
| Cnull_deleter | |
| COptionListWrapper | |
| CPropertyListWrapper | |
| CPythonListInterface | |
| CPythonListToAny | Conversion for lists |
| CPythonToAny | Conversion for basic types |
| ►CScriptEngine | Manage a python interpreter |
| CPythonDictEntry | Allow to make a tree representation of the python scope. the root of the tree is supposed to be a python dictionnary, children are simple python objects |
| CSignalWrapper | |
| CTableList | Tables can be used as python lists |
| CTableMethods | Extra methods for Table |
| CTableRowWrapper | Functions exposed to python dealing with table rows |
| CTestAllOptions | Creates an option for each type, to enable testing of python option handling |
| CTestSignals | Exposes certain signals for testing purposes |
| ►Nsolver | Basic Classes for Solver applications used by CF |
| ►Nactions | |
| ►Ndetail | |
| Cthreshold_compare | |
| ►Ndetail_twopoint | |
| Cthreshold_compare | |
| ►NProto | |
| ►Ndetail | |
| ►CGetNbNodes | Helper struct to get the number of element nodes |
| Capply | |
| Capply< boost::mpl::false_, EqDataT > | |
| Capply< boost::mpl::true_, EqDataT > | |
| CHasEvalVar | |
| CHasSubExpr | |
| CHasSubGrammar | Grammar matching expressions if they have a terminal with the index given in the template parameter |
| CMatchImplicitEval | Returns true if an interpolation op is used |
| CSafeNbNodes | Helper to get the number of LSS nodes, avoiding static divide-by-zero |
| CSafeNbNodes< 0 > | |
| CUsesVar | Grammar matching expressions if they have a terminal with the index given in the template parameter |
| ►CAddNodeData | MPL transform operator to wrap a variable in its data type |
| Capply | |
| Capply< VectorField, Dummy > | |
| ►CAddNodeValues | |
| Cimpl | |
| ►CAddNodeValuesIndex | |
| Cimpl | |
| CAssignNodalValues | Write to element nodal values |
| CBlockAccumulation | Grammar matching block accumulation expressions |
| ►CBlockAccumulator | Primitive transform to handle assignment to an LSS matrix |
| Cimpl | |
| CBlockAssignmentOp | Helper struct for assignment to a matrix or RHS |
| CBlockAssignmentOp< SystemMatrixTag, OpTagT > | |
| CBlockAssignmentOp< SystemRHSTag, OpTagT > | |
| CBlockLhsGrammar | Grammar matching the LHS of an assignment op |
| CCheckSameEtype | Check if all variables are on fields with element type ETYPE |
| CColTag | |
| CComponentWrapper | Proto-ready terminal type for wrapping a component |
| CComponentWrapperImpl | |
| ►CComputeNorm | Compute the norm of a matrix or a vector |
| Cimpl | |
| CConfigurableConstant | Refers to a configurable constant value |
| CConstantStorage | Storage for the values pointed to by a ConfigurableConstant |
| CConstantStorageType | Returns the map type used to store values of the given type |
| CCoordinatesGrammar | |
| ►CCoordinatesOp | Interpolated real-world coordinates at mapped coordinates |
| Cimpl | |
| CResultType | |
| CCoordsTerminals | Valid terminals that can represent the current node coordinates |
| CCopyNumberedVars | Copy the terminal values to a fusion list |
| CCustomSFOp | |
| ►CCustomSFOpTransform | Operation with a custom implementation |
| CChildGrammar | Catch field terminals first |
| ►Cimpl | |
| Capply | Pass the stored parameter if the result type is a reference, don't store otherwise |
| Capply< ResultT & > | Specialization for references |
| ►CChildType | |
| CDataType | Keep the type, by default |
| CDataType< Var< VarI, T > > | Convert numbered variables to their data |
| CEvaluatedChild | Helper to get the variable type at a child of an expression |
| CGetChild | |
| CGetChild< Var< I, T > > | Specialization to get the associated data |
| CResultType | Helper to get the result type |
| CResultType< boost::proto::tag::function, 10, Dummy > | Specialization for a function with 9 arguments |
| CResultType< boost::proto::tag::function, 2, Dummy > | Specialization for a function with one argument |
| CResultType< boost::proto::tag::function, 3, Dummy > | Specialization for a function with 2 arguments |
| CResultType< boost::proto::tag::function, 4, Dummy > | Specialization for a function with 3 arguments |
| CResultType< boost::proto::tag::function, 5, Dummy > | Specialization for a function with 4 arguments |
| CResultType< boost::proto::tag::function, 6, Dummy > | Specialization for a function with 5 arguments |
| CResultType< boost::proto::tag::function, 7, Dummy > | Specialization for a function with 6 arguments |
| CResultType< boost::proto::tag::function, 8, Dummy > | Specialization for a function with 7 arguments |
| CResultType< boost::proto::tag::function, 9, Dummy > | Specialization for a function with 8 arguments |
| CResultType< boost::proto::tag::terminal, 0, Dummy > | Used as a terminal, so we assume it just needs the basic context data |
| CDeepCopy | Transform to copy an expression, keeping terminals that store a value by reference unchanged (thanks to Eric Niebler) |
| CDefaultFunctions | All possible default-evaluated functions |
| CDefineType | Transform that extracts the type of variable I |
| CDefineTypeOp | Ease application of DefineType as an MPL lambda expression, and strip the Var encapsulation |
| CDimensionIdxTag | Tags terminals that will be replaced with the current dimension |
| ►CDirichletBCComponentSetter | Sets a specific component of a vector |
| Cimpl | |
| CDirichletBCGrammar | Matches the proper formulation of Dirichlet BC |
| ►CDirichletBCSetter | Sets whole-variable dirichlet BC, allowing the use of a complete vector as value |
| Cimpl | |
| CDirichletBCTag | Tag for a Dirichlet BC |
| CDivOp | Evaluate the divergence |
| CEigenIndexing | Indexing into Eigen expressions |
| CEigenMath | Grammar for valid Eigen expressions, composed of primitives matching GrammarT |
| CEigenMultiplication | Handle an expression that is filtered by Eigen |
| ►CEigenPlusAssignProductEval | Evaluate A += B*C, which is a special case needed in Gauss integrator. If B or C is a scalar, it's also faster |
| ►Cimpl | |
| CLHSHelper | |
| CLHSHelper< const T & > | |
| CStoreResult | |
| CStoreResult< Eigen::Block< MatT, R, C >, Dummy > | |
| CStoreResult< Real, Dummy > | |
| ►CEigenProductEval | Evaluate the product LeftT * RightT |
| Cimpl | |
| CEigenProductType | Generalization of Eigen::ProductReturnType that also works for scalars (see specializations below) |
| CEigenProductType< Eigen::GeneralProduct< LeftT, RightT >, Real > | Scalar on the right |
| CEigenProductType< LeftT, Real > | Scalar on the right |
| CEigenProductType< Real, Eigen::GeneralProduct< LeftT, RightT > > | Scalar on the left |
| CEigenProductType< Real, Real > | Scalar - scalar |
| CEigenProductType< Real, RightT > | Scalar on the left |
| ►CElementBased | Dummy shape function type used for element-based fields |
| CSF | Mimic some shape function functionality, to avoid compile errors. Not that this is only used during the recursion on the types, and never actually used |
| ►CElementData | |
| CDataType | Return the type of the data stored for variable I (I being an Integral Constant in the boost::mpl sense) |
| CDeleteVariablesData | Delete stored per-variable data |
| CFillRhs | Set the element on each stored data item |
| CInitVariablesData | Initializes the pointers in a VariablesDataT fusion sequence |
| CPrecomputeData | Precompute variables data |
| CSetElement | Set the element on each stored data item |
| CVariableType | Return the type of the stored variable I (I being an Integral Constant in the boost::mpl sense) |
| CElementGrammar | Matches and evaluates element-wise expressions |
| CElementIntegration | |
| CElementLooper | Mpl::for_each compatible functor to loop over elements, using the correct shape function for the geometry |
| CElementLooperImpl | Helper struct to launch execution once all shape functions have been determined |
| CElementMath | |
| CElementMathBase | |
| CElementMathImplicit | |
| CElementMathImplicitIndexed | Grammar that allows looping over I and J indices |
| CElementMathIndexed | |
| CElementMatrix | Represents an element matrix |
| ►CElementMatrixBlockValue | Only get a block containing the rows for the first var and the cols for the second |
| Cimpl | |
| CElementMatrixGrammar | |
| CElementMatrixGrammarIndexed | Gets submatrices of vector variables |
| ►CElementMatrixRowsValue | Only get the rows relevant for a given variable |
| Cimpl | |
| CElementMatrixSize | Calculate the size of the element matrix |
| CElementMatrixSubBlocks | Match but don't evaluate subblock-expressions |
| CElementMatrixTerm | Match element matrix terminals |
| ►CElementMatrixValue | Get a given element matrix |
| Cimpl | |
| CElementQuadrature | |
| ►CElementQuadratureEval | |
| ►Cimpl | |
| Cevaluate_expr | Fusion functor to evaluate each child expression using the GrammarT supplied in the template argument |
| CElementQuadratureMatch | Match quadrature expressions. THese call the grouping separately, so don't trigger on indices there |
| CElementQuadratureTag | Tags a gauss-quadrature loop for the following expressions |
| CElementRHS | Reperesents element RHS vector |
| ►CElementRHSValue | Get the RHS vector |
| Cimpl | |
| CElementsExpression | |
| CElementSystemMatrix | Represents an element matrix that is used as part of the linear system |
| CElementSystemMatrixTerm | Match only element matrices that are used in a linear system |
| ►CElementValue | |
| Cimpl | |
| CElementVector | Represents an element vector |
| ►CElementVectorRowsValue | Only get the rows relevant for a given variable |
| Cimpl | |
| CElementVectorTag | |
| CElementVectorTerm | Match element matrix terminals |
| ►CElementVectorTransform | |
| Cimpl | |
| ►CElementVectorValue | Get a given element matrix |
| Cimpl | |
| CEquationVariables | Calculate if a variable is part of an equation |
| CEquationVariablesOp | Wrap IsEquationVariable as a lambda expression |
| ►CEtypeTVariableData | Data associated with field variables |
| CInterpolationImpl | Interpolation of a field |
| CInterpolationImpl< 1, Dummy > | Interpolation of a scalar field |
| CEtypeTVariableData< ElementBased< 1 >, SupportEtypeT, 1, IsEquationVar > | Data for scalar element-based fields |
| CEtypeTVariableData< ElementBased< Dim >, SupportEtypeT, Dim, IsEquationVar > | Data for element-based fields |
| CEvalMappedCoords | Transform to evalate mapped coordinates |
| CExpandDimension | Replaces dimension placeholder with state |
| CExpression | Abstract interface for classes that can hold a proto expression |
| ►CExpressionBase | Boilerplate implementation |
| CAppendTags | Functor to store the tags used by a field |
| CRegisterVariables | Functor to register variables in a physical model |
| ►CExpressionGroup | Primitive transform to evaluate a group of expressions |
| ►Cimpl | |
| Cevaluate_expr | |
| CExpressionGroupTag | Tags a terminal that triggers expression grouping |
| CExpressionProperties | Convenience struct to get easy access to the numberof variables and their type |
| CExpressionRunner | Find the concrete element type of each field variable |
| CExpressionRunner< ElementTypesT, ExprT, SupportETYPE, VariablesT, VariablesEtypesT, NbVarsT, NbVarsT > | When we recursed to the last variable, actually run the expression |
| CExprVarArity | Gets the arity (max index) for the numbered variables |
| ►CExtractDiag | Primitive transform to perform the transpose |
| Cimpl | |
| CExtractDiagTag | Terminal to indicate we want a diagonal |
| CFieldBase | Base class for field data |
| CFieldInterpolation | Interpolate a field at the current gauss point |
| CFieldSynchronizer | Helper struct to synchronize fields at the end of a loop |
| CFieldTypes | Match field types |
| CFieldVariable | |
| CFieldWidth | Get the width of a field varaible, based on the variable type |
| CFieldWidth< ScalarField, SF > | Scalars have width 1 |
| CFieldWidth< VectorField, SF > | VectorFields have the same dimension as the problem domain |
| CFilterElementField | |
| CFilterElementField< IsEqVarT, boost::mpl::void_ > | |
| CFilterEquationVars | Filter out element-based fields from the possible equation variables |
| CFilterMatrixSizes | Filter the matrix size so equation variables are the only ones left with non-zero size |
| ►CForEachDimension | Primitive transform to evaluate a group of expressions |
| Cimpl | |
| CForEachDimensionGrammar | Matches and evaluates groups of expressions matching GrammarT |
| CForEachDimensionTag | Tags a terminal that indicates that indicates the argument should be evaluated for each dimension index |
| CFunctionBase | Base class of all functions that can be evaluated using "default" C++ semantics |
| CFunctionPointer | Matches a terminal containing a function pointer |
| CGaussGrammar | |
| ►CGaussIntegral | Primitive transform that evaluates an integral using the Gauss points and returns the result as a reference to a stored matrix (or scalar) |
| CGetOrder | Helper structs |
| CGetOrder< IntegralTag< boost::mpl::int_< I > > > | |
| Cimpl | |
| CGaussOrder | Static constant for the Gauss integration order |
| ►CGaussPointEval | Transform to evaluate Gauss point access |
| Cimpl | |
| CGaussPointTag | |
| ►CGaussWeightEval | Transform to evaluate Gauss weight access |
| Cimpl | |
| CGaussWeightTag | |
| CGeometricSupport | Functions and operators associated with a geometric support |
| ►CGetCoordinates | Provide access to the geometry coordinates in case of node expressions |
| Cimpl | |
| CGetElementResultType | Dummy for non-element fields |
| CGetElementResultType< T, ElementBased< Dim > > | |
| CGetNodeIdx | |
| CGetOrder | Get the order of variable I |
| CGetOrderFromData | |
| CGetOrderFromData< DataT, boost::mpl::void_ > | |
| ►CGetRHSVector | |
| Cimpl | |
| ►CGetSolutionVector | |
| Cimpl | |
| ►CGradientOp | Evaluate the gradient |
| Cresult | |
| Cresult< This(VarT)> | |
| Cresult< This(VarT, MappedCoordsT)> | |
| CGroupGrammar | Matches and evaluates groups of expressions matching GrammarT |
| CHasIdx | Check if index I is used in the expression |
| CIdentityTag | |
| ►CIndexedNodeAssign | Modify only a single component of a field |
| Cimpl | |
| ►CIndexedNodeAssignmentCases | |
| Ccase_ | |
| Ccase_< boost::proto::tag::assign, Dummy > | |
| Ccase_< boost::proto::tag::minus_assign, Dummy > | |
| Ccase_< boost::proto::tag::plus_assign, Dummy > | |
| ►CIndexLooper | |
| ►Cimpl | |
| CEvalExpr | |
| CInnerLoop | |
| COuterLoop | |
| COuterLoop< 1, 1, Dummy > | |
| CIndexTag | Tag terminals used as index |
| CIndexType | Extract an index-type from a var |
| CIndexType< Var< I, T > > | |
| CIndexValues | Evaluate the value of both indices to the integral constants given in the template arguments |
| CIntegers | Matches integer terminals |
| CIntegralTag | Tag for an integral, wit the order provided as an MPL integral constant |
| CIntegrationOrder | Determine integration order based on the order of the shape function |
| CIntegrationOrder< 1 > | |
| CIntegrationOrder< 2 > | |
| ►CInterpolationOp | Interpolated values at mapped coordinates |
| Cimpl | |
| ►CIsEquationData | Predicate to check if data belongs to an equation variable |
| Capply | |
| Capply< boost::mpl::void_, Dummy > | |
| CIsEquationVariable | Transform to set a range with true indicating a variable that has an equation, and false for no equation |
| CIsSubCols | Match subrows |
| CIsSubMatrix | Match submatrices |
| CIsSubRows | Match subrows |
| CIsVectorSubRows | Match subrows for vectors |
| ►CJacobianDeterminantOp | Jacobian determinant |
| Cimpl | |
| CResultType | |
| ►CJacobianOp | Jacobian matrix |
| Cimpl | |
| CResultType | |
| CLazyElementGrammar | Less restricitve grammar to get the result of expressions that are in an integral as well |
| CLazyIndexedGrammar | |
| CLSSWrapper | Proto-ready terminal type for wrapping a component |
| CLSSWrapperImpl | |
| ►CLump | Lump the matrix |
| Cimpl | |
| CLumpTag | |
| CMakeSFOp | Helper struct to declare custom types |
| ►CMakeVarData | Metafunction class for creating an appropriate data type |
| ►Capply | |
| CGetEETypeT | |
| CGetEETypeT< boost::mpl::void_, AnETypeT > | |
| ►CMakeVarData< VariablesT, EtypeT, EtypeT, EquationVariablesT, MatrixSizesT, EMatrixSizeT > | |
| Capply | |
| CMappedCoordTerms | Possible types for mapped coords |
| CMappedOpBase | Base class for the implementation of operations that depend on mapped coordinates (CRTP pattern) |
| CMappedVarOpBase | Base class for the implementation of operations that depend on mapped coordinates (CRTP pattern) |
| CMathOpDefault | Math operators evaluated using default C++ meaning |
| ►CMathOpDefaultCases | Split up MapthOpDefault using cases, for better compilation performance |
| Ccase_ | |
| Ccase_< boost::proto::tag::assign, Dummy > | |
| Ccase_< boost::proto::tag::divides, Dummy > | |
| Ccase_< boost::proto::tag::function, Dummy > | |
| Ccase_< boost::proto::tag::minus, Dummy > | |
| Ccase_< boost::proto::tag::negate, Dummy > | |
| Ccase_< boost::proto::tag::plus, Dummy > | |
| Ccase_< boost::proto::tag::plus_assign, Dummy > | |
| Ccase_< boost::proto::tag::post_dec, Dummy > | |
| Ccase_< boost::proto::tag::post_inc, Dummy > | |
| Ccase_< boost::proto::tag::pre_dec, Dummy > | |
| Ccase_< boost::proto::tag::pre_inc, Dummy > | |
| Ccase_< boost::proto::tag::unary_plus, Dummy > | |
| CMathTerminals | Matches terminal values that can be used in math formulas |
| ►CMatrixAssignOpsCases | Allowed block assignment operations |
| Ccase_ | |
| Ccase_< boost::proto::tag::assign, Dummy > | |
| Ccase_< boost::proto::tag::minus_assign, Dummy > | |
| Ccase_< boost::proto::tag::plus_assign, Dummy > | |
| ►CMatrixColAccess | |
| Cimpl | |
| ►CMatrixElementAccess | Primitive transform to access matrix elements using operator() |
| Cimpl | |
| ►CMatrixRowAccess | |
| Cimpl | |
| CMatrixSizePerVar | The size of the element matrix for each variable |
| ►CMatrixSubscript | Primitive transform to access matrix elements using operator[] |
| ►Cimpl | |
| CMatrixRef | |
| CMatrixRef< Eigen::Transpose< MatrixT > > | |
| CMatrixTerm | Match matrix terms (only matrix products need special treatment) |
| CMatVec | Matches matrices and vectors |
| CMaxOrder | Get the maximum order of the shape functions used in Expr |
| ►CNablaOp | Gradient |
| Cimpl | |
| CResultType | |
| CNodalValues | Get nodal values |
| CNodalValuesTag | |
| ►CNodeAssign | Handle modification of a field |
| Cimpl | |
| CNodeAssignGrammar | |
| ►CNodeAssignmentCases | |
| Ccase_ | |
| Ccase_< boost::proto::tag::assign, Dummy > | |
| Ccase_< boost::proto::tag::minus_assign, Dummy > | |
| Ccase_< boost::proto::tag::plus_assign, Dummy > | |
| ►CNodeData | |
| CDataType | Return the type of the data stored for variable I (I being an Integral Constant in the boost::mpl sense) |
| CDeleteVariablesData | Delete stored per-variable data |
| CInitVariablesData | Initializes the pointers in a VariablesDataT fusion sequence |
| CSetNode | Set the element on each stored data item |
| CNodeGrammar | |
| CNodeIdxOp | |
| CNodeLooper | Loop over nodes, using static-sized vectors to store coordinates |
| ►CNodeLooperDim | Loop over nodes, when the dimension is known |
| CFindDict | |
| CNodesDomain | |
| CNodesExpression | |
| CNodesExpressionStored | Wraps a given expression, so the value that it represents can be stored inside the expression itself |
| CSelectWrapper | |
| CSelectWrapper< false, ProtoExprT > | |
| CSelectWrapper< true, ProtoExprT > | |
| CWrapExpression | |
| CNodeMath | |
| CNodeMathBase | Matches expressions that can be used as terms in math formulas for element expressions |
| CNodeMathIndexed | |
| CNodesExpression | Expression for looping over nodes |
| ►CNodesOp | Element nodes |
| Cimpl | |
| CNodesTimesDim | Given a variable's data, get the product of the number of nodes with the dimension variable (i.e. the size of the element matrix if this variable would be the only one in the problem) |
| CNodesTimesDim< boost::mpl::void_, SF, SupportSF > | |
| CNodeStreamOutputIndexed | |
| CNodeVarData | Struct keeping track of data associated with numbered variables in node expressions |
| CNodeVarData< ScalarField > | |
| CNodeVarData< VectorField, Dim > | |
| ►CNormalOp | Face Normal |
| Cimpl | |
| CResultType | |
| CNormTag | |
| CNumberedTermType | Shorthand for terminals containing a numbered variable |
| CParsedFunctionGrammar | |
| ►CParsedScalarFunctionTransform | |
| Cimpl | |
| ►CParsedVectorFunctionTransform | Primitive transform to evaluate a function with the function parser |
| Cimpl | |
| CPhysicsConstant | Refers to a value from the physical model |
| CPhysicsConstantStorage | Storage for the values pointed to by a PhysicsConstant |
| Cpow_fun | Pow function based on Proto docs example |
| ►CProtoAction | Class to encapsulate Proto actions |
| ►CImplementation | |
| CPhysicsConstantLink | |
| CProtoDefaultFunction | Matches a terminal containing a proto function that can be evaluated using operator() |
| CProtoEvaluatedFunction | Wrap the vectorial function, adding extra data that may be filled before expression evaluation |
| ►CReplaceConfigurableConstant | Transform to replace an occurance of ConfigurableConstant with a reference to its value |
| Cimpl | |
| CReplaceConfigurableConstants | Grammar replacing ConfigurableConstants in an expression |
| ►CReplacePhysicsConstant | Transform to replace an occurance of PhysicsConstant with a reference to its value |
| Cimpl | |
| CReplacePhysicsConstants | Grammar replacing PhysicsConstants in an expression |
| ►CRestrictToElementType | Primitive transform to evaluate a group of expressions for specific element types only |
| ►Cimpl | |
| Cevaluate_expr | |
| CRestrictToElementTypeGrammar | |
| CRestrictToElementTypeGrammarSingle | Matches and evaluates groups of expressions matching GrammarT, optionally restricting to certain element types |
| CRestrictToElementTypeTag | |
| ►CRHSAccumulator | |
| Cimpl | |
| CRHSVectorGrammar | Matches placeholders for the solution vector |
| CRowTag | Placeholders to indicate if we should get a row or a column |
| ►CRunFunctionOp | Runs a shape function operation that is used as a function call |
| Cimpl | |
| ►CRunTerminalOp | Runs a shape function operation that is used as a terminal |
| Cimpl | |
| CScalar | Matches scalar terminals |
| CScalarField | Field data for a scalar field |
| CScalarFunction | |
| ►CSetIdentity | |
| Cimpl | |
| Cimpl< Eigen::Block< MatT, R, C >, StateT, DataT > | |
| CSetRHSGrammar | Matches the proper formulation of Neumann BC |
| ►CSetRHSSetter | |
| Cimpl | |
| CSetSolutionGrammar | Matches the proper formulation of Neumann BC |
| ►CSetSolutionSetter | |
| Cimpl | |
| ►CSetZero | |
| Cimpl | |
| Cimpl< Eigen::Block< MatT, R, C >, StateT, DataT > | |
| CSFOp | Wrap all operations in a template, so we can detect ops using a wildcard |
| ►CSFOp< CustomSFOp< OpT > > | |
| Cresult | |
| Cresult< This(GrammarT)> | |
| CSFOps | Shape-function related operations |
| ►CShapeFunctionOp | Shape functions |
| Cimpl | |
| CResultType | |
| CSingleExprElementGrammar | |
| CSingleExprNodeGrammar | Matches and evaluates element-wise expressions |
| CSolutionVectorGrammar | Matches placeholders for the solution vector |
| CSolutionVectorTag | Tag for a Neumann BC |
| CStoredMatrixExpression | Wraps a given expression, so the value that it represents can be stored inside the expression itself |
| CStreamOutput | Stream output |
| CStreamOutputIndexed | |
| ►CSubCols | A subblock of columns |
| Cimpl | |
| ►CSubMatrix | A submatrix |
| Cimpl | |
| ►CSubRows | A subblock of rows |
| Cimpl | |
| CSystemMatrixTag | Tag for system matrix |
| CSystemRHSTag | Tag for RHS |
| CTransposeFunction | Terminal to indicate we want a transpose |
| CTransposeGrammar | |
| ►CTransposeTransform | Primitive transform to perform the transpose |
| Cimpl | |
| CValueType | Extract the real value type of a given type, which might be an Eigen expression |
| CValueType< Eigen::CwiseUnaryOp< Eigen::internal::scalar_multiple_op< Real >, const MatrixT > > | Specialise for multiplication with a scalar |
| CValueType< Eigen::Matrix< Real, I, J > > | Specialize for Eigen matrices |
| CValueType< Eigen::Transpose< const Real > > | Specialise for transpose of reals |
| CValueType< Real > | Specialise for reals |
| CVar | Creates a variable that has unique ID I |
| CVarArity | |
| CVarChild | Helper to get the variable type at a child of an expression |
| CVarDataType | Helper to get the data type for the given variable |
| ►CVarValue | Returns the data value of a numbered variable |
| Cimpl | |
| CVectorField | Field data for a vector having the dimension of the problem |
| CVectorFunction | |
| ►CVectorSubRows | A subblock for the element vector |
| Cimpl | |
| ►CVolumeOp | Element volume |
| Cimpl | |
| CWrapExpression | Grammar to do the expression wrapping |
| ►CWrapMatrixExpression | |
| ►Cimpl | |
| CWrapperSelector | Helper to select if the expression is to be wrapped |
| CWrapperSelector< T &, true > | Expression is to be wrapped |
| CWrappableElementExpressions | Matches expressions that can be wrapped |
| CWrappableNodeExpressions | Matches expressions that need to be wrapped in an extension before they can be evaluated (i.e. Eigen products) |
| CZeroTag | |
| CAdvanceTime | |
| CComputeArea | |
| CComputeVolume | |
| CConditional | |
| CCopyScalar | Copy a scalar field variable |
| CDirectionalAverage | |
| CFieldTimeAverage | |
| CForAllCells | |
| CForAllElements | |
| ►CForAllElementsT | |
| CElementLooper | |
| CIsShapeFunction | Predicate class to test if the region contains a specific element type |
| CForAllFaces | |
| CForAllNodes2 | |
| CIterate | Action component that iteratively executes all contained actions |
| CLibActions | Class defines the initialization and termination of the library actions |
| CLoop | |
| CLoopOperation | |
| CNodeValence | Compute the valence (number of adjacent cells) for each node |
| CParallelDataToFields | |
| CPeriodicWriteMesh | |
| CPrintIterationSummary | |
| CProbe | Probe to interpolate field values to a given coordinate |
| CProbePostProcessor | ProbePostProcessor class to attach to a probe |
| CProbePostProcFunction | Probe Post Processor class to compute a configurable function |
| CProbePostProcHistory | ProbePostProcHistory class to attach to a probe |
| CRandomizeField | |
| CReadRestartFile | Read out a restartfile, designed to be loaded into an already-created mesh |
| CSetNodeValence | |
| CSynchronizeFields | |
| CTimeSeriesWriter | |
| CTurbulenceStatistics | |
| CTwoPointCorrelation | Compute two-point correlations in two perpendipular directions on a structured mesh |
| CWriteRestartFile | Write out a restartfile, designed to be loaded into an already-created mesh |
| CAction | |
| CActionDirector | |
| CActionDirectorWithSkip | |
| CBC | |
| CComputeCFL | Compute Right-Hand-Side of a PDE |
| CComputeLNorm | |
| CComputeRHS | Compute Right-Hand-Side of a PDE |
| CCriterion | |
| CCriterionAbsResidual | |
| CCriterionMaxIterations | |
| CCriterionMilestoneIteration | |
| CCriterionMilestoneTime | |
| CCriterionTime | |
| CHistory | Stores History of variables |
| CHistoryEntry | Helper class to output one entry to an output stream |
| CImposeCFL | |
| CLibSolver | |
| ►CModel | |
| CImplementation | |
| CModelSteady | |
| ►CModelUnsteady | |
| CImplementation | |
| CPDE | PDE component |
| CPDESolver | Solver base class to solve Partial Differential Equations, defined in class PDE |
| CPlotter | |
| CPlotXY | |
| CRiemannSolver | |
| CSimpleSolver | |
| ►CSolver | |
| CImplementation | |
| CTags | |
| CTerm | Term class |
| CTermBase | |
| CTermComputer | Computes a term of a system of equations by looping over elements |
| CTime | Storage for time, and time steps for unsteady simulation |
| CTimeStepComputer | Base class to compute a time_step field |
| CTimeStepping | Time Stepping component |
| CWizard | |
| ►NTestActions | |
| CDummyLoopOperation | |
| CLibTestActions | Class defines the initialization and termination of the library actions |
| ►NTools | Helpful non-essential libraries to use with COOLFluiD |
| ►NGooglePerfTools | The classes related to Google perftools |
| CGoogleHeapProfiling | |
| CGooglePerfProfiling | |
| CLibGooglePerfTools | |
| ►NGrowl | Classes for Growl desktop notifications using the GNTP protocol |
| CLibGrowl | Defines the initialization and termination of the library Growl |
| CNotifier | Growl notifier component |
| ►Nmesh_transformer | |
| CHelp | |
| CTransformer | |
| ►NMeshDiff | |
| CCommands | |
| CLibMeshDiff | |
| ►NMeshGeneration | |
| CLibMeshGeneration | |
| CMeshSourceGlobalFixture | |
| ►NProwl | Classes for Prowl push notifications on Apple iOS devices |
| CLibProwl | Defines the initialization and termination of the library Prowl |
| CNotifier | Prowl notifier component |
| ►NShell | Classes for command line interpreting COOLFluiD |
| CBasicCommands | Defines basic set of commands in the coolfluid shell |
| CCommand | |
| CInterpreter | Command Line and script interpreter |
| CLibShell | |
| CStdHelp | |
| ►Nsolver | |
| CCWorker | |
| CLogForwarder | Appends LoggingEvents to the remote client log window |
| CNotifier | |
| ►NTesting | |
| CAccumulator | Stores the results of the difference::test() function |
| CLibTesting | |
| CProfiledTestFixture | Any test using this fixture (or a derivative) will be profiled |
| CTimedTestFixture | Any test using this fixture (or a derivative) will be timed |
| ►Ntutorial | Contains Tutorial classes and functions |
| CHello | |
| CLibTutorial | Defines the Tutorial library |
| ►NUFEM | |
| ►Ndemo | |
| CCorrectionMatrix | |
| CLibUFEMDemo | |
| CNavierStokesChorin | Us Chorin's method to solve the Navier-Stokes equations |
| CNavierStokesManual | |
| CNavierStokesManualAssembly | |
| CNavierStokesSpecialized | |
| CNavierStokesSpecializedAssembly | |
| CPoissonManual | |
| CPoissonManualAssembly | |
| CPoissonProto | Poisson problem using generic Proto expressions |
| CPoissonSpecialized | Poisson problem using generic Proto expressions |
| CPoissonTriagAssembly | |
| CPoissonVirtual | |
| CPoissonVirtualAssembly | |
| ►Ndetail | |
| CSetGradient | |
| ►Nles | |
| ►Ndetail | |
| CComputeNuWALE | Proto functor to compute the turbulent viscosity |
| CLibUFEMLES | |
| CWALE | WALE LES model component |
| ►Nparticles | |
| ►Ndetail | |
| CBrownianCollisionKernel | |
| CDNSBrownianCollisionKernel | Combined DNS and Brownian coagulation |
| CDNSCollisionKernel | |
| CLocalImplicit | |
| CMomentSourceFunctor | Functor to compute the moment source terms |
| CNoCollisionKernel | |
| CTaylorGreenModel | |
| CUnityCollisionKernel | |
| CDiscontinuityCapture | Stabilization as described by Tezduyar et al |
| ►CEquilibriumEuler | |
| CVelocityFunctor | |
| ►CEquilibriumEulerConvergence | |
| CConvergenceFunctor | |
| CEquilibriumEulerFEM | |
| CLibUFEMParticles | |
| CParticleConcentration | |
| CPolydisperse | Polydisperse flow modeling |
| CRelaxationTime | Compute the particle relaxation time |
| CSquaredParticleRadius | |
| CTaylorGreen | Store the SUPG coefficient values in a field |
| CAdjacentCellToFace | |
| CAdjustForceTerm | AdjustForceTerm: Adjust force term proportionally to the difference with some target criterion (such as the bulk velocity) |
| ►CApplyAup | |
| Cresult | |
| Cresult< This(UT, PVecT, Real, Real)> | |
| CBCDirichletFunction | Boundary condition to hold the value of a field at a value given by another (or the same) field |
| CBCHoldValue | Boundary condition to hold the value of a field at a value given by another (or the same) field |
| CBCNeumannConstant | Boundary condition to hold the value of a field at a value given by another (or the same) field |
| ►CBoundaryConditions | BoundaryConditions for UFEM problems |
| CImplementation | |
| CBulkVelocity | |
| ►CCFLOp | |
| CShapeType | |
| CShapeType< ElementBased< Dim > > | |
| CComputeCFL | Boundary condition to hold the value of a field at a value given by another (or the same) field |
| CComputeFlux | |
| CComputeSACoeffs | |
| CComputeTau | Convenience type for a compute_tau operation, grouping the stored operator and its proto counterpart |
| CComputeTauImpl | Calculation of the stabilization coefficients for the SUPG method |
| CComputeTfluid | |
| CCouplingIterationControl | |
| CCriterionConvergence | |
| CCrosswindDiffusion | |
| CHeatConductionSteady | Steady, linear heat conduction |
| CHeatCouplingFlux | |
| CHeatCouplingRobin | |
| CHeatSpecialized | |
| CICNSImplicitToSemi | Initial condition to convert from a solution of the implicit solver to the semi-implicit one |
| CICNSSemiToImplicit | Initial condition to convert from a solution of the Semi-implicit solver to the implcit one |
| CInitialConditionConstant | InitialConditionConstant for UFEM problems, setting variables to a constant value |
| CInitialConditionFunction | InitialConditionFunction for UFEM problems, setting variables to a constant value |
| CInitialConditions | InitialConditions for UFEM problems |
| CInnerLoop | This is the inner solve loop |
| CIntegralOrder | Helper to detemine the appropriate default integration order |
| CIntegralOrder< mesh::LagrangeP1::Tetra3D > | Tetrahedra get order 1 |
| CIntegralOrder< mesh::LagrangeP1::Triag2D > | Triangles get order 1 |
| CKineticEnergyIntegral | |
| CLibUFEM | |
| ►CLSSAction | |
| CImplementation | |
| CLSSActionUnsteady | |
| CLSSIndexConverter | Convert LSS indices (copy from base proto code) |
| CNavierStokes | Solver for the unsteady incompressible Navier-Stokes equations |
| CNavierStokesPhysics | Physical model for the Navier Stokes equations |
| CNavierStokesSemiImplicit | Solver for the unsteady incompressible Navier-Stokes equations |
| CNSResidual | Store the SUPG coefficient values in a field |
| CParsedFunctionExpression | |
| ►CPressureRHS | |
| Cresult | |
| Cresult< This(UT, UVecT, UVecT, UVecT, PVecT, Real, Real)> | |
| CPressureSystem | Builds the pressure system matrix |
| CPressureSystemAssembly | |
| CScalarAdvection | Solver for scalar transport |
| ►CScalarLSSVector | Custom proto op to access element values in an LSS vector for a scalar variable |
| Cresult | Custom ops must implement the TR1 result_of protocol |
| Cresult< This(DataT)> | |
| CSetupInnerLoopData | Initialize inner loop data |
| CSolver | Manage a collection of UFEM solvers |
| CSpalartAllmaras | Solver for SpalartAllmaras turbulence model |
| CStokesSteady | |
| CSUPGFields | Store the SUPG coefficient values in a field |
| CSUPGSpecialized | |
| ►CSUPGTypes | Possible types of SUPG computation to apply |
| CConvert | |
| CSurfaceIntegral | |
| CTags | |
| ►CVectorLSSVector | Custom proto op to access element values in an LSS vector for a vector variable |
| Cresult | Custom ops must implement the TR1 result_of protocol |
| Cresult< This(DataT)> | |
| CVelocityAssembly | |
| CVelocityGradient | Compute a field containing the velocity gradient tensor and the divergence |
| ►CVelocityRHS | |
| Cresult | |
| Cresult< This(UT, NUT, GT, UVecT1, UVecT2, PVecT, Real, Real)> | |
| Cresult< This(UT, NUT, UVecT1, UVecT2, PVecT, Real, Real)> | |
| CWriteRestartManager | Helper class to manage the writing of restart files |
| ►Nui | |
| ►Ncore | Basic Classes for client-core library used by coolfluid-client application |
| CActionInfo | |
| CCNode | Base component adapted to fit the client needs |
| CCNodeBuilders | |
| CCNodeNotifier | Handles signal emitting for CNode class |
| CCommitDetails | Model that handles modified options details |
| CCommitDetailsItem | Basic item used by CommitDetails class |
| CJournalNotifier | |
| CLibCore | |
| CNBrowser | Component that manages remote browsers. This class subclasses CNode class |
| CNetworkQueue | |
| CNetworkThread | |
| CNGeneric | Client generic component |
| CNJournal | |
| CNJournalBrowser | |
| CNLink | Client corresponding component for cf3::common::Link |
| CNLog | Log component |
| CNPlugin | |
| CNPlugins | |
| ►CNRemoteFSBrowser | |
| CFileInfo | |
| CNRoot | Client root. This class is wrapper for cf3::common::Root class on the client side. A NRoot object may never have any child. Add them to the internal Root componenent instead. It can be obtained by calling root() method |
| CNScriptEngine | Make the link between ScriptEngine server side and the python console client side |
| CNTree | Tree model |
| CPropertyItem | |
| CPropertyModel | Model that maintains properties for the node pointed by the index returned by NTree::global()->currentIndex(). This class is a view for the tree model and is automatically updated whenever the current index is changed |
| CRemoteDispatcher | |
| CSSHTunnel | |
| CThreadManager | |
| CTransaction | |
| CTreeNode | Handles a CNode component in the tree |
| CTreeThread | Manages the client root node |
| ►NCoreTest | |
| CMyNode | |
| ►Ngraphics | Basic Classes for Graphics applications used by CF |
| CAboutCFDialog | |
| CApplication | |
| CBorderArea | Used to display the the line number and the prompt on a PythonCodeContainer |
| CBrowserDialog | |
| CCentralPanel | Panel to view and modify options of an object |
| CConfirmCommitDialog | Dialog used to ask user whether modifcations have to be committed before continuing |
| CCustomListWidget | Simple inherited class to reimplement some behavior |
| CCustomStandardItem | Dervied QStandardItem to allow case insensitive sorting |
| CDraggableListWidget | |
| ►CFavoritesModel | Model that manages a list of favorite directories |
| CSpecialDir | |
| CFileFilter | |
| CFilesListItem | Adds a functionnality to QStandardItem class |
| CFilteringModel | |
| CGraphicalArray | |
| CGraphicalArrayRestrictedList | |
| CGraphicalBool | |
| CGraphicalDouble | |
| CGraphicalInt | |
| CGraphicalRestrictedList | |
| CGraphicalString | |
| CGraphicalUri | |
| CGraphicalUriArray | |
| CGraphicalValue | |
| CJournalBrowserBuilder | |
| CJournalBrowserDialog | |
| CLibGraphics | |
| CLoggingList | Manages a graphical log component |
| CMainWindow | Client main window |
| CModifiedOptionsDialog | Dialog that shows commit details |
| COptionLayout | Panel to m_view and modify options() of an object |
| ►CPythonCodeContainer | This class contains common code for python editors |
| CPythonDict | |
| CPythonCodeEditor | Simple python editor |
| CPythonCompleter | Dervied QCompleter to allow the use of a tree model for completion model |
| ►CPythonConsole | The python console send python command to the server in form of python "fragment" the term "fragment" is used to describe a single python statement wich mean one instruction without tabulation (that instruction may have children instruction) Example of python fragment: for i in range(0,5): print i |
| Cpython_command | Used to store the pending command on the command stack |
| CPythonPreCompiler | Try to compile a python line to detect simple errors |
| ►CPythonSyntaxeHighlighter | Simple syntaxe highlighter |
| CHighlightingRule | |
| CRemoteFileCopy | |
| CSelectPathDialog | |
| CSignalInspectorDialog | |
| CSignalManager | |
| CSignatureDialog | |
| CTabBuilder | |
| CTabInfo | |
| CTextBlockErrorData | |
| CTreeBrowser | This widget allows allows to browse the treeview in a special way |
| CTreeView | This class manages the tree view |
| ►Nnetwork | Network layer for XML communications |
| CErrorHandler | |
| CLibNetwork | |
| CTCPConnection | Manages a TCP/IP connection between two entities where one is a server and the other one is a client |
| ►NParaView | |
| CC3DView | C3DView class |
| CC3DViewBuilder | C3DView class builder |
| CLibParaView | |
| ►NParaViewTab | Basic Classes for ParaViewTab applications used by CF |
| CLibParaViewTab | |
| CN3DView | Class used with C3DView to provide 3D mesh view |
| CWidget3D | Show a mesh rendered on a ParaViewTab server |
| ►NQwtTab | |
| CBodePlot | This is a QwtPlot with easiest way to acces the options and add curves |
| CColorSelector | This is QLabel that display a color picker when clicked and can give this color back |
| CGraph | This hold the XY graph and the options graph |
| CGraphOption | This class is used to set visuals options, generate functions and set the curve to draw |
| CLibQwtTab | |
| CNPlotXY | |
| CZoomer | |
| ►Nserver | |
| ►CCCore | Manages everything that is not related to the network layer or the simulation management |
| CDirContent | |
| CNetworkError | Exception thrown when the server can not open its socket |
| ►CServerNetworkComm | This class is the server network level |
| CClientInfo | |
| CServerRoot | |
| CUnknownClientId | Exception thrown when a given client id could not be associated to any existing client |
| ►NuiCommon | Common classes for the client and the server |
| CLibUICommon | |
| ►CLogMessage | |
| CConvert | |
| ►Nvtk | Classes for VTK operations |
| CCF3ToVTK | Convert a mesh to VTK format |
| CLibVTK | |
| CMeshInterpolator | Interpolate one mesh to another. Geometry dict only |
| CTetrahedralize | |
| ►Nzoltan | Classes for Zoltan operations |
| ►CArrayElementRemover | |
| CIndexMapping | |
| CGidToLocal | Helper class to convert global to local indices |
| CHGCollection | |
| CLibZoltan | |
| CNodePacker | |
| CNodeUnpacker | Helper class to unpack nodes packed using NodePacker |
| CPeriodicData | |
| CPHG | Executes a mesh partitioning using the hypergraph (PHG) mechanism |
| CDeleter | Functor for deleting objects by calling the safer delete_ptr function |
| CHandle | Safe pointer to an object. This is the supported method for referring to components |
| CNonInstantiable | Derive from this class if you want a class that is not instantiable |
| ►Nnetworkxpython | |
| Cnx_event_connector | Need to put things into a class to be reachable by the event callbacks |
| ►Nptest-navier-stokes-assembly | |
| CTestCase | |
| ►Nptest-ufem-demo-assembly | |
| CProfiler | |
| ►Nptest-ufem-demo-assembly3d | |
| CProfiler | |
| ►Nptest-ufem-demo-navier-stokes | |
| CProfiler | |
| ►Nrapidxml | External library used for XML parsing |
| Cxml_document | |
| Cxml_node | |
| ►NSmURF | |
| CMeshReader | |
| CMeshWriter | |
| CTecZone | |
| CAir | Properties of air that depend on temperature |
| CBinaryDataFixture | |
| CBlockMeshReaderFixture | |
| CBockMesh3DFixture | |
| CboundingboxMPITests_Fixture | |
| CBuilder_fixture | |
| CCAbstract | |
| CCConcrete1 | |
| CCheckGradientX | Check if the gradient of X is one in the X direction and zero in the other directions |
| CCheckJacobianDeterminant | Checks if the jacobian_determinant function result is the same as det(jacobian) |
| CCheckJacobianInverse | Checks if the inverse of the jacobian matrix equals jacobian_adjoint / jacobian_determinant |
| CClient | |
| CCommPatternFixture | |
| CCommWrapperFixture | |
| CComponentBenchFixture | |
| CComponentIterationFixture | |
| ►CComponentURIPrinter | |
| Cimpl | |
| CComposedPhysics | Prototype implementation of a static physics model. Compose up to 5 physical models |
| CComposedPhysics< T1, T2, boost::mpl::void_, boost::mpl::void_, boost::mpl::void_ > | Specialization for 2 models |
| CComposedPhysics< T1, T2, T3, boost::mpl::void_, boost::mpl::void_ > | Specialization for 3 models |
| CComposedPhysics< T1, T2, T3, T4, boost::mpl::void_ > | Specialization for 4 models |
| CConnectivityFixture | Fixture providing a simple mesh read from a .neu file. Unprofiled |
| CCore_fixture | |
| CCoreInit | |
| CCounter | Custom op that just modifies its argument |
| CCSmall | |
| ►CCustomLaplacian | |
| Cresult | Custom ops must implement the TR1 result_of protocol |
| Cresult< This(FieldDataT)> | |
| ►CCustomLaplacianApply | |
| Cresult | |
| Cresult< This(TempT, MatrixT, VectorT)> | |
| CCustomProtoSolver | Create a custom actiondomain |
| ►CCustomTerminal | |
| Cresult | Custom ops must implement the TR1 result_of protocol |
| Cresult< This(DataT)> | |
| CDataComponentWrapperFixture | |
| CDictionaryTests_Fixture | |
| CDisplayIter | |
| CEigenFixture | Fixture for each test of Eigen |
| CElementIterator | |
| ►CEuler2D | |
| CProperties | |
| CEuler2DCons | |
| Cf | |
| CFaceCellConnectivity_Fixture | |
| CFactoryFixture | |
| CFileUpload | |
| CFixture | |
| CForeachFixture | |
| CFunctionParser_Fixture | |
| CFunctorForDim | |
| CFunctorForDim< 1 > | |
| CFunctorForDim< 2 > | |
| CFunctorForDim< 3 > | |
| Cglobal_fixture | |
| CGlobalFixture | Use a global fixture, so mesh creation happens only once |
| CgmshReaderMPITests_Fixture | |
| CGnuplot | |
| CGnuplotPty | |
| CGrowl | |
| ►CHexa3DFixture | |
| CConstFunctor | |
| CHilbertNumberingTests_Fixture | |
| CHolderT | |
| Cimaxdiv_t | |
| CIntegralConstantGrammar | |
| CIntegralConstantTag | |
| CIsotermalFluid2D | Store local fluid properties |
| CIterativeAlgo | |
| ►CLagrangeP1Line1DFixture | |
| CConstFunctor | |
| ►CLagrangeP1Line2DFixture | |
| CConstFunctor | |
| CConstVectorField | Returns the scalar product of a constant vector field and the local element normal |
| CNormalVectorNorm | Returns the norm of the normal vector to the curve or surface element (equal to tangent in the case of Line2D) |
| CRotatingCylinderPressure | |
| ►CLagrangeP1Line3DFixture | |
| CConstFunctor | |
| CTangentVectorNorm | Returns the norm of the tangen vector to the curve |
| ►CLagrangeP1Quad2DFixture | |
| CConstFunctor | |
| ►CLagrangeP1Quad3DFixture | |
| CConstFunctor | |
| CConstVectorField | Returns the scalar product of a constant vector field and the local element normal |
| CNormalVectorNorm | Returns the norm of the normal vector to the curve or surface element (equal to tangent in the case of Line2D) |
| CRotatingCylinderPressure | |
| ►CLagrangeP1Tetra3DFixture | |
| CConstFunctor | |
| ►CLagrangeP1Triag2DFixture | |
| CConstFunctor | |
| ►CLagrangeP1Triag3DFixture | |
| CConstFunctor | |
| CConstVectorField | Returns the scalar product of a constant vector field and the local element normal |
| CNormalVectorNorm | Returns the norm of the normal vector to the curve or surface element (equal to tangent in the case of Line2D) |
| CRotatingCylinderPressure | |
| CLagrangeP2BTriag2DFixture | |
| CLastCallbackInfo | |
| Clocal_fixture | |
| CLogLevelFilterFixture | |
| CLogStampFilter_Fixture | |
| CLoopElems | |
| CLSSAtomicFixture | |
| CLSSDistributedMatrixFixture | |
| CLSSSymmetricDirichletFixture | |
| CLSSSystem_EmptyLSSFixture | |
| CMapFixture | |
| CMatrixInterpolationFixture | |
| CMatrixInverter_Fixture | |
| Cmd5_context | |
| CMeshComponent_Fixture | |
| CMeshConstruction_Fixture | |
| CMeshInterpolation_Fixture | |
| CMeshManipulationsTests_Fixture | |
| CMeshReading_Fixture | |
| CMeshTransformer_Fixture | |
| ►CMetricTensor | |
| Cresult | Custom ops must implement the TR1 result_of protocol |
| Cresult< This(DataT)> | |
| CMPIBufferTests_Fixture | |
| CMyC | |
| CMyErrorHandler | |
| Cnat | |
| CNavierStokesAssemblyFixture | |
| CNeumannFixture | |
| CneuReaderMPITests_Fixture | |
| CNodeElementConnectivity_Fixture | |
| CNodes_Fixture | |
| COcttree_Fixture | |
| COSystemFixture | |
| CParallelFieldsTests_Fixture | |
| CParallelOverlapTests_Fixture | |
| CPart | |
| CPEAllGatherFixture | |
| ►CPEAllReduceFixture | |
| Coptest | Test class with operator + to test if operations and all_reduce can work with it |
| CPEAllToAllFixture | |
| CPEBroadcastFixture | |
| CPECollectiveFixture | |
| ►CPEDatatypeFixture | |
| Cuser_struct_c | |
| Cuser_struct_d | |
| Cuser_struct_i | Some complex data types |
| CPEFixture | |
| CPEGatherFixture | |
| ►CPEOperationsFixture | |
| Ccustommult | Example custom function |
| Coptest | Custom class for checking the non built-in way |
| ►CPEReduceFixture | |
| Coptest | Test class with operator + to test if operations and reduce can work with it |
| CPerfectGas | Use the perfect gas law to get density |
| CPEScatterFixture | |
| ►CPhysModel | |
| CProperties | |
| ►CPrism3DFixture | |
| CConstFunctor | |
| CProfiledFixture | Profile and time tests using this fixture |
| CProperties_Fixture | |
| ►CProtoBenchmarkFixture | |
| CDirectArrays | |
| CProtoHeatFixture | |
| CProtoLSSFixture | |
| CProtoParallelFixture | |
| CProtoUnsteadyFixture | |
| Cprowl_connection | |
| CPtrFixture | |
| CPTScotchTests_Fixture | |
| CQList | |
| CQMap | |
| CRapidXML_Test_Fixture | |
| CRDMMergeFixture | |
| ►CScalarLSSVector | |
| Cresult | Custom ops must implement the TR1 result_of protocol |
| Cresult< This(DataT)> | |
| ►CServer | |
| CClientInfo | |
| CSetIntegerAction | Action that sets an integer, for testing purposes |
| CSimpleGrammar | Simple test grammar |
| CSimpleMeshGeneratorTests_Fixture | |
| CSomeTag | Define a tag (not used here) |
| CSpaceElement | |
| CStackTrace | |
| CStencilComputerRings_Fixture | |
| CSumVectorNorm | |
| CTecWriterTests_Fixture | |
| Ctest_matrix | Holding all the data and the constructor sets everything up, everything is public |
| CTest_ShapeFunction_Fixture | |
| CTestBuildFaces_Fixture | |
| CTestCGNS_Fixture | |
| CTestFieldCreation_Fixture | |
| CTestFixture | |
| CTestGlobalConnectivity_Fixture | |
| CTestParallelDistribution_Fixture | |
| CTestRotate_Fixture | |
| CTestSignals_Fixture | |
| CTetraSFFixture | Fixture for each test |
| CThermalFluid | Non-isothermal fluid (assume we get the temperature from somewhere else) |
| CUFEMBuildSparsityFixture | |
| CUnifiedData_Fixture | |
| CVariables | |
| CVariablesT | |
| CVectorBenchmarkFixture | |
| ►CVectorLSSVector | |
| Cresult | Custom ops must implement the TR1 result_of protocol |
| Cresult< This(DataT)> | |
| CVectorOperations_Fixture | |
| CVolumeFunctor | Simple test functor to compute the volume |
| ►CVolumeSFFixture | |
| CMakeSFNodesPair | Functor to create a fusion pair between a shape function and its node matrix |
| CVolumeMPLFunctor | Applies a functor if the element is a volume element |
| CXmlFixture | |
| CZoltanTests_Fixture |
1.8.9.1
|
Send comments to: COOLFluiD Web Admin |
