| ►CAbstract | |
| CQuadratureT< Concrete, Abstract > | Translation class to link concrete static implementations to the dynamic API |
| CShapeFunctionT< Concrete, Abstract > | Translation class to link concrete static implementations to the dynamic API |
| CAccumulator | Stores the results of the difference::test() function |
| CActionInfo | |
| CAddNewParameter | |
| CAddNodeData< Dim > | MPL transform operator to wrap a variable in its data type |
| CAddParameter | |
| CAir | Properties of air that depend on temperature |
| CAnalyticalFunction | |
| ►Cand_ | |
| CFunctionPointer | Matches a terminal containing a function pointer |
| CMatrixTerm< GrammarT > | Match matrix terms (only matrix products need special treatment) |
| CProtoDefaultFunction | Matches a terminal containing a proto function that can be evaluated using operator() |
| CAnyListToPython | Conversion for lists |
| CAnyToPython | Conversion from any to python for basic types |
| CExpressionBase< ExprT >::AppendTags | Functor to store the tags used by a field |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::apply< ResultT > | Pass the stored parameter if the result type is a reference, don't store otherwise |
| CAddNodeData< Dim >::apply< VarT, Dummy > | |
| CGetNbNodes< EquationDataT >::apply< BoolT, EqDataT > | |
| CIsCellType::apply< ETYPE > | |
| CIsEquationData::apply< DataT, Dummy > | |
| CMakeVarData< VariablesT, SupportEtypeT, ShapeFunctionsT, EquationVariablesT, MatrixSizesT, EMatrixSizeT >::apply< I > | |
| CMakeVarData< VariablesT, EtypeT, EtypeT, EquationVariablesT, MatrixSizesT, EMatrixSizeT >::apply< I > | |
| CIsFaceType::apply< ETYPE > | |
| CIsEdgeType::apply< ETYPE > | |
| CIsCompatibleWith< ETYPE >::apply< OTHER_ETYPE > | |
| CIsMinimalOrder< Order >::apply< SF > | |
| CGetNbNodes< EquationDataT >::apply< boost::mpl::false_, EqDataT > | |
| CGetNbNodes< EquationDataT >::apply< boost::mpl::true_, EqDataT > | |
| CIsEquationData::apply< boost::mpl::void_, Dummy > | |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::apply< ResultT & > | Specialization for references |
| CAddNodeData< Dim >::apply< VectorField, Dummy > | |
| CApplyAup | |
| CArrayBase< ValueT > | |
| CArrayBufferT< T > | A Buffer that is constructed passing a boost::multi_array<T,2> table. This class allows to interface this table by using a buffer |
| CArrayElementRemover | |
| CArrayToVector< TYPE > | A struct, since partial specializations of functions is not allowed |
| CArrayToVector< Handle< ComponentT > > | |
| ►Cassign | |
| CIndexedNodeAssignmentCases< GrammarT, IndexGrammarT >::case_< boost::proto::tag::assign, Dummy > | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::assign, Dummy > | |
| CMatrixAssignOpsCases< SystemTagT >::case_< boost::proto::tag::assign, Dummy > | |
| CNodeAssignmentCases< GrammarT >::case_< boost::proto::tag::assign, Dummy > | |
| CBasicCommands | Defines basic set of commands in the coolfluid shell |
| CReader::BCData | |
| CBinaryDataFixture | |
| CBlockArrays::Implementation::Block | Encapsulate a single block, providing all data needed to produce the mesh connectivity |
| CBlockAccumulator | |
| CBlockAssignmentOp< SystemTagT, OpTagT > | Helper struct for assignment to a matrix or RHS |
| CBlockAssignmentOp< SystemMatrixTag, OpTagT > | |
| CBlockAssignmentOp< SystemRHSTag, OpTagT > | |
| CBlockData | Helper struct to read the data into vectors |
| CBlockArrays::Implementation::BlockLayer | Represents a single layer across the mesh |
| CBlockMeshReaderFixture | |
| CBlocksPartitioning | Helper struct to keep using the old partitioning method |
| ►CBoundingBox | Bounding box defined by minimum and maximum coordinates |
| CBoundingBox | Wrapped math::BoundingBox, with extra functionality |
| CboundingboxMPITests_Fixture | |
| ►CBracketMethod | |
| CBrent | |
| CDbrent | |
| CGolden | |
| CBrownianCollisionKernel | |
| CBuffer | Buffer that can hold multiple data types, useful for MPI communication |
| CArrayBufferT< T >::Buffer | |
| CDynArrayBufferT< T >::Buffer | |
| CListBufferT< T >::Buffer | |
| CBuilder_fixture | |
| ►Ccallable | |
| CGetNodeIdx | |
| ►Ccallable_context | |
| CCopyNumberedVars< VarsT > | Copy the terminal values to a fusion list |
| CCFLOp | |
| CShared::CGNS_Base | |
| CShared::CGNS_Boco | |
| CShared::CGNS_Field | |
| CShared::CGNS_File | |
| CShared::CGNS_FlowSolution | |
| CShared::CGNS_Section | |
| CShared::CGNS_Size | |
| CShared::CGNS_Zone | |
| CChangeArrayValue< TYPE > | Helper function to set the value |
| CChangeArrayValue< Handle< ComponentT > > | |
| CChangeArrayValue< int > | |
| CChangeArrayValue< Real > | |
| CChangeArrayValue< Uint > | |
| 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 |
| CCheckSameEtype< ETYPE > | Check if all variables are on fields with element type ETYPE |
| CChildListWrapper | |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ChildType< I > | |
| CClient | |
| CServerNetworkComm::ClientInfo | |
| CServer::ClientInfo | |
| CCNodeBuilders | |
| CCodeLocation | |
| CColTag | |
| CCommands | |
| ►Ccommands_description | |
| ►CCommand | |
| CHelp | |
| CStdHelp | |
| CCommitDetailsItem | Basic item used by CommitDetails class |
| CCommPatternFixture | |
| CCommWrapperFixture | |
| CMap< KEY, DATA >::Compare | |
| CComponentBuilder< CONCRETE, BASE, LIB > | Helper class to create the Builder and place it in the factory |
| CComponentHandle< ParentT, ComponentT > | Handle to ComponentT, constness determined by the constness of ParentT |
| CComponentIterationFixture | |
| CComponentIteratorRangeSelector< ParentT, ComponentT, Predicate > | Derive the correct range type based on the constness of ParentT, which should be the type of the parent component |
| CComponentIteratorSelector< ParentT, ComponentT > | Derive the correct range type based on the constness of ParentT, which should be the type of the parent component |
| CComponentPtr< ParentT, ComponentT > | Shared pointer to ComponentT, constness determined by the constness of ParentT |
| CComponentReference< ParentT, ComponentT > | Reference to ComponentT, constness determined by the constness of ParentT |
| ►CComponentT | |
| CAllocatedComponent< ComponentT > | |
| CComponentWrapper | Wrapper class for components |
| CComponentWrapperImpl< ComponentT, TagT > | |
| CComposedPhysics< T1, T2, T3, T4, T5 > | Prototype implementation of a static physics model. Compose up to 5 physical models |
| CCompressedStream | |
| CCompressedStreamHeader | |
| CComputeCentroid | Helper to compute the centroid |
| CComputeNuWALE | Proto functor to compute the turbulent viscosity |
| CComputeSACoeffs | |
| CComputeTau | Convenience type for a compute_tau operation, grouping the stored operator and its proto counterpart |
| CConfigurableConstant< ValueT > | Refers to a configurable constant value |
| ►CConnectionManager | |
| ►CComponent | Base class for defining CF components |
| CCAbstract | |
| ►CAction | Component that executes an action. Implementation of the IAction interface as a component, exposing the execute function as a signal |
| ►CActionDirector | |
| CActionDirector | |
| CActionDirectorWithSkip | |
| CIterate | Action component that iteratively executes all contained actions |
| ►CSolver | |
| ►CSimpleSolver | |
| CSolver | Manage a collection of UFEM solvers |
| CCustomProtoSolver | Create a custom actiondomain |
| CTimeStepping | Time Stepping component |
| CBoundaryConditions | BoundaryConditions for UFEM problems |
| CComputeFlux | |
| CComputeTfluid | |
| CHeatCouplingFlux | |
| CHeatCouplingRobin | |
| CInitialConditions | InitialConditions for UFEM problems |
| ►CLSSAction | |
| CPoissonManual | |
| CPoissonProto | Poisson problem using generic Proto expressions |
| CPoissonSpecialized | Poisson problem using generic Proto expressions |
| CPoissonVirtual | |
| CHeatConductionSteady | Steady, linear heat conduction |
| ►CLSSActionUnsteady | |
| CNavierStokesManual | |
| CNavierStokesSpecialized | |
| CNavierStokes | Solver for the unsteady incompressible Navier-Stokes equations |
| CEquilibriumEulerFEM | |
| CParticleConcentration | |
| CPressureSystem | Builds the pressure system matrix |
| CScalarAdvection | Solver for scalar transport |
| CSpalartAllmaras | Solver for SpalartAllmaras turbulence model |
| CStokesSteady | |
| CNavierStokesSemiImplicit | Solver for the unsteady incompressible Navier-Stokes equations |
| CArrayDiff | |
| CPrintTimingTree | Prints the timing tree for a root component |
| CSolveLSS | |
| CZeroLSS | |
| CMeshDiff | |
| CMeshInterpolator | |
| CSurfaceIntegral | SurfaceIntegral Fields with matching support |
| CVolumeIntegral | VolumeIntegral Fields with matching support |
| ►CMeshGenerator | |
| CChannelGenerator | Generate parallel 3D channels with grading towards the wall |
| CGenerateLine3D | |
| CGeneratePlane3D | |
| CSimpleMeshGenerator | Generate a simple carthesian P1 mesh without grading |
| ►CMeshReader | |
| CBlockMeshReader | |
| CReader | |
| CReader | |
| CReader | |
| CReader | |
| CReader | |
| ►CMeshTransformer | |
| CTetrahedralize | |
| CAddPointRegion | |
| CBuildArea | |
| CBuildFaceNormals | |
| CBuildFaces | |
| CBuildVolume | |
| CComputeFieldGradient | Compute the gradient of a field |
| CCreateField | Create a field with given functions |
| CExtract | |
| 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 |
| CLinkPeriodicNodes | |
| CLoadBalance | Load Balance the mesh |
| CMakeBoundaryGlobal | |
| CPeriodicMeshPartitioner | |
| CRemoveGhostElements | |
| CRotate | |
| CShortestEdge | |
| CTranslate | |
| CWallDistance | |
| ►CMeshPartitioner | |
| CPartitioner | |
| CPartitioner | |
| CMeshTriangulator | |
| CCF3ToVTK | Convert a mesh to VTK format |
| CTetrahedralize | |
| CPHG | Executes a mesh partitioning using the hypergraph (PHG) mechanism |
| ►CMeshWriter | |
| CWriter | |
| CWriter | |
| CWriter | |
| CWriter | |
| CWriter | |
| CWriter | |
| CWriter | |
| CWriter | |
| CWriteMesh | |
| CAction | |
| CAdvanceTime | |
| CConditional | |
| CDirectionalAverage | |
| CFieldTimeAverage | |
| ►CLoop | |
| CForAllCells | |
| CForAllElements | |
| CForAllElementsT< ActionT > | |
| CForAllFaces | |
| CForAllNodes2 | |
| ►CLoopOperation | |
| CComputeArea | |
| CComputeVolume | |
| CDummyLoopOperation | |
| 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 |
| ►CProtoAction | Class to encapsulate Proto actions |
| CCopyScalar | Copy a scalar field variable |
| CNodeValence | Compute the valence (number of adjacent cells) for each node |
| CAdjustForceTerm | AdjustForceTerm: Adjust force term proportionally to the difference with some target criterion (such as the bulk velocity) |
| 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 |
| CBulkVelocity | |
| CComputeCFL | Boundary condition to hold the value of a field at a value given by another (or the same) field |
| CKineticEnergyIntegral | |
| CWALE | WALE LES model component |
| CNSResidual | Store the SUPG coefficient values in a field |
| ►CParsedFunctionExpression | |
| CBCDirichletFunction | Boundary condition to hold the value of a field at a value given by another (or the same) field |
| CInitialConditionFunction | InitialConditionFunction for UFEM problems, setting variables to a constant value |
| CEquilibriumEuler | |
| CEquilibriumEulerConvergence | |
| CRelaxationTime | Compute the particle relaxation time |
| CTaylorGreen | Store the SUPG coefficient values in a field |
| CSUPGFields | Store the SUPG coefficient values in a field |
| CSurfaceIntegral | |
| CVelocityGradient | Compute a field containing the velocity gradient tensor and the divergence |
| CRandomizeField | |
| CReadRestartFile | Read out a restartfile, designed to be loaded into an already-created mesh |
| CSynchronizeFields | |
| ►CTimeSeriesWriter | |
| CWriteRestartManager | Helper class to manage the writing of restart files |
| 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 |
| CBC | |
| CComputeCFL | Compute Right-Hand-Side of a PDE |
| CComputeLNorm | |
| CComputeRHS | Compute Right-Hand-Side of a PDE |
| CPDESolver | Solver base class to solve Partial Differential Equations, defined in class PDE |
| CTermComputer | Computes a term of a system of equations by looping over elements |
| ►CTimeStepComputer | Base class to compute a time_step field |
| CImposeCFL | |
| CAdjacentCellToFace | |
| CCouplingIterationControl | |
| CNavierStokesChorin | Us Chorin's method to solve the Navier-Stokes equations |
| CNavierStokesManualAssembly | |
| CPoissonManualAssembly | |
| CPoissonVirtualAssembly | |
| 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 |
| CInnerLoop | This is the inner solve loop |
| CPolydisperse | Polydisperse flow modeling |
| CPressureSystemAssembly | |
| CSetupInnerLoopData | Initialize inner loop data |
| CMeshInterpolator | Interpolate one mesh to another. Geometry dict only |
| CSetIntegerAction | Action that sets an integer, for testing purposes |
| CBinaryDataReader | Component for writing binary data collected into a single file |
| CBinaryDataWriter | Component for writing binary data collected into a single file |
| ►CBuilder | Component that builds other components |
| CBuilderT< BASE, CONCRETE > | Component that builds other components of a given abstract type This is the actual builder for one concrete type |
| ►CCAbstract | |
| CCConcrete1 | |
| CCConcrete1 | |
| CCConcrete2 | |
| ►CCodeProfiler | |
| CNoProfiling | |
| CGoogleHeapProfiling | |
| CGooglePerfProfiling | |
| CDynTable< T > | |
| CEnvironment | |
| CFactories | |
| ►CFactory | Component class for a factory which builds other components |
| CFactoryT< TYPE > | Component class for a factory which builds other components |
| CGroup | Component for grouping other components |
| CJournal | |
| CLibraries | |
| ►CLibrary | Component class for a library |
| CLibBlockMeshReader | |
| CLibCGAL | |
| CLibCommon | |
| CLibMath | |
| CLibLSS | Class defines the initialization and termination of the library LSS |
| CLibActions | Class defines the initialization and termination of the library actions |
| CLibBlockMesh | |
| CLibCF3Mesh | |
| CLibCGNS | |
| CLibGaussLegendre | |
| CLibGmsh | |
| CLibLagrangeP0 | |
| CLibLagrangeP1 | |
| CLibLagrangeP2 | |
| CLibLagrangeP2B | |
| CLibLagrangeP3 | |
| CLibMesh | |
| CLibNeu | |
| CLibPTScotch | |
| CLibSmurf | |
| CLibTecplot | |
| CLibVTKLegacy | |
| CLibVTKXML | |
| CLibZoltan | |
| CLibEuler | |
| CLibEuler | |
| CLibPhysics | |
| CLibLinEuler | |
| CLibScalar | |
| CLibPython | |
| CLibActions | Class defines the initialization and termination of the library actions |
| CLibSolver | |
| CLibTestActions | Class defines the initialization and termination of the library actions |
| CLibGooglePerfTools | |
| CLibGrowl | Defines the initialization and termination of the library Growl |
| CLibMeshDiff | |
| CLibMeshGeneration | |
| CLibProwl | Defines the initialization and termination of the library Prowl |
| CLibShell | |
| CLibTesting | |
| CLibTutorial | Defines the Tutorial library |
| CLibUFEMDemo | |
| CLibUFEMLES | |
| CLibUFEM | |
| CLibUFEMParticles | |
| CLibCore | |
| CLibGraphics | |
| CLibNetwork | |
| CLibParaView | |
| CLibParaViewTab | |
| CLibQwtTab | |
| CLibUICommon | |
| CLibVTK | |
| CLibZoltan | |
| CLink | |
| CList< ValueT > | Component holding a 1 dimensional array of a templated type |
| CMap< KEY, DATA > | |
| CCommPattern | |
| ►CCommWrapper | Base wrapper class serving as interface |
| CCommWrapperMArray< T, NumDims > | Wrapper class for Table components |
| CCommWrapperMArray< T, 1 > | |
| CCommWrapperMArray< T, 2 > | |
| CCommWrapperPtr< T > | Wrapper class for raw ptr arrays allocated by new[]/malloc/calloc |
| CCommWrapperVector< T > | Wrapper class for std::vectors |
| CManager | |
| CWorkerGroup | |
| CTable< ValueT > | Component holding a 2 dimensional array of a templated type |
| ►CMatrix | |
| CEmptyLSSMatrix | |
| CTrilinosCrsMatrix | |
| CTrilinosFEVbrMatrix | |
| CParameterList | Encapsulate a Teuchos parameter list |
| ►CParameterListDefaults | Encapsulate a Teuchos parameter list |
| CBelosGMRESParameters | Encapsulate a Teuchos parameter list |
| ►CSolutionStrategy | |
| ►CCoordinatesStrategy | |
| CDirectStrategy | |
| CRCGStrategy | |
| CTrilinosStratimikosStrategy | |
| CEmptyStrategy | |
| CSystem | |
| ►CVector | |
| CEmptyLSSVector | |
| CTrilinosVector | |
| CVariableManager | |
| CVariablesDescriptor | |
| ►CAInterpolator | A Interpolator base component |
| ►CInterpolator | Interpolator component delegating interpolation to a PointInterpolator strategy |
| CInterpolatorT< POINTINTERPOLATOR > | Compile-time configured strategy for interpolation |
| CMatchedMeshInterpolator | Interpolator component that interpolates fields between spaces in the same mesh |
| CSpaceInterpolator | Interpolator component that interpolates fields between spaces in the same mesh |
| ►CAPointInterpolator | PointInterpolator to interpolate a field to a point |
| CPointInterpolator | A general configurable point interpolator |
| CPointInterpolatorT< ELEMENTFINDER, STENCILCOMPUTER, INTERPOLATIONFUNCTION > | A compile-time configured point interpolator, making sure that element-finder, stencil computer, and interpolation function match together |
| CBlockArrays | |
| CBoundingBox | Wrapped math::BoundingBox, with extra functionality |
| ►CDictionary | |
| CContinuousDictionary | |
| CDiscontinuousDictionary | |
| CDomain | |
| ►CElementFinder | Base class for finding an element given a coordinate |
| CElementFinderOcttree | Find elements using an octtree |
| ►CElementType | |
| CElementTypeT< ETYPE > | Translation class to link concrete static implementations to the dynamic API |
| ►CElementTypeT< Triag2D > | |
| CElementTypeTriag2D | |
| ►CEntities | |
| CCellFaces | |
| ►CElements | |
| CCells | |
| CEdges | |
| CFaces | |
| CFaceCellConnectivity | |
| CFaceConnectivity | |
| CFieldManager | |
| ►CInterpolationFunction | |
| CPseudoLaplacianLinearInterpolation | Pseudo-Laplacian Weighted Linear Interpolation function |
| CShapeFunctionInterpolation | |
| CLoadMesh | |
| CMergedParallelDistribution | |
| CMesh | |
| CMeshMetadata | Storage for metadata related to the mesh |
| CNode2FaceCellConnectivity | |
| CNodeConnectivity | |
| CNodeElementConnectivity | |
| COcttree | |
| CParallelDistribution | |
| CQuadrature | |
| CRegion | |
| CShapeFunction | |
| CSpace | Space component class |
| ►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 |
| ►CUnifiedData | |
| CMeshElements | |
| ►CPhysModel | |
| ►CDynamicModel | |
| CNavierStokesPhysics | Physical model for the Navier Stokes equations |
| CLinEuler2D | |
| CLinEuler3D | |
| CScalar1D | |
| CScalar2D | |
| CScalar3D | |
| CScalarSys2D | |
| ►CVariables | |
| CDynamicVars | |
| CVariablesT< PHYS > | |
| ►CVariablesT< Burgers2D > | |
| CBurgers2D | |
| ►CVariablesT< Cons2D > | |
| CCons2D | |
| ►CVariablesT< Cons3D > | |
| CCons3D | |
| ►CVariablesT< Diffusion2D > | |
| CDiffusion2D | |
| ►CVariablesT< LinearAdv1D > | |
| CLinearAdv1D | |
| ►CVariablesT< LinearAdv2D > | |
| CLinearAdv2D | |
| ►CVariablesT< LinearAdv3D > | |
| CLinearAdv3D | |
| ►CVariablesT< LinearAdvSys2D > | |
| CLinearAdvSys2D | |
| ►CVariablesT< RotationAdv2D > | |
| CRotationAdv2D | |
| CNetworkXPython | |
| CScriptEngine | Manage a python interpreter |
| CTestAllOptions | Creates an option for each type, to enable testing of python option handling |
| CTestSignals | Exposes certain signals for testing purposes |
| ►CCriterion | |
| CCriterionAbsResidual | |
| CCriterionMaxIterations | |
| CCriterionMilestoneIteration | |
| CCriterionMilestoneTime | |
| CCriterionTime | |
| CCriterionConvergence | |
| CHistory | Stores History of variables |
| ►CModel | |
| CModelSteady | |
| CModelUnsteady | |
| CPDE | PDE component |
| CPlotter | |
| CPlotXY | |
| CRiemannSolver< DATA, NB_DIM, NB_EQS > | |
| ►CTerm | Term class |
| CTermBase< NB_DIM, NB_EQS, NB_VAR, NB_GRAD > | |
| CTime | Storage for time, and time steps for unsteady simulation |
| CWizard | |
| CNotifier | Growl notifier component |
| CNotifier | Prowl notifier component |
| CCWorker | |
| CHello | |
| ►CCNode | Base component adapted to fit the client needs |
| CNBrowser | Component that manages remote browsers. This class subclasses CNode class |
| CNetworkQueue | |
| CNGeneric | Client generic component |
| CNJournal | |
| CNJournalBrowser | |
| CNLink | Client corresponding component for cf3::common::Link |
| CNLog | Log component |
| CNPlugin | |
| CNPlugins | |
| CNRemoteFSBrowser | |
| 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 |
| CMyNode | |
| CPythonPreCompiler | Try to compile a python line to detect simple errors |
| CN3DView | Class used with C3DView to provide 3D mesh view |
| CNPlotXY | |
| CC3DView | C3DView class |
| CC3DViewBuilder | C3DView class builder |
| CCCore | Manages everything that is not related to the network layer or the simulation management |
| CCSmall | |
| CHolderT< SubCompT > | |
| CList< bool > | |
| CList< int > | |
| CList< Uint > | |
| CMyC | |
| CPart | |
| ►CTable< Real > | |
| CField | |
| ►CTable< Uint > | |
| CConnectivity | |
| CNotificationQueue | Manages a notification queue |
| CDisplayIter | |
| CFileUpload | |
| CConnectivityFixture | Fixture providing a simple mesh read from a .neu file. Unprofiled |
| CConstantStorage | Storage for the values pointed to by a ConfigurableConstant |
| CConstantStorageType< T > | Returns the map type used to store values of the given type |
| CConstantStorageType< Real > | |
| CConstantStorageType< RealVector > | |
| CConstantStorageType< std::vector< Real > > | |
| CHexa3DFixture::ConstFunctor | |
| CLagrangeP1Line1DFixture::ConstFunctor | |
| CLagrangeP1Line2DFixture::ConstFunctor | |
| CLagrangeP1Line3DFixture::ConstFunctor | |
| CPrism3DFixture::ConstFunctor | |
| CLagrangeP1Quad2DFixture::ConstFunctor | |
| CLagrangeP1Quad3DFixture::ConstFunctor< SF > | |
| CLagrangeP1Tetra3DFixture::ConstFunctor | |
| CLagrangeP1Triag2DFixture::ConstFunctor | |
| CLagrangeP1Triag3DFixture::ConstFunctor | |
| CLagrangeP1Line2DFixture::ConstVectorField | Returns the scalar product of a constant vector field and the local element normal |
| CLagrangeP1Quad3DFixture::ConstVectorField | Returns the scalar product of a constant vector field and the local element normal |
| CLagrangeP1Triag3DFixture::ConstVectorField | Returns the scalar product of a constant vector field and the local element normal |
| CCore_fixture | |
| CCoreInit | |
| CCoreWrapper | |
| CCorrectionMatrix | |
| CCrosswindDiffusion | |
| CCustomLaplacian | |
| CCustomLaplacianApply | |
| CPEOperationsFixture::custommult | Example custom function |
| CCustomSFOp< CustomT > | |
| CCustomTerminal | |
| ►CData | |
| CData | |
| ►CData | |
| CData | |
| CData | |
| CDataComponentWrapperFixture | |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ChildType< I >::DataType< T > | Keep the type, by default |
| CNodeData< VariablesT, NbDims >::DataType< I > | Return the type of the data stored for variable I (I being an Integral Constant in the boost::mpl sense) |
| CElementData< VariablesT, VariablesEtypeTT, SupportEtypeT, EquationVariablesInT >::DataType< I > | Return the type of the data stored for variable I (I being an Integral Constant in the boost::mpl sense) |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ChildType< I >::DataType< Var< VarI, T > > | Convert numbered variables to their data |
| CDefineTypeOp< I, Expr > | Ease application of DefineType as an MPL lambda expression, and strip the Var encapsulation |
| CDeleter< BASE > | Functor for deleting objects by calling the safer delete_ptr function |
| CNodeData< VariablesT, NbDims >::DeleteVariablesData | Delete stored per-variable data |
| CElementData< VariablesT, VariablesEtypeTT, SupportEtypeT, EquationVariablesInT >::DeleteVariablesData | Delete stored per-variable data |
| CDerivativeInPoint | |
| CDictionaryTests_Fixture | |
| CVariablesDescriptor::Dimensionalities | |
| CDimensionIdxTag | Tags terminals that will be replaced with the current dimension |
| CCCore::DirContent | |
| CProtoBenchmarkFixture::DirectArrays | |
| CDirichletBCTag | Tag for a Dirichlet BC |
| CDiscontinuityCapture | Stabilization as described by Tezduyar et al |
| CCommPattern::dist_struct | Helper struct for setup function |
| ►Cdivides | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::divides, Dummy > | |
| CDivOp | Evaluate the divergence |
| CDNSBrownianCollisionKernel< dim > | Combined DNS and Brownian coagulation |
| CDNSCollisionKernel< dim > | |
| CDoArrayDiff | |
| CDoDiff | |
| ►Cdomain | |
| CNodeLooperDim< ExprT, NbDimsT >::NodesDomain | |
| CDynArrayBufferT< T > | |
| CEigenFixture | Fixture for each test of Eigen |
| CEigenProductType< LeftT, RightT > | 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< Dim > | Dummy shape function type used for element-based fields |
| CElementData< VariablesT, VariablesEtypeTT, SupportEtypeT, EquationVariablesInT > | |
| CForAllElementsT< ActionT >::ElementLooper | |
| CElementLooper< ElementTypesT, ExprT > | Mpl::for_each compatible functor to loop over elements, using the correct shape function for the geometry |
| CElementLooperImpl< DataT > | Helper struct to launch execution once all shape functions have been determined |
| CElementMatrixSize< MatrixSizesT, EquationVariablesT > | Calculate the size of the element matrix |
| CElementNodeView< NbNodes, NbRows, NbCols > | View of nodal data, allowing modification of the referenced data |
| CElementNodeView< NbNodes, 1, 1 > | Specialization for single Real values |
| CElementQuadratureTag | Tags a gauss-quadrature loop for the following expressions |
| CElementRHS | Reperesents element RHS vector |
| CElementTypeBase< ETYPE, TR > | Fallback class if a concrete Element Type doesn't implement a static function |
| ►CElementTypeBase< Hexa3D, Hexa3D_traits > | |
| 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 |
| ►CElementTypeBase< Line1D, Line1D_traits > | |
| 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 | 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 |
| ►CElementTypeBase< Line2D, Line2D_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 | 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 | 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 |
| ►CElementTypeBase< Line3D, Line3D_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 |
| ►CElementTypeBase< Point1D, Point1D_traits > | |
| 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 |
| ►CElementTypeBase< Point2D, Point2D_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 |
| ►CElementTypeBase< Point3D, Point3D_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 |
| ►CElementTypeBase< Prism3D, Prism3D_traits > | |
| 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 |
| ►CElementTypeBase< Quad2D, Quad2D_traits > | |
| 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 |
| 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 | 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 |
| ►CElementTypeBase< Quad3D, Quad3D_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 |
| 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 |
| ►CElementTypeBase< Tetra3D, Tetra3D_traits > | |
| 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 |
| ►CElementTypeBase< Triag2D, Triag2D_traits > | |
| 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 | 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 | 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 | 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 |
| ►CElementTypeBase< Triag3D, Triag3D_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 |
| CElementTypeFaceConnectivity | Stores connectivity information about the faces that form the cell boundary |
| CElementVectorTag | |
| ►Cenable_shared_from_this | |
| CComponent | Base class for defining CF components |
| CTCPConnection | Manages a TCP/IP connection between two entities where one is a server and the other one is a client |
| CMeshWriter::EntitiesFilter | Predicate to check if a Entities component is to be included |
| CEntity | Low storage struct to uniquely identify one element |
| CEquationVariables< ExprT, NbVarsT > | Calculate if a variable is part of an equation |
| CEquationVariablesOp< I, ExprT > | Wrap IsEquationVariable as a lambda expression |
| ►CErrorHandler | |
| CMyErrorHandler | |
| CEtypeTVariableData< ETYPE, SupportEtypeT, Dim, IsEquationVar > | Data associated with field variables |
| CEtypeTVariableData< ElementBased< 1 >, SupportEtypeT, 1, IsEquationVar > | Data for scalar element-based fields |
| CEtypeTVariableData< ElementBased< Dim >, SupportEtypeT, Dim, IsEquationVar > | Data for element-based fields |
| CEuler2DCons | |
| CIndexLooper< GrammarT >::impl< ExprT, StateT, DataT >::EvalExpr< I > | |
| CExpressionGroup< GrammarT >::impl< ExprT, StateT, DataT >::evaluate_expr | |
| CRestrictToElementType< GrammarT >::impl< ExprT, StateT, DataT >::evaluate_expr | |
| CElementQuadratureEval< GrammarT >::impl< ExprT, StateT, DataT >::evaluate_expr | Fusion functor to evaluate each child expression using the GrammarT supplied in the template argument |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::EvaluatedChild< Idx > | Helper to get the variable type at a child of an expression |
| ►Cexception | STL class |
| ►CException | Base class for all Exceptions in CF |
| CBadPointer | |
| CBadValue | |
| CCastingFailed | |
| CFailedAssertion | |
| CFailedToConverge | |
| CFileFormatError | |
| CFileSystemError | |
| CFloatingPointError | |
| CIllegalCall | |
| CInvalidStructure | |
| CInvalidURI | Exception thrown when a string does not construct a valid path |
| CNotEnoughMemory | |
| CNotImplemented | |
| CNotSupported | |
| COSystemError | |
| CParallelError | |
| CParsingFailed | |
| CProtocolError | |
| CSegmentationFault | |
| CSetupError | |
| CShouldNotBeHere | |
| CSignalError | |
| CURLError | |
| CValueExists | |
| CValueNotFound | |
| CXmlError | |
| COutOfBounds | Exception thrown when a certain value is not found in a storage or container |
| CZeroDeterminant | Exception thrown when a Zero determinant matrix is found |
| CCGNSException | |
| CNetworkError | Exception thrown when the server can not open its socket |
| CUnknownClientId | Exception thrown when a given client id could not be associated to any existing client |
| ►Cruntime_error | STL class |
| CLibLoadingError | Not deriving from common::Exception to avoid the automatic error output |
| ►CExpression | Abstract interface for classes that can hold a proto expression |
| ►CExpressionBase< ExprT > | Boilerplate implementation |
| CElementsExpression< ExprT, ElementTypes > | |
| CNodesExpression< ExprT, DimsT > | Expression for looping over nodes |
| CExpressionGroupTag | Tags a terminal that triggers expression grouping |
| CExpressionProperties< ExprT > | Convenience struct to get easy access to the numberof variables and their type |
| CExpressionRunner< ElementTypesT, ExprT, SupportETYPE, VariablesT, VariablesEtypesT, NbVarsT, VarIdxT > | 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 |
| ►Cextends | |
| CComponentWrapper< ComponentT, TagT > | Proto-ready terminal type for wrapping a component |
| CFieldVariable< I, T > | |
| CLSSWrapper< TagT > | Proto-ready terminal type for wrapping a component |
| CNodeLooperDim< ExprT, NbDimsT >::NodesExpressionStored< ProtoExprT > | Wraps a given expression, so the value that it represents can be stored inside the expression itself |
| CStoredMatrixExpression< ExprT, MatrixT > | Wraps a given expression, so the value that it represents can be stored inside the expression itself |
| CFieldVariable< 0, cf3::solver::actions::Proto::VectorField > | |
| CFieldVariable< 0, ScalarField > | |
| CFieldVariable< 1, cf3::solver::actions::Proto::ScalarField > | |
| CFieldVariable< 2, cf3::solver::actions::Proto::VectorField > | |
| CFieldVariable< 3, cf3::solver::actions::Proto::ScalarField > | |
| CFieldVariable< 3, cf3::solver::actions::Proto::VectorField > | |
| CFieldVariable< 4, cf3::solver::actions::Proto::VectorField > | |
| CFieldVariable< 5, cf3::solver::actions::Proto::VectorField > | |
| CFieldVariable< 6, cf3::solver::actions::Proto::ScalarField > | |
| CFieldVariable< 7, cf3::solver::actions::Proto::ScalarField > | |
| CFieldVariable< 8, cf3::solver::actions::Proto::VectorField > | |
| CLSSWrapper< DirichletBCTag > | |
| CLSSWrapper< SolutionVectorTag > | |
| CLSSWrapper< SystemMatrixTag > | |
| CLSSWrapper< SystemRHSTag > | |
| CExtractDiagTag | Terminal to indicate we want a diagonal |
| Cf | |
| CFace2Cell | |
| CFaceCellConnectivity_Fixture | |
| CFaceCompare | |
| CFactoryFixture | |
| CReader::Field | |
| ►CFieldBase | Base class for field data |
| CScalarField | Field data for a scalar field |
| CVectorField | Field data for a vector having the dimension of the problem |
| CFieldWidth< T, SF > | 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 |
| CNRemoteFSBrowser::FileInfo | |
| CElementData< VariablesT, VariablesEtypeTT, SupportEtypeT, EquationVariablesInT >::FillRhs | Set the element on each stored data item |
| CFilterElementField< IsEqVarT, VariableSFT > | |
| CFilterElementField< IsEqVarT, boost::mpl::void_ > | |
| CFilterEquationVars< EquationVariablesT, VariablesEtypeTT, SupportEtypeT > | Filter out element-based fields from the possible equation variables |
| CFilterMatrixSizes< MatrixSizesT, EquationVariablesT > | Filter the matrix size so equation variables are the only ones left with non-zero size |
| CNodeLooperDim< ExprT, NbDimsT >::FindDict | |
| CFixture | |
| CFloatingPoint< RawType > | |
| CForEachDimensionTag | Tags a terminal that indicates that indicates the argument should be evaluated for each dimension index |
| CForeachFixture | |
| CFromString< TYPE > | A struct, since partial specializations of functions is not allowed |
| CFromString< Handle< ComponentT > > | |
| ►Cfunction | |
| CIsSubCols< IdxT > | Match subrows |
| CIsSubMatrix< IdxT > | Match submatrices |
| CIsSubRows< IdxT > | Match subrows |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::function, Dummy > | |
| ►CFunctionBase | Base class of all functions that can be evaluated using "default" C++ semantics |
| Cpow_fun< Exp > | Pow function based on Proto docs example |
| CMomentSourceFunctor< CollisionKernelT > | Functor to compute the moment source terms |
| CEquilibriumEuler::VelocityFunctor | |
| CEquilibriumEulerConvergence::ConvergenceFunctor | |
| CSquaredParticleRadius | |
| CSumVectorNorm | |
| CFunctionParser_Fixture | |
| CFunctorForDim< Dim > | |
| CFunctorForDim< 1 > | |
| CFunctorForDim< 2 > | |
| CFunctorForDim< 3 > | |
| CGaussIntegrator< Order, Shape > | |
| CQuad< P >::GaussLegendreQuadrature | |
| CHexa< P >::GaussLegendreQuadrature | |
| CLine< P >::GaussLegendreQuadrature | |
| CGaussMappedCoords< Order, Shape > | Stores pre-computed mapped coords and weights for all gauss point locations |
| CGaussMappedCoordsImpl< Order, Shape > | 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 > | |
| CGaussOrder< Order > | Static constant for the Gauss integration order |
| CGaussPoints< Order > | This file hides some implementation details of Gauss integration |
| CGaussPoints< 16 > | |
| CGaussPoints< 2 > | |
| CGaussPoints< 32 > | |
| CGaussPoints< 4 > | |
| CGaussPoints< 8 > | |
| CGaussPointTag< OrderT > | |
| CGaussWeightTag< OrderT > | |
| CGeometricSupport< ETYPE > | Functions and operators associated with a geometric support |
| CGeometricSupport< SupportEtypeT > | |
| CGeoShape | |
| Cget_mpi_op< T, Op, selector > | 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 > | |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::GetChild< ChildT > | |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::GetChild< Var< I, T > > | Specialization to get the associated data |
| CMakeVarData< VariablesT, SupportEtypeT, ShapeFunctionsT, EquationVariablesT, MatrixSizesT, EMatrixSizeT >::apply< I >::GetEETypeT< AVarT, AnETypeT > | |
| CMakeVarData< VariablesT, SupportEtypeT, ShapeFunctionsT, EquationVariablesT, MatrixSizesT, EMatrixSizeT >::apply< I >::GetEETypeT< boost::mpl::void_, AnETypeT > | |
| CGetElementResultType< T, ElementBasedT > | Dummy for non-element fields |
| CGetElementResultType< T, ElementBased< Dim > > | |
| CGetNbNodes< EquationDataT > | Helper struct to get the number of element nodes |
| CGetOrder< I, DataT, ExprT > | Get the order of variable I |
| CGaussIntegral::GetOrder< T > | Helper structs |
| CGaussIntegral::GetOrder< IntegralTag< boost::mpl::int_< I > > > | |
| CGetOrderFromData< DataT, VarT > | |
| CGetOrderFromData< DataT, boost::mpl::void_ > | |
| CGidConverter | |
| CGidToLocal | Helper class to convert global to local indices |
| Cglobal_fixture | |
| CGlobalFixture | Use a global fixture, so mesh creation happens only once |
| CgmshReaderMPITests_Fixture | |
| CGnuplotPty | |
| CGradientOp | Evaluate the gradient |
| CReader::GroupData | |
| CGrowl | |
| CHandle< T > | Safe pointer to an object. This is the supported method for referring to components |
| CHandle< ActionT > | |
| CHandle< CConcrete1 > | |
| CHandle< cf3::common::Component > | |
| CHandle< cf3::common::Component const > | |
| CHandle< cf3::common::Map > | |
| CHandle< cf3::common::Option > | |
| CHandle< cf3::common::PE::CommWrapper > | |
| CHandle< cf3::common::Table > | |
| CHandle< cf3::math::BoundingBox > | |
| CHandle< cf3::math::LSS::ParameterList > | |
| CHandle< cf3::math::LSS::System > | |
| CHandle< cf3::math::LSS::ThyraOperator const > | |
| CHandle< cf3::math::LSS::ThyraVector > | |
| CHandle< cf3::math::LSS::TrilinosCrsMatrix > | |
| CHandle< cf3::math::LSS::TrilinosVector > | |
| CHandle< cf3::math::VariableManager > | |
| CHandle< cf3::mesh::AInterpolator > | |
| CHandle< cf3::mesh::APointInterpolator > | |
| CHandle< cf3::mesh::Connectivity > | |
| CHandle< cf3::mesh::Dictionary > | |
| CHandle< cf3::mesh::Dictionary const > | |
| CHandle< cf3::mesh::Domain > | |
| CHandle< cf3::mesh::ElementFinder > | |
| CHandle< cf3::mesh::ElementType > | |
| CHandle< cf3::mesh::Entities > | |
| CHandle< cf3::mesh::Entities const > | |
| CHandle< cf3::mesh::FaceCellConnectivity > | |
| CHandle< cf3::mesh::FaceConnectivity > | |
| CHandle< cf3::mesh::Field > | |
| CHandle< cf3::mesh::Field const > | |
| CHandle< cf3::mesh::InterpolationFunction > | |
| CHandle< cf3::mesh::LoadMesh > | |
| CHandle< cf3::mesh::MergedParallelDistribution > | |
| CHandle< cf3::mesh::Mesh > | |
| CHandle< cf3::mesh::Mesh const > | |
| CHandle< cf3::mesh::MeshMetadata > | |
| CHandle< cf3::mesh::MeshTransformer > | |
| CHandle< cf3::mesh::Octtree > | |
| CHandle< cf3::mesh::ParallelDistribution > | |
| CHandle< cf3::mesh::Quadrature > | |
| CHandle< cf3::mesh::Region > | |
| CHandle< cf3::mesh::Region const > | |
| CHandle< cf3::mesh::ShapeFunction > | |
| CHandle< cf3::mesh::Space > | |
| CHandle< cf3::mesh::Space const > | |
| CHandle< cf3::mesh::StencilComputer > | |
| CHandle< cf3::mesh::UnifiedData > | |
| CHandle< cf3::mesh::WriteMesh > | |
| CHandle< cf3::physics::PhysModel > | |
| CHandle< cf3::solver::actions::Probe > | |
| CHandle< cf3::solver::History > | |
| CHandle< cf3::solver::TermComputer > | |
| CHandle< cf3::solver::Time > | |
| CHandle< cf3::UFEM::InitialConditions > | |
| CHandle< cf3::UFEM::InnerLoop > | |
| CHandle< cf3::UFEM::LSSAction > | |
| CHandle< cf3::UFEM::LSSActionUnsteady > | |
| CHandle< cf3::ui::core::CNode > | |
| CHandle< common::cf3::common::Action > | |
| CHandle< common::cf3::common::ActionDirector > | |
| CHandle< common::cf3::common::Component > | |
| CHandle< common::cf3::common::DynTable< cf3::mesh::Face2Cell > > | |
| CHandle< common::cf3::common::DynTable< cf3::mesh::SpaceElem > > | |
| CHandle< common::cf3::common::DynTable< Uint > > | |
| CHandle< common::cf3::common::Group > | |
| CHandle< common::cf3::common::Link > | |
| CHandle< common::cf3::common::List< bool > > | |
| CHandle< common::cf3::common::List< Uint > > | |
| CHandle< common::cf3::common::Map< Uint, Uint > > | |
| CHandle< common::cf3::common::Table< bool > > | |
| CHandle< common::cf3::common::Table< Real > > | |
| CHandle< common::cf3::common::Table< Real > const > | |
| CHandle< common::cf3::common::Table< Uint > > | |
| CHandle< common::Component > | |
| CHandle< common::PE::cf3::common::PE::CommPattern > | |
| CHandle< common::PE::CommPattern > | |
| CHandle< common::PE::Manager > | |
| CHandle< core::cf3::ui::core::CNode > | |
| CHandle< Domain > | |
| CHandle< ELEMENTFINDER > | |
| CHandle< Entities const > | |
| CHandle< FieldManager > | |
| CHandle< INTERPOLATIONFUNCTION > | |
| CHandle< LSS::cf3::math::LSS::Matrix > | |
| CHandle< LSS::cf3::math::LSS::SolutionStrategy > | |
| CHandle< LSS::cf3::math::LSS::Vector > | |
| CHandle< LSS::System > | |
| CHandle< math::cf3::math::VariablesDescriptor > | |
| CHandle< math::LSS::cf3::math::LSS::System > | |
| CHandle< math::LSS::SolutionStrategy > | |
| CHandle< math::LSS::SolveLSS > | |
| CHandle< math::LSS::System > | |
| CHandle< math::LSS::Vector > | |
| CHandle< math::VariablesDescriptor > | |
| CHandle< Mesh > | |
| CHandle< mesh::cf3::mesh::Dictionary > | |
| CHandle< mesh::cf3::mesh::Dictionary const > | |
| CHandle< mesh::cf3::mesh::Entities > | |
| CHandle< mesh::cf3::mesh::Field > | |
| CHandle< mesh::cf3::mesh::Mesh > | |
| CHandle< mesh::cf3::mesh::MeshReader > | |
| CHandle< mesh::cf3::mesh::MeshWriter > | |
| CHandle< mesh::cf3::mesh::NodeConnectivity > | |
| CHandle< mesh::cf3::mesh::PointInterpolator > | |
| CHandle< mesh::cf3::mesh::Region > | |
| CHandle< mesh::cf3::mesh::Space const > | |
| CHandle< mesh::Mesh > | |
| CHandle< Model > | |
| CHandle< physics::PhysModel > | |
| CHandle< solver::actions::cf3::solver::actions::WriteRestartFile > | |
| CHandle< solver::actions::Proto::cf3::solver::actions::Proto::ProtoAction > | |
| CHandle< solver::cf3::common::ActionDirector > | |
| CHandle< solver::cf3::solver::ComputeLNorm > | |
| CHandle< solver::cf3::solver::ComputeRHS > | |
| CHandle< solver::cf3::solver::History > | |
| CHandle< solver::cf3::solver::PDE > | |
| CHandle< solver::cf3::solver::Solver > | |
| CHandle< solver::cf3::solver::Time > | |
| CHandle< solver::cf3::solver::TimeStepComputer > | |
| CHandle< STENCILCOMPUTER > | |
| CHandle< SubCompT > | |
| CHasSubExpr< ExprT, MatchingGrammarT > | |
| CReader::HeaderData | |
| CHeatSpecialized | |
| CHexa3D_traits | |
| CHexa3DFixture | |
| CHexa_traits | |
| CHexa_traits | |
| CHexa_traits< P > | |
| CHGCollection | |
| CPythonSyntaxeHighlighter::HighlightingRule | |
| CHilbert | Class to compute a global index given a coordinate, based on the Hilbert Spacefilling Curve |
| CHilbertNumberingTests_Fixture | |
| CHistoryEntry | Helper class to output one entry to an output stream |
| ►CI | |
| CVar< I, T > | Creates a variable that has unique ID I |
| ►CIAction | Abstract interface for actions. You probably want to use Action as a base to start from, since that implements IAction as a component |
| CAction | Component that executes an action. Implementation of the IAction interface as a component, exposing the execute function as a signal |
| CIdentityTag | |
| Cimaxdiv_t | |
| CComponentIteratorRangeSelector< ParentT, ComponentT, Predicate >::impl< IsAbstractT, dummy > | |
| CComponentIteratorRangeSelector< ParentT, ComponentT, Predicate >::impl< boost::false_type, dummy > | |
| CComponentIteratorRangeSelector< ParentT, ComponentT, Predicate >::impl< boost::true_type, dummy > | |
| CProtoAction::Implementation | |
| CModel::Implementation | |
| CModelUnsteady::Implementation | |
| CSolver::Implementation | |
| CBinaryDataReader::Implementation | |
| CBinaryDataWriter::Implementation | |
| CDynamicModel::Implementation | |
| CBoundaryConditions::Implementation | |
| CComponentWrapper::Implementation | |
| CDirectStrategy::Implementation | |
| CLSSAction::Implementation | |
| CRCGStrategy::Implementation | |
| CTrilinosStratimikosStrategy::Implementation | |
| CFieldManager::Implementation | |
| CVariablesDescriptor::Implementation | |
| CBlockArrays::Implementation | |
| CDomain::Implementation | |
| ►CImplicitFunction | |
| CSphereFunction | Sphere around the origin with radius r |
| CIndexedNodeAssignmentCases< GrammarT, IndexGrammarT > | |
| CArrayElementRemover::IndexMapping | |
| CIndexTag< T > | Tag terminals used as index |
| CIndexType< T > | Extract an index-type from a var |
| CIndexType< Var< I, T > > | |
| CNodeData< VariablesT, NbDims >::InitVariablesData | Initializes the pointers in a VariablesDataT fusion sequence |
| CElementData< VariablesT, VariablesEtypeTT, SupportEtypeT, EquationVariablesInT >::InitVariablesData | Initializes the pointers in a VariablesDataT fusion sequence |
| CIndexLooper< GrammarT >::impl< ExprT, StateT, DataT >::InnerLoop< NJ > | |
| CIntegralConstantTag | |
| CIntegralOrder< ElementT > | Helper to detemine the appropriate default integration order |
| CIntegralOrder< mesh::LagrangeP1::Tetra3D > | Tetrahedra get order 1 |
| CIntegralOrder< mesh::LagrangeP1::Triag2D > | Triangles get order 1 |
| CIntegralTag< OrderT > | Tag for an integral, wit the order provided as an MPL integral constant |
| CIntegrate | |
| CIntegrationOrder< Uint > | Determine integration order based on the order of the shape function |
| CIntegrationOrder< 1 > | |
| CIntegrationOrder< 2 > | |
| CInterpolateInPoint | |
| CEtypeTVariableData< ETYPE, SupportEtypeT, Dim, IsEquationVar >::InterpolationImpl< VarDim, Dummy > | Interpolation of a field |
| CEtypeTVariableData< ETYPE, SupportEtypeT, Dim, IsEquationVar >::InterpolationImpl< 1, Dummy > | Interpolation of a scalar field |
| CEtypeTVariableData< ETYPE, SupportEtypeT, Dim, IsEquationVar >::InterpolationImpl< Dim > | |
| CInterpreter | Command Line and script interpreter |
| Cis_connection | |
| Cis_const_comptible< T, Y > | Helper struct to put const-correctness in a short expression |
| Cis_signal | |
| CIsBuilderReducedName | Checks the builder reduced name matches The reduced name is the name without the namespace preceding it |
| CIsCellType | Compile-time predicate to determine if the given shape function represents a volume element, i.e. dimensions == dimensionality |
| CIsCompatibleWith< ETYPE > | |
| CIsComponentName | |
| CIsComponentTag | |
| CIsComponentTrue | |
| CIsComponentType< CType > | |
| CIsEdgeType | Compile-time predicate to determine if the given shape function represents a volume element, i.e. dimensions == dimensionality |
| CIsElementRegion | |
| CIsElementsSurface | |
| CIsElementsVolume | |
| CIsElementType< ETYPE > | |
| CIsEquationData | Predicate to check if data belongs to an equation variable |
| CIsFaceType | Compile-time predicate to determine if the given shape function represents a volume element, i.e. dimensions == dimensionality |
| CIsGroup | |
| CIsMinimalOrder< Order > | Compile-time predicate to determine if the given shape function or element type has at least the given order |
| CIsotermalFluid2D | Store local fluid properties |
| CForAllElementsT< ActionT >::IsShapeFunction< TYPE > | Predicate class to test if the region contains a specific element type |
| CIterativeAlgo | |
| ►Citerator_facade | |
| CComponentIterator< T > | ComponentIterator class, can linearize a complete tree of components |
| CListBufferIterator< BufferT > | |
| CElementIterator | |
| Citerator_range< T > | |
| ►Citerator_range< boost::filter_iterator< Predicate, ComponentIterator< T > > > | |
| CComponentIteratorRange< T, Predicate > | |
| ►Citerator_range< boost::filter_iterator< Predicate, ComponentIterator< T const > > > | |
| CConstComponentIteratorRange< T, Predicate > | |
| CQuad2D::JacobianCoefficients | Convenience struct to easily access the elements that make up the jacobian |
| CQuad3D::JacobianCoefficients | Convenience struct to easily access the elements that make up the jacobian |
| CQuad3D::JacobianCoefficients | Convenience struct to easily access the elements that make up the jacobian |
| CLagrangeP1Line1DFixture | |
| CLagrangeP1Line2DFixture | |
| CLagrangeP1Line3DFixture | |
| CLagrangeP1Quad2DFixture | |
| CLagrangeP1Quad3DFixture | |
| CLagrangeP1Tetra3DFixture | |
| CLagrangeP1Triag2DFixture | |
| CLagrangeP1Triag3DFixture | |
| CLagrangeP2BTriag2DFixture | |
| CLastCallbackInfo | |
| CMap< KEY, DATA >::LessThan | |
| CEigenPlusAssignProductEval< GrammarT >::impl< ExprT, StateT, DataT >::LHSHelper< T > | |
| CEigenPlusAssignProductEval< GrammarT >::impl< ExprT, StateT, DataT >::LHSHelper< const T & > | |
| CLine1D_traits | |
| CLine1D_traits | |
| CLine2D_traits | |
| CLine2D_traits | |
| CLine2D_traits | |
| CLine3D_traits | |
| CLine_traits | |
| CLine_traits | |
| CLine_traits | |
| CLine_traits | |
| CLine_traits< P > | |
| CListBufferT< T > | A Buffer that is constructed passing a boost::multi_array<T,2> table. This class allows to interface this table by using a buffer |
| CListeningInfo | Holds MPI listening information |
| CListeningThread | Listener for MPI messages |
| CListMethods< ValueT > | Extra methods for Table |
| Clocal_fixture | |
| CLocalImplicit | |
| CLogLevelFilter | Filters log messages corresponding to their level |
| CLogLevelFilterFixture | |
| CLogMessage | |
| CLogStampFilter | Prepends a stamp to the log messages |
| CLogStampFilter_Fixture | |
| CLogStream | Manages a log stream |
| ►CLogStringForwarder | |
| CLogForwarder | Appends LoggingEvents to the remote client log window |
| CNLog | Log component |
| CLoopElems< FunctorT > | |
| CLSSAtomicFixture | |
| CLSSDistributedMatrixFixture | |
| CLSSIndexConverter | Convert LSS indices (copy from base proto code) |
| CLSSSymmetricDirichletFixture | |
| CLSSSystem_EmptyLSSFixture | |
| CLSSWrapperImpl< TagT > | |
| CLSSWrapperImpl< DirichletBCTag > | |
| CLSSWrapperImpl< SolutionVectorTag > | |
| CLSSWrapperImpl< SystemMatrixTag > | |
| CLSSWrapperImpl< SystemRHSTag > | |
| CLumpTag | |
| CVolumeSFFixture::MakeSFNodesPair< SF > | Functor to create a fusion pair between a shape function and its node matrix |
| CMakeSFOp< OpT > | Helper struct to declare custom types |
| CMakeSFOp< cf3::UFEM::ComputeSACoeffs > | |
| CMakeSFOp< cf3::UFEM::ComputeTauImpl > | |
| CMakeSFOp< cf3::UFEM::CrosswindDiffusion > | |
| CMakeSFOp< cf3::UFEM::particles::DiscontinuityCapture > | |
| CMakeSFOp< detail::ComputeNuWALE > | |
| CMakeVarData< VariablesT, SupportEtypeT, ShapeFunctionsT, EquationVariablesT, MatrixSizesT, EMatrixSizeT > | Metafunction class for creating an appropriate data type |
| CMakeVarData< VariablesT, EtypeT, EtypeT, EquationVariablesT, MatrixSizesT, EMatrixSizeT > | |
| CMap | |
| CMapFixture | |
| CMath | |
| CMathOpDefaultCases< GrammarT > | Split up MapthOpDefault using cases, for better compilation performance |
| Cmatrix_array_mapper< rows, cols > | |
| CMatrixAssignOpsCases< SystemTagT > | Allowed block assignment operations |
| CMatrixInterpolationFixture | |
| CMatrixInverter_Fixture | |
| CMatrixSubscript< GrammarT, IntegersT >::impl< ExprT, StateT, DataT >::MatrixRef< MatrixT > | |
| CMatrixSubscript< GrammarT, IntegersT >::impl< ExprT, StateT, DataT >::MatrixRef< Eigen::Transpose< MatrixT > > | |
| CMatrixSizePerVar< VariablesT, VariablesSFT, SupportSF > | The size of the element matrix for each variable |
| CMatrixTypes< NDIM, NEQS, NVAR, NGRAD > | |
| CMatrixTypes< NDIM, NEQS > | |
| CMaxOrder< ExprT, DataT > | Get the maximum order of the shape functions used in Expr |
| Cmd5_context | |
| CMeshAdaptor | Class to adapt the mesh |
| CMeshComponent_Fixture | |
| CMeshConstruction_Fixture | |
| CMeshInterpolation_Fixture | |
| CMeshManipulationsTests_Fixture | |
| CMeshParameters | Parameters for mesh generation, as defined in the CGAL manual |
| CMeshReader | |
| CMeshReading_Fixture | |
| CMeshSourceGlobalFixture< MeshSize > | |
| CMeshTransformer_Fixture | |
| CMeshWriter | |
| CMetricTensor | |
| ►Cminus | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::minus, Dummy > | |
| ►Cminus_assign | |
| CIndexedNodeAssignmentCases< GrammarT, IndexGrammarT >::case_< boost::proto::tag::minus_assign, Dummy > | |
| CMatrixAssignOpsCases< SystemTagT >::case_< boost::proto::tag::minus_assign, Dummy > | |
| CNodeAssignmentCases< GrammarT >::case_< boost::proto::tag::minus_assign, Dummy > | |
| CMPIBufferTests_Fixture | |
| Cnat | |
| CNavierStokesAssemblyFixture | |
| CNavierStokesSpecializedAssembly | |
| ►Cnegate | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::negate, Dummy > | |
| CNetworkInfo | |
| CNeumannFixture | |
| CneuReaderMPITests_Fixture | |
| CNoCollisionKernel | |
| CNodalValuesTag | |
| CNodeAssignmentCases< GrammarT > | |
| CNodeData< VariablesT, NbDims > | |
| CNodeElementConnectivity_Fixture | |
| CNodeIdxOp | |
| CNodeLooper< ExprT > | Loop over nodes, using static-sized vectors to store coordinates |
| CNodeLooperDim< ExprT, NbDimsT > | Loop over nodes, when the dimension is known |
| CNodePacker | |
| CNodes_Fixture | |
| CNodesTimesDim< VariableT, SF, SupportSF > | 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 > | |
| CNodeUnpacker | Helper class to unpack nodes packed using NodePacker |
| CNodeVarData< T, Dim > | Struct keeping track of data associated with numbered variables in node expressions |
| CNodeVarData< ScalarField > | |
| CNodeVarData< VectorField, Dim > | |
| ►Cnoncopyable | |
| CAssertionManager | Manager of behavior of assertions |
| CBuildInfo | |
| CComponent | Base class for defining CF components |
| CConnection | |
| CCore | |
| ►CEnumT< EClass > | |
| CURI::Scheme::Convert | |
| CWorkerStatus::Convert | |
| CGeoShape::Convert | |
| CSUPGTypes::Convert | |
| CLogMessage::Convert | |
| CEventHandler | |
| CExceptionManager | Manager of behavior of exceptions |
| ►CLibLoader | |
| CPosixDlopenLibLoader | |
| CLibLoader | Class to load libraries in the Win32 OS |
| CLogger | Main class of the logging system |
| COSystem | |
| ►COSystemLayer | |
| COSystemLayer | |
| COSystemLayer | |
| COSystemLayer | |
| CComm | |
| CCommWrapperView< T > | |
| CSignal | |
| CTypeInfo | Handles type information This struct allows to associate a type to a string. It is a singleton |
| ►CProperties | |
| CDynamicModel::Properties | Physical properties |
| CLinEuler2D::Properties | Physical properties |
| CLinEuler3D::Properties | Physical properties |
| CScalar1D::Properties | Physical properties |
| CScalar2D::Properties | Physical properties |
| CScalar3D::Properties | Physical properties |
| CScalarSys2D::Properties | Physical properties |
| CFieldSynchronizer | Helper struct to synchronize fields at the end of a loop |
| CComputeTauImpl | Calculation of the stabilization coefficients for the SUPG method |
| CCounter | Custom op that just modifies its argument |
| ►CEnumT< Dimensionalities > | |
| CVariablesDescriptor::Dimensionalities::Convert | |
| CNonInstantiable< TYPE > | Derive from this class if you want a class that is not instantiable |
| ►CNonInstantiable< Protocol > | |
| CProtocol | |
| ►CNonInstantiable< Tags > | |
| CTags | |
| CProtocol::Tags | |
| CTags | |
| CTags | |
| CTags | |
| CLagrangeP1Line2DFixture::NormalVectorNorm | Returns the norm of the normal vector to the curve or surface element (equal to tangent in the case of Line2D) |
| CLagrangeP1Quad3DFixture::NormalVectorNorm | Returns the norm of the normal vector to the curve or surface element (equal to tangent in the case of Line2D) |
| CLagrangeP1Triag3DFixture::NormalVectorNorm | Returns the norm of the normal vector to the curve or surface element (equal to tangent in the case of Line2D) |
| CNormTag | |
| ►Cnot_ | |
| CIndexedNodeAssignmentCases< GrammarT, IndexGrammarT >::case_< Tag, Dummy > | |
| CMathOpDefaultCases< GrammarT >::case_< Tag, Dummy > | |
| CMatrixAssignOpsCases< SystemTagT >::case_< Tag, Dummy > | |
| CNodeAssignmentCases< GrammarT >::case_< Tag, Dummy > | |
| CNotifier | |
| Cnull_deleter | |
| CNumberedTermType< I, T > | Shorthand for terminals containing a numbered variable |
| Cnx_event_connector | Need to put things into a class to be reachable by the event callbacks |
| COcttree_Fixture | |
| CPEAllReduceFixture::optest | Test class with operator + to test if operations and all_reduce can work with it |
| CPEReduceFixture::optest | Test class with operator + to test if operations and reduce can work with it |
| CPEOperationsFixture::optest | Custom class for checking the non built-in way |
| ►COptionBuilder | Interface for option builders that can be registered with the factory |
| COptionArrayBuilder< TYPE > | |
| COptionComponentArrayBuilder< CTYPE > | Builder for OptionArrays of this component |
| COptionComponentBuilder< CTYPE > | Builder for OptionComponents |
| COptionTBuilder< TYPE > | Builders for OptionT components |
| COptionURIBuilder | |
| COptionFactory | Factory class to buikd options dynamically |
| ►COptionList | |
| CSignalOptions | Abstracts the use of XML when adding options to a signal frame |
| COptionListWrapper | |
| ►Cor_ | |
| CAssignNodalValues< GrammarT, IndexGrammarT > | Write to element nodal values |
| CBlockAccumulation< GrammarT > | Grammar matching block accumulation expressions |
| CCoordinatesGrammar | |
| CCustomSFOpTransform< OpImpl, GrammarT >::ChildGrammar | Catch field terminals first |
| 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< I > | Transform that extracts the type of variable I |
| CHasEvalVar< I > | |
| CHasSubGrammar< MatchingGrammarT > | Grammar matching expressions if they have a terminal with the index given in the template parameter |
| CMatchImplicitEval< I > | Returns true if an interpolation op is used |
| CDirichletBCGrammar< GrammarT > | Matches the proper formulation of Dirichlet BC |
| CEigenIndexing< GrammarT, IntegersT > | Indexing into Eigen expressions |
| CEigenMath< GrammarT, IntegersT > | Grammar for valid Eigen expressions, composed of primitives matching GrammarT |
| CEigenMultiplication< GrammarT > | Handle an expression that is filtered by Eigen |
| CElementGrammar | Matches and evaluates element-wise expressions |
| CElementMath | |
| CElementMathBase | |
| CElementMathImplicit | |
| CElementMathImplicitIndexed< I, J > | Grammar that allows looping over I and J indices |
| CElementMathIndexed< I, J > | |
| CElementMatrixGrammar | |
| CElementMatrixGrammarIndexed< I, J > | Gets submatrices of vector variables |
| CElementMatrixSubBlocks< IdxT > | Match but don't evaluate subblock-expressions |
| CElementMatrixTerm | Match element matrix terminals |
| CElementQuadratureMatch | Match quadrature expressions. THese call the grouping separately, so don't trigger on indices there |
| CElementSystemMatrixTerm | Match only element matrices that are used in a linear system |
| CEvalMappedCoords | Transform to evalate mapped coordinates |
| CExpandDimension | Replaces dimension placeholder with state |
| CExprVarArity | Gets the arity (max index) for the numbered variables |
| CFieldTypes | Match field types |
| CGaussGrammar | |
| CGroupGrammar< GrammarT > | Matches and evaluates groups of expressions matching GrammarT |
| CHasIdx< I > | Check if index I is used in the expression |
| CIndexValues< I, J > | Evaluate the value of both indices to the integral constants given in the template arguments |
| CIsEquationVariable< I > | Transform to set a range with true indicating a variable that has an equation, and false for no equation |
| CLazyIndexedGrammar< I, J > | |
| CMappedCoordTerms | Possible types for mapped coords |
| CMathTerminals | Matches terminal values that can be used in math formulas |
| CMatVec | Matches matrices and vectors |
| CNodalValues | Get nodal values |
| CNodeAssignGrammar< GrammarT, IndexGrammarT > | |
| CNodeGrammar | |
| CNodeLooperDim< ExprT, NbDimsT >::WrapExpression | |
| CNodeMath | |
| CNodeMathBase | Matches expressions that can be used as terms in math formulas for element expressions |
| CNodeMathIndexed< I, J > | |
| CParsedFunctionGrammar | |
| CReplaceConfigurableConstants | Grammar replacing ConfigurableConstants in an expression |
| CReplacePhysicsConstants | Grammar replacing PhysicsConstants in an expression |
| CRestrictToElementTypeGrammar< GrammarT > | |
| CRestrictToElementTypeGrammarSingle< GrammarT > | Matches and evaluates groups of expressions matching GrammarT, optionally restricting to certain element types |
| CScalar | Matches scalar terminals |
| CSFOps< GrammarT > | Shape-function related operations |
| CSingleExprElementGrammar | |
| CSingleExprNodeGrammar | Matches and evaluates element-wise expressions |
| CWrapExpression | Grammar to do the expression wrapping |
| 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) |
| ►CHasSubGrammar< boost::proto::terminal< Var< boost::mpl::int_< I >, boost::proto::_ > > > | |
| CUsesVar< I > | Grammar matching expressions if they have a terminal with the index given in the template parameter |
| ►CLazyIndexedGrammar< boost::mpl::int_< 0 >, boost::mpl::int_< 0 > > | |
| CLazyElementGrammar | Less restricitve grammar to get the result of expressions that are in an integral as well |
| CSimpleGrammar | Simple test grammar |
| COSystemFixture | |
| CIndexLooper< GrammarT >::impl< ExprT, StateT, DataT >::OuterLoop< NI, NJ, Dummy > | |
| CIndexLooper< GrammarT >::impl< ExprT, StateT, DataT >::OuterLoop< 1, 1, Dummy > | |
| ►CPackedObject | |
| 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 |
| CParallelFieldsTests_Fixture | |
| CParallelOverlapTests_Fixture | |
| CBlockArrays::Implementation::Patch | |
| CPEAllGatherFixture | |
| CPEAllReduceFixture | |
| CPEAllToAllFixture | |
| CPEBroadcastFixture | |
| CPECollectiveFixture | |
| CPEDatatypeFixture | |
| CPEFixture | |
| CPEGatherFixture | |
| CPEOperationsFixture | |
| CPEReduceFixture | |
| CPerfectGas | Use the perfect gas law to get density |
| CPeriodicData | |
| CPEScatterFixture | |
| CPhysicsConstant | Refers to a value from the physical model |
| CProtoAction::Implementation::PhysicsConstantLink | |
| CPhysicsConstantStorage | Storage for the values pointed to by a PhysicsConstant |
| ►CPhysModel | |
| CEuler2D | |
| ►Cplus | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::plus, Dummy > | |
| ►Cplus_assign | |
| CIndexedNodeAssignmentCases< GrammarT, IndexGrammarT >::case_< boost::proto::tag::plus_assign, Dummy > | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::plus_assign, Dummy > | |
| CMatrixAssignOpsCases< SystemTagT >::case_< boost::proto::tag::plus_assign, Dummy > | |
| CNodeAssignmentCases< GrammarT >::case_< boost::proto::tag::plus_assign, Dummy > | |
| CPoint | |
| CPoint | |
| CPoint | |
| CPoint1D_traits | |
| CPoint2D_traits | |
| CPoint3D_traits | |
| CPoint_traits | |
| CPoint_traits | |
| CPoint_traits | |
| CPoissonTriagAssembly | |
| ►Cpost_dec | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::post_dec, Dummy > | |
| ►Cpost_inc | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::post_inc, Dummy > | |
| ►Cpre_dec | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::pre_dec, Dummy > | |
| ►Cpre_inc | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::pre_inc, Dummy > | |
| CElementData< VariablesT, VariablesEtypeTT, SupportEtypeT, EquationVariablesInT >::PrecomputeData< ExprT > | Precompute variables data |
| CPressureRHS | |
| CPrism3D_traits | |
| CPrism3DFixture | |
| CPrism_traits | |
| CPrism_traits | |
| ►CProfiledTestFixture | Any test using this fixture (or a derivative) will be profiled |
| CComponentBenchFixture | |
| CProfiledFixture | Profile and time tests using this fixture |
| CProtoBenchmarkFixture | |
| CProfiler | |
| CProfiler | |
| CProfiler | |
| ►CPhysModel::Properties | |
| CEuler2D::Properties | |
| CProperties_Fixture | |
| CPropertyItem | |
| CPropertyList | |
| CPropertyListWrapper | |
| CProtoHeatFixture | |
| CProtoLSSFixture | |
| CProtoUnsteadyFixture | |
| Cprowl_connection | |
| CPTScotchTests_Fixture | |
| CPythonConsole::python_command | Used to store the pending command on the command stack |
| CPythonCodeContainer::PythonDict | |
| CScriptEngine::PythonDictEntry | 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 |
| ►CPythonListInterface | |
| CList< ValueT > | Tables can be used as python lists |
| CTableList< ValueT > | Tables can be used as python lists |
| CPythonListToAny | Conversion for lists |
| CPythonToAny | Conversion for basic types |
| ►CQAbstractItemModel | |
| CCommitDetails | Model that handles modified options details |
| CNJournalBrowser | |
| CNRemoteFSBrowser | |
| CNTree | Tree model |
| 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 |
| CFavoritesModel | Model that manages a list of favorite directories |
| ►CQApplication | |
| CApplication | |
| ►CQCompleter | |
| CPythonCompleter | Dervied QCompleter to allow the use of a tree model for completion model |
| ►CQDialog | |
| CAboutCFDialog | |
| CBrowserDialog | |
| CConfirmCommitDialog | Dialog used to ask user whether modifcations have to be committed before continuing |
| CJournalBrowserDialog | |
| CModifiedOptionsDialog | Dialog that shows commit details |
| CSelectPathDialog | |
| CSignalInspectorDialog | |
| CSignatureDialog | |
| ►CQFormLayout | |
| COptionLayout | Panel to m_view and modify options() of an object |
| ►CQLabel | |
| CColorSelector | This is QLabel that display a color picker when clicked and can give this color back |
| CQList< T > | |
| CQList< cf3::ui::core::ActionInfo > | |
| CQList< cf3::ui::core::CommitDetailsItem * > | |
| CQList< cf3::ui::core::NRemoteFSBrowser::FileInfo * > | |
| CQList< cf3::ui::core::PropertyItem * > | |
| CQList< cf3::ui::core::Transaction * > | |
| CQList< cf3::ui::core::TreeNode * > | |
| CQList< cf3::ui::graphics::FavoritesModel::SpecialDir > | |
| CQList< common::cf3::common::UUCount > | |
| CQList< common::SignalArgs * > | |
| CQList< common::SignalArgs > | |
| CQList< QPersistentModelIndex > | |
| CQList< QPointer< pqPipelineSource > > | |
| CQList< QString > | |
| ►CQListView | |
| CDraggableListWidget | |
| ►CQListWidget | |
| CCustomListWidget | Simple inherited class to reimplement some behavior |
| ►CQMainWindow | |
| CMainWindow | Client main window |
| CQMap< T, V > | |
| CQMap< cf3::ui::graphics::MainWindow::MainWinActions, QAction * > | |
| CQMap< common::cf3::common::UUCount, cf3::ui::graphics::TabInfo > | |
| CQMap< common::cf3::common::UUCount, int > | |
| CQMap< int, int > | |
| CQMap< QAction *, bool > | |
| CQMap< QAction *, core::cf3::ui::core::ActionInfo > | |
| CQMap< QAction *, int > | |
| CQMap< QString, boost::shared_ptr< common::Component > > | |
| CQMap< QString, cf3::ui::core::Transaction * > | |
| CQMap< QString, cf3::ui::graphics::GraphicalValue * > | |
| CQMap< QString, common::XML::XmlNode > | |
| CQMap< QString, QIcon > | |
| ►CQObject | |
| CCNodeNotifier | Handles signal emitting for CNode class |
| CJournalNotifier | |
| CNBrowser | Component that manages remote browsers. This class subclasses CNode class |
| CNJournal | |
| CNLink | Client corresponding component for cf3::common::Link |
| CNLog | Log component |
| 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 |
| CRemoteDispatcher | |
| CTreeNode | Handles a CNode component in the tree |
| CJournalBrowserBuilder | |
| CSignalManager | |
| CC3DView | C3DView class |
| CN3DView | Class used with C3DView to provide 3D mesh view |
| CNPlotXY | |
| ►CQPlainTextEdit | |
| ►CPythonCodeContainer | This class contains common code for python editors |
| CPythonCodeEditor | Simple python editor |
| 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 |
| ►CQProcess | |
| CSSHTunnel | |
| ►CQSortFilterProxyModel | |
| CFileFilter | |
| CFilteringModel | |
| ►CQSplitter | |
| CRemoteFileCopy | |
| ►CQStandardItem | |
| CCustomStandardItem | Dervied QStandardItem to allow case insensitive sorting |
| CFilesListItem | Adds a functionnality to QStandardItem class |
| ►CQSyntaxHighlighter | |
| CPythonSyntaxeHighlighter | Simple syntaxe highlighter |
| ►CQTabWidget | |
| CTabBuilder | |
| ►CQTextBlockUserData | |
| CTextBlockErrorData | |
| ►CQTextEdit | |
| CLoggingList | Manages a graphical log component |
| ►CQThread | |
| CNetworkThread | |
| CTreeThread | Manages the client root node |
| ►CQTreeView | |
| CTreeView | This class manages the tree view |
| CQuad2D_traits | |
| CQuad2D_traits | |
| CQuad2D_traits | |
| CQuad3D_traits | |
| CQuad3D_traits | |
| CQuad_traits< P > | |
| CQuad_traits | |
| CQuad_traits | |
| CQuad_traits | |
| CQuad_traits | |
| CQuadratureBase< TR > | Fallback class if a concrete Quadrature doesn't implement a static function |
| CQuadratureBase< cf3::mesh::gausslegendre::Hexa_traits< P > > | |
| CQuadratureBase< cf3::mesh::gausslegendre::Line_traits< P > > | |
| CQuadratureBase< cf3::mesh::gausslegendre::Quad_traits< P > > | |
| ►CQuadratureBase< Hexa_traits< P > > | |
| CHexa< P > | |
| ►CQuadratureBase< Line_traits< P > > | |
| CLine< P > | |
| ►CQuadratureBase< Quad_traits< P > > | |
| CQuad< P > | |
| ►CQWidget | |
| CBorderArea | Used to display the the line number and the prompt on a PythonCodeContainer |
| CCentralPanel | Panel to view and modify options of an object |
| ►CGraphicalValue | |
| CGraphicalArray | |
| CGraphicalArrayRestrictedList | |
| CGraphicalBool | |
| CGraphicalDouble | |
| CGraphicalInt | |
| CGraphicalRestrictedList | |
| CGraphicalString | |
| CGraphicalUri | |
| CGraphicalUriArray | |
| CTreeBrowser | This widget allows allows to browse the treeview in a special way |
| CWidget3D | Show a mesh rendered on a ParaViewTab server |
| 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 |
| ►CQwtPlot | |
| CBodePlot | This is a QwtPlot with easiest way to acces the options and add curves |
| ►CQwtPlotZoomer | |
| CZoomer | |
| CRapidXML_Test_Fixture | |
| CRDMMergeFixture | |
| CReconstructPoint | |
| CReader::RegionData | |
| CMeshWriter::RegionFilter | Predicate to check if a component directly contains any Entities component |
| CRegisterComponent< COMPONENT, LIB > | 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 |
| CExpressionBase< ExprT >::RegisterVariables | Functor to register variables in a physical model |
| CRegistLibrary< LIB > | Struct to force library registration |
| CRegistTypeInfo< TYPE, LIB > | |
| CRestrictToElementTypeTag< T > | |
| CSFOp< CustomSFOp< OpT > >::result< Signature > | |
| CCustomTerminal::result< Signature > | Custom ops must implement the TR1 result_of protocol |
| CScalarLSSVector::result< Signature > | Custom ops must implement the TR1 result_of protocol |
| CVectorLSSVector::result< Signature > | Custom ops must implement the TR1 result_of protocol |
| CApplyAup::result< Signature > | |
| CVelocityRHS::result< Signature > | |
| CScalarLSSVector::result< Signature > | Custom ops must implement the TR1 result_of protocol |
| CMetricTensor::result< Signature > | Custom ops must implement the TR1 result_of protocol |
| CPressureRHS::result< Signature > | |
| CGradientOp::result< Signature > | |
| CCustomLaplacian::result< Signature > | Custom ops must implement the TR1 result_of protocol |
| CVectorLSSVector::result< Signature > | Custom ops must implement the TR1 result_of protocol |
| CCustomLaplacianApply::result< Signature > | |
| CVectorLSSVector::result< This(DataT)> | |
| CScalarLSSVector::result< This(DataT)> | |
| CScalarLSSVector::result< This(DataT)> | |
| CMetricTensor::result< This(DataT)> | |
| CCustomTerminal::result< This(DataT)> | |
| CVectorLSSVector::result< This(DataT)> | |
| CCustomLaplacian::result< This(FieldDataT)> | |
| CSFOp< CustomSFOp< OpT > >::result< This(GrammarT)> | |
| CCustomLaplacianApply::result< This(TempT, MatrixT, VectorT)> | |
| CVelocityRHS::result< This(UT, NUT, GT, UVecT1, UVecT2, PVecT, Real, Real)> | |
| CVelocityRHS::result< This(UT, NUT, UVecT1, UVecT2, PVecT, Real, Real)> | |
| CApplyAup::result< This(UT, PVecT, Real, Real)> | |
| CPressureRHS::result< This(UT, UVecT, UVecT, UVecT, PVecT, Real, Real)> | |
| CGradientOp::result< This(VarT)> | |
| CGradientOp::result< This(VarT, MappedCoordsT)> | |
| CNormalOp::ResultType< SupportT > | |
| CNablaOp::ResultType< VarDataT > | |
| CCoordinatesOp::ResultType< SupportT > | |
| CJacobianOp::ResultType< SupportT > | |
| CShapeFunctionOp::ResultType< VarDataT > | |
| CJacobianDeterminantOp::ResultType< SupportT > | |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< TagT, Arity, Dummy > | Helper to get the result type |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 10, Dummy > | Specialization for a function with 9 arguments |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 2, Dummy > | Specialization for a function with one argument |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 3, Dummy > | Specialization for a function with 2 arguments |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 4, Dummy > | Specialization for a function with 3 arguments |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 5, Dummy > | Specialization for a function with 4 arguments |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 6, Dummy > | Specialization for a function with 5 arguments |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 7, Dummy > | Specialization for a function with 6 arguments |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 8, Dummy > | Specialization for a function with 7 arguments |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::function, 9, Dummy > | Specialization for a function with 8 arguments |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT >::ResultType< boost::proto::tag::terminal, 0, Dummy > | Used as a terminal, so we assume it just needs the basic context data |
| CLagrangeP1Quad3DFixture::RotatingCylinderPressure | |
| CLagrangeP1Triag3DFixture::RotatingCylinderPressure | |
| CLagrangeP1Line2DFixture::RotatingCylinderPressure | |
| CRowTag | Placeholders to indicate if we should get a row or a column |
| CSafeNbNodes< I > | Helper to get the number of LSS nodes, avoiding static divide-by-zero |
| CSafeNbNodes< 0 > | |
| CScalarLSSVector | |
| CScalarLSSVector | Custom proto op to access element values in an LSS vector for a scalar variable |
| CURI::Scheme | |
| CSelectComponentWrapper< ComponentT > | Helper struct to select the correct wrapper for a component |
| CSelectOptionType< T > | |
| 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 |
| CNodeLooperDim< ExprT, NbDimsT >::SelectWrapper< B, ProtoExprT > | |
| CNodeLooperDim< ExprT, NbDimsT >::SelectWrapper< false, ProtoExprT > | |
| CNodeLooperDim< ExprT, NbDimsT >::SelectWrapper< true, ProtoExprT > | |
| CServer | |
| CServerRoot | |
| CElementData< VariablesT, VariablesEtypeTT, SupportEtypeT, EquationVariablesInT >::SetElement | Set the element on each stored data item |
| CSetGradient | |
| CNodeData< VariablesT, NbDims >::SetNode | Set the element on each stored data item |
| CSetNodeValence | |
| CElementBased< Dim >::SF | 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 |
| CSFOp< OpT > | Wrap all operations in a template, so we can detect ops using a wildcard |
| CSFOp< cf3::solver::actions::Proto::CustomSFOp< cf3::UFEM::ScalarLSSVector > > | |
| CSFOp< cf3::solver::actions::Proto::CustomSFOp< cf3::UFEM::VectorLSSVector > > | |
| CSFOp< CustomSFOp< OpT > > | |
| CShapeFunctionBase< SF, TR > | Fallback class if a concrete ShapeFunction doesn't implement a static function |
| ►CShapeFunctionBase< Hexa, Hexa_traits > | |
| CHexa | |
| CHexa | |
| ►CShapeFunctionBase< Line, Line_traits > | |
| CLine | |
| CLine | |
| CLine | |
| CLine | |
| ►CShapeFunctionBase< Prism, Prism_traits > | |
| CPrism | |
| CPrism | |
| ►CShapeFunctionBase< Quad, Quad_traits > | |
| CQuad | |
| CQuad | |
| CQuad | |
| CQuad | |
| ►CShapeFunctionBase< Tetra, Tetra_traits > | |
| CTetra | |
| CTetra | |
| ►CShapeFunctionBase< Triag, Triag_traits > | |
| CTriag | |
| CTriag | |
| CTriag | |
| CTriag | |
| CTriag | |
| CCFLOp::ShapeType< T > | |
| CCFLOp::ShapeType< ElementBased< Dim > > | |
| ►CShared | |
| CReader | |
| CWriter | |
| CShared | |
| ►CShared | |
| CReader | |
| CWriter | |
| ►CShared | |
| CReader | |
| CWriter | |
| ►CShared | |
| CReader | |
| ►CSignalDispatcher | API to dispatch a signal call |
| CLocalDispatcher | Dispatches a signal locally |
| CNetworkQueue | |
| CRemoteDispatcher | |
| CSignalFrame | Manages a set of maps |
| ►CSignalHandler | |
| CComponent | Base class for defining CF components |
| CEventHandler | |
| CNetworkThread | |
| CServerNetworkComm | This class is the server network level |
| CSignalWrapper | |
| CSimpleMeshGeneratorTests_Fixture | |
| CSolutionVectorTag | Tag for a Neumann BC |
| CSomeTag | Define a tag (not used here) |
| CSpaceElem | |
| CSpaceElement | |
| CFavoritesModel::SpecialDir | |
| CStackTrace | |
| CStencilComputerRings_Fixture | |
| CEigenPlusAssignProductEval< GrammarT >::impl< ExprT, StateT, DataT >::StoreResult< T, Dummy > | |
| CEigenPlusAssignProductEval< GrammarT >::impl< ExprT, StateT, DataT >::StoreResult< Eigen::Block< MatT, R, C >, Dummy > | |
| CEigenPlusAssignProductEval< GrammarT >::impl< ExprT, StateT, DataT >::StoreResult< Real, Dummy > | |
| ►Cstream | |
| CGnuplot | |
| CStringConverter | Prevent a crash in the intel compiler |
| ►Csubscript | |
| CIsVectorSubRows< IdxT > | Match subrows for vectors |
| CSUPGSpecialized | |
| CSUPGTypes | Possible types of SUPG computation to apply |
| CSystemMatrixTag | Tag for system matrix |
| CSystemRHSTag | Tag for RHS |
| ►CT | |
| CElementMatrix< T > | Represents an element matrix |
| CElementSystemMatrix< T > | Represents an element matrix that is used as part of the linear system |
| CElementVector< T > | Represents an element vector |
| ►CT1 | |
| 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 |
| ►CT2 | |
| 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 |
| ►CT3 | |
| 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 |
| ►CT4 | |
| CComposedPhysics< T1, T2, T3, T4, boost::mpl::void_ > | Specialization for 4 models |
| CTabInfo | |
| CTableArray< T > | |
| CTableArray< Real > | |
| CTableArray< Uint > | |
| CTableArray< ValueT > | |
| CTableConstRow< T > | |
| CTableMethods< ValueT > | Extra methods for Table |
| CTableRow< T > | |
| CTableRowWrapper< ValueT > | Functions exposed to python dealing with table rows |
| ►CTaggedObject | Manages tags |
| CComponent | Base class for defining CF components |
| ►COption | Adds fonctionnalities to Property class |
| COptionArray< TYPE > | |
| COptionComponent< T > | |
| COptionT< TYPE > | |
| ►COptionT< URI > | |
| COptionURI | |
| CLagrangeP1Line3DFixture::TangentVectorNorm | Returns the norm of the tangen vector to the curve |
| CTaylorGreen | |
| CTaylorGreen | |
| CTaylorGreenModel | |
| CTecWriterTests_Fixture | |
| CTecZone | |
| CCommPattern::temp_buffer_item | Typedef for the temporary buffer |
| ►Cterminal | |
| CBlockLhsGrammar< TagT > | Grammar matching the LHS of an assignment op |
| CCoordsTerminals | Valid terminals that can represent the current node coordinates |
| CElementVectorTerm | Match element matrix terminals |
| Ctest_matrix | Holding all the data and the constructor sets everything up, everything is public |
| CTest_ShapeFunction_Fixture | |
| CTestBuildFaces_Fixture | |
| CTestCase | |
| CTestCGNS_Fixture | |
| CTestFieldCreation_Fixture | |
| CTestFixture | |
| CTestGlobalConnectivity_Fixture | |
| CTestParallelDistribution_Fixture | |
| CTestRotate_Fixture | |
| CTestSignals_Fixture | |
| CTetra3D_traits | |
| CTetra_traits | |
| CTetra_traits | |
| CTetraSFFixture | Fixture for each test |
| CThermalFluid | Non-isothermal fluid (assume we get the temperature from somewhere else) |
| CThreadManager | |
| Cthreshold_compare | |
| Cthreshold_compare | |
| ►CThyraOperator | Abstract class for all Trilinos matrix operators |
| CTrilinosCrsMatrix | |
| CTrilinosFEVbrMatrix | |
| ►CThyraVector | Abstract class for all Trilinos matrix operators |
| CTrilinosVector | |
| CTimedComponent | Pure virtual interface for components that store timings |
| ►CTimedTestFixture | Any test using this fixture (or a derivative) will be timed |
| CBockMesh3DFixture | |
| CComponentBenchFixture | |
| CProfiledFixture | Profile and time tests using this fixture |
| CProtoBenchmarkFixture | |
| CProtoParallelFixture | |
| CPtrFixture | |
| CVectorBenchmarkFixture | |
| CTransaction | |
| ►Ctransform | |
| CAddNodeValues | |
| CAddNodeValuesIndex< IndexGrammarT > | |
| CBlockAccumulator | Primitive transform to handle assignment to an LSS matrix |
| CComputeNorm | Compute the norm of a matrix or a vector |
| CCoordinatesOp | Interpolated real-world coordinates at mapped coordinates |
| CCustomSFOpTransform< OpImpl, GrammarT > | Operation with a custom implementation |
| CDirichletBCComponentSetter | Sets a specific component of a vector |
| CDirichletBCSetter | Sets whole-variable dirichlet BC, allowing the use of a complete vector as value |
| CEigenPlusAssignProductEval< GrammarT > | Evaluate A += B*C, which is a special case needed in Gauss integrator. If B or C is a scalar, it's also faster |
| CEigenProductEval< GrammarT > | Evaluate the product LeftT * RightT |
| CElementMatrixBlockValue | Only get a block containing the rows for the first var and the cols for the second |
| CElementMatrixRowsValue | Only get the rows relevant for a given variable |
| CElementMatrixValue | Get a given element matrix |
| CElementQuadratureEval< GrammarT > | |
| CElementRHSValue | Get the RHS vector |
| CElementValue | |
| CElementVectorRowsValue | Only get the rows relevant for a given variable |
| CElementVectorTransform | |
| CElementVectorValue | Get a given element matrix |
| CExpressionGroup< GrammarT > | Primitive transform to evaluate a group of expressions |
| CExtractDiag | Primitive transform to perform the transpose |
| CForEachDimension< GrammarT > | Primitive transform to evaluate a group of expressions |
| CGaussIntegral | Primitive transform that evaluates an integral using the Gauss points and returns the result as a reference to a stored matrix (or scalar) |
| CGaussPointEval | Transform to evaluate Gauss point access |
| CGaussWeightEval | Transform to evaluate Gauss weight access |
| CGetCoordinates | Provide access to the geometry coordinates in case of node expressions |
| CGetRHSVector | |
| CGetSolutionVector | |
| CIndexedNodeAssign< IndexGrammarT > | Modify only a single component of a field |
| CIndexLooper< GrammarT > | |
| CInterpolationOp | Interpolated values at mapped coordinates |
| CJacobianDeterminantOp | Jacobian determinant |
| CJacobianOp | Jacobian matrix |
| CLump | Lump the matrix |
| CMatrixColAccess | |
| CMatrixElementAccess | Primitive transform to access matrix elements using operator() |
| CMatrixRowAccess | |
| CMatrixSubscript< GrammarT, IntegersT > | Primitive transform to access matrix elements using operator[] |
| CNablaOp | Gradient |
| CNodeAssign | Handle modification of a field |
| CNodesOp | Element nodes |
| CNormalOp | Face Normal |
| CParsedScalarFunctionTransform | |
| CParsedVectorFunctionTransform | Primitive transform to evaluate a function with the function parser |
| CReplaceConfigurableConstant | Transform to replace an occurance of ConfigurableConstant with a reference to its value |
| CReplacePhysicsConstant | Transform to replace an occurance of PhysicsConstant with a reference to its value |
| CRestrictToElementType< GrammarT > | Primitive transform to evaluate a group of expressions for specific element types only |
| CRHSAccumulator | |
| CRunFunctionOp< GrammarT > | Runs a shape function operation that is used as a function call |
| CRunTerminalOp< GrammarT > | Runs a shape function operation that is used as a terminal |
| CSetIdentity | |
| CSetRHSSetter | |
| CSetSolutionSetter | |
| CSetZero | |
| CShapeFunctionOp | Shape functions |
| CSubCols< I, J > | A subblock of columns |
| CSubMatrix< I, J > | A submatrix |
| CSubRows< I, J > | A subblock of rows |
| CTransposeTransform | Primitive transform to perform the transpose |
| CVarValue | Returns the data value of a numbered variable |
| CVectorSubRows< I, J > | A subblock for the element vector |
| CVolumeOp | Element volume |
| CWrapMatrixExpression | |
| CComponentURIPrinter | |
| ►Ctransform_impl | |
| CAddNodeValues::impl< ExprT, StateT, DataT > | |
| CAddNodeValuesIndex< IndexGrammarT >::impl< ExprT, StateT, DataT > | |
| CBlockAccumulator::impl< ExprT, State, DataT > | |
| CComputeNorm::impl< ExprT, StateT, DataT > | |
| CCustomSFOpTransform< OpImpl, GrammarT >::impl< ExprT, StateT, DataT > | |
| CDirichletBCComponentSetter::impl< ExprT, StateT, DataT > | |
| CDirichletBCSetter::impl< ExprT, StateT, DataT > | |
| CEigenPlusAssignProductEval< GrammarT >::impl< ExprT, StateT, DataT > | |
| CEigenProductEval< GrammarT >::impl< ExprT, StateT, DataT > | |
| CElementMatrixBlockValue::impl< ExprT, StateT, DataT > | |
| CElementMatrixRowsValue::impl< ExprT, StateT, DataT > | |
| CElementMatrixValue::impl< ExprT, StateT, DataT > | |
| CElementQuadratureEval< GrammarT >::impl< ExprT, StateT, DataT > | |
| CElementRHSValue::impl< ExprT, StateT, DataT > | |
| CElementValue::impl< ExprT, StateT, DataT > | |
| CElementVectorRowsValue::impl< ExprT, StateT, DataT > | |
| CElementVectorTransform::impl< ExprT, StateT, DataT > | |
| CElementVectorValue::impl< ExprT, StateT, DataT > | |
| CExpressionGroup< GrammarT >::impl< ExprT, StateT, DataT > | |
| CExtractDiag::impl< ExprT, StateT, DataT > | |
| CForEachDimension< GrammarT >::impl< ExprT, StateT, DataT > | |
| CGaussIntegral::impl< ExprT, StateT, DataT > | |
| CGaussPointEval::impl< ExprT, StateT, DataT > | |
| CGaussWeightEval::impl< ExprT, StateT, DataT > | |
| CGetCoordinates::impl< TagT, StateT, DataT > | |
| CGetRHSVector::impl< ExprT, StateT, DataT > | |
| CGetSolutionVector::impl< ExprT, StateT, DataT > | |
| CIndexedNodeAssign< IndexGrammarT >::impl< ExprT, StateT, DataT > | |
| CIndexLooper< GrammarT >::impl< ExprT, StateT, DataT > | |
| CInterpolationOp::impl< VarT, StateT, DataT > | |
| CLump::impl< ExprT, StateT, DataT > | |
| CMappedOpBase< ExprT, StateT, DataT, Derived, ResultType > | Base class for the implementation of operations that depend on mapped coordinates (CRTP pattern) |
| CMappedVarOpBase< ExprT, StateT, DataT, Derived, ResultType > | Base class for the implementation of operations that depend on mapped coordinates (CRTP pattern) |
| CMatrixColAccess::impl< ExprT, StateT, DataT > | |
| CMatrixElementAccess::impl< ExprT, StateT, DataT > | |
| CMatrixRowAccess::impl< ExprT, StateT, DataT > | |
| CMatrixSubscript< GrammarT, IntegersT >::impl< ExprT, StateT, DataT > | |
| CNodeAssign::impl< ExprT, StateT, DataT > | |
| CNodesOp::impl< ExprT, StateT, DataT > | |
| CParsedScalarFunctionTransform::impl< ExprT, StateT, DataT > | |
| CParsedVectorFunctionTransform::impl< ExprT, StateT, DataT > | |
| CReplaceConfigurableConstant::impl< ExprT, StateT, DataT > | |
| CReplacePhysicsConstant::impl< ExprT, StateT, DataT > | |
| CRestrictToElementType< GrammarT >::impl< ExprT, StateT, DataT > | |
| CRHSAccumulator::impl< ExprT, State, DataT > | |
| CRunFunctionOp< GrammarT >::impl< ExprT, StateT, DataT > | |
| CRunTerminalOp< GrammarT >::impl< ExprT, StateT, DataT > | |
| CSetIdentity::impl< ExprT, StateT, DataT > | |
| CSetIdentity::impl< Eigen::Block< MatT, R, C >, StateT, DataT > | |
| CSetRHSSetter::impl< ExprT, StateT, DataT > | |
| CSetSolutionSetter::impl< ExprT, StateT, DataT > | |
| CSetZero::impl< ExprT, StateT, DataT > | |
| CSetZero::impl< Eigen::Block< MatT, R, C >, StateT, DataT > | |
| CSubCols< I, J >::impl< ExprT, StateT, DataT > | |
| CSubMatrix< I, J >::impl< ExprT, StateT, DataT > | |
| CSubRows< I, J >::impl< ExprT, StateT, DataT > | |
| CTransposeTransform::impl< ExprT, StateT, DataT > | |
| CVarValue::impl< VarT, StateT, DataT > | |
| CVectorSubRows< I, J >::impl< ExprT, StateT, DataT > | |
| CVolumeOp::impl< ExprT, StateT, DataT > | |
| CWrapMatrixExpression::impl< ExprT, StateT, DataT > | |
| CComponentURIPrinter::impl< ExprT, StateT, DataT > | |
| ►CMappedOpBase< ExprT, StateT, DataT, impl< ExprT, StateT, DataT >, ResultType > | |
| CCoordinatesOp::impl< ExprT, StateT, DataT > | |
| CJacobianDeterminantOp::impl< ExprT, StateT, DataT > | |
| CJacobianOp::impl< ExprT, StateT, DataT > | |
| CNormalOp::impl< ExprT, StateT, DataT > | |
| ►CMappedVarOpBase< ExprT, StateT, DataT, impl< ExprT, StateT, DataT >, ResultType > | |
| CNablaOp::impl< ExprT, StateT, DataT > | |
| CShapeFunctionOp::impl< ExprT, StateT, DataT > | |
| CTransformer | |
| CTransposeFunction | Terminal to indicate we want a transpose |
| CTriag2D_traits | |
| CTriag2D_traits | |
| CTriag2D_traits | |
| CTriag2D_traits | |
| CTriag3D_traits | |
| CTriag_traits | |
| CTriag_traits | |
| CTriag_traits | |
| CTriag_traits | |
| CTriag_traits | |
| ►Ctype | |
| CNodeLooperDim< ExprT, NbDimsT >::NodesExpression< ProtoExprT > | |
| CUFEMBuildSparsityFixture | |
| ►Cunary_function | |
| CUnaryRealOp | |
| ►Cunary_plus | |
| CMathOpDefaultCases< GrammarT >::case_< boost::proto::tag::unary_plus, Dummy > | |
| CUnifiedData_Fixture | |
| CUnityCollisionKernel | |
| CUpdateParameterValue | |
| CURI | |
| CPEDatatypeFixture::user_struct_c | |
| CPEDatatypeFixture::user_struct_d | |
| CPEDatatypeFixture::user_struct_i | Some complex data types |
| CUUCount | Combination of a UUID and a count, together forming the equivalent of a 192-bit identifier |
| CValue< TYPE > | |
| CValue< Handle< ComponentT > > | |
| COptionComponent< T >::ValueExtractor | MPL functor to extract a value from an any |
| CValueType< T > | 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 |
| CVarArity< T > | |
| CVarChild< ExprT, Idx > | Helper to get the variable type at a child of an expression |
| CVarDataType< VarT, DataT > | Helper to get the data type for the given variable |
| ►CVariables | |
| CVariablesT< PHYS > | |
| CElementData< VariablesT, VariablesEtypeTT, SupportEtypeT, EquationVariablesInT >::VariableType< I > | Return the type of the stored variable I (I being an Integral Constant in the boost::mpl sense) |
| ►CVectorialFunction | |
| ►CProtoEvaluatedFunction | Wrap the vectorial function, adding extra data that may be filled before expression evaluation |
| ►CScalarFunction | |
| CVectorFunction | |
| CVectorLSSVector | Custom proto op to access element values in an LSS vector for a vector variable |
| CVectorLSSVector | |
| CVectorOperations_Fixture | |
| CVelocityAssembly | |
| CVelocityRHS | |
| CVolumeFunctor | Simple test functor to compute the volume |
| CVolumeSFFixture::VolumeMPLFunctor< FunctorT > | Applies a functor if the element is a volume element |
| CVolumeSFFixture | |
| CWallProjection | Helper struct to handle projection to the wall near a given surface node |
| ►Cwhen | |
| CElementIntegration | |
| CElementQuadrature | |
| CFieldInterpolation | Interpolate a field at the current gauss point |
| CForEachDimensionGrammar< GrammarT > | Matches and evaluates groups of expressions matching GrammarT |
| CIntegers | Matches integer terminals |
| CMathOpDefault< GrammarT > | Math operators evaluated using default C++ meaning |
| CRHSVectorGrammar | Matches placeholders for the solution vector |
| CSetRHSGrammar< GrammarT > | Matches the proper formulation of Neumann BC |
| CSetSolutionGrammar< GrammarT > | Matches the proper formulation of Neumann BC |
| CSolutionVectorGrammar | Matches placeholders for the solution vector |
| CStreamOutput< GrammarT > | Stream output |
| CTransposeGrammar< GrammarT > | |
| CIntegralConstantGrammar< I > | |
| ►CStreamOutput< ElementMathIndexed< I, J > > | |
| CStreamOutputIndexed< I, J > | |
| ►CStreamOutput< NodeMathIndexed< I, J > > | |
| CNodeStreamOutputIndexed< I, J > | |
| CWorkerStatus | |
| CWrapMatrixExpression::impl< ExprT, StateT, DataT >::WrapperSelector< T, bool > | Helper to select if the expression is to be wrapped |
| CWrapMatrixExpression::impl< ExprT, StateT, DataT >::WrapperSelector< T &, true > | Expression is to be wrapped |
| Cxml_document< Ch > | |
| Cxml_document< char > | |
| Cxml_node< Ch > | |
| Cxml_node< char > | |
| CXmlFixture | |
| ►CXmlNode | |
| CXmlDoc | |
| CZeroTag | |
| CZoltanTests_Fixture | |
1.8.9.1
