GemaCoreLib
The GeMA Core library
Loading...
Searching...
No Matches
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 CGmResultsTimeManager::AttributeData
 CGmResultsTimeManager::AttributeTimeSetData
 CGmHdf5ModelReader::AttrInfoAux structure with information for a data attribute
 CGmAttributeResultsManager::AttrValueThe union representing the saved value Using a QString instead of a QString* should be possible, but would require an explicit destructor for the union due to the non POD member and more complicated code to init the value and destroy the union. See, for example, https://en.cppreference.com/w/cpp/language/union Since the set of string attributes is minimal, storing a pointer should not really matter
 CGmAttributeResultsManager::AttrValueWithStatsAn option to store an attribute value with statistics
 ►CBase
 ►CBaseAc
 CGmHdf5ModelReader::BcInfoAux structure with information abou a boundary condition
 CGmStateDumpBufferDataItem::BufferDataHelper structure to store a tuple (buffer ptr, size ptr, size multiplier)
 CGmValueSetEvalContext::CacheAlignedDataA structure to merge cache aligned data since they combined fit inside a cache lign
 CGmNfFileWriter::CellOrder
 CGmRunProgressReport::ColData
 CGmSingleAppendBuffer< T, Base >::ControllDataAux controll structure storing a buffer
 CGmPolygonTriangulator::CostIndex
 CGmHdf5ModelReader::DicInfoAux structure with information for dictionary tables with associated data sets
 CGmHdf5ModelReader::DiscInfoAux structure with information about a discontinuity
 CGmHdf5ModelReader::DsInfoAux structure with information about a discontinuity set
 CGmXdmfHdf5::DsSizeInfo
 CGmMemoryDump::DumpItemThe structure adding controll information to a GmMemoryDumpItem
 CGmCellGeometryMetadata::EdgeNodeDataAux structure storing information about one edge of a cell type
 CGmVectorCSxSparseMatrixLayoutBuilder< IndexType, T >::ExtData
 CGmCellGeometryMetadata::FaceNodeDataAux structure storing information about the set of face edges for a cell type
 CGmMemoryDump::FileControlHeaderThe file structure with file control info
 CGmMemoryDump::FileDataChunkHeaderThe file header for each data chunk
 CGmMemoryDump::FileInfoBlockHeaderThe structure storing control info for an Info block
 CGmMemoryDump::FileItemHeaderThe file header for every data item
 CGmNfFileFormat::SupportedTypesT::GaussNumbering
 CGm3DSurfaceCellIntersection
 CGm3DSurfacePointInfo
 ►CGmAccessorProxyHelper class with common code for several classes that wrap a value accessor, provinding a slitly different indexing mode (such as a cell accessor where indices the cell pointer or a Gauss accessor where indices are the element pointer + an ip index)
 CGmAggregator
 ►CGmAppendBuffer< T >A virtual class representing a buffer of T objects that can be appended in a thread-safe way, growing the buffer as needed
 CGmAppendBuffer< arma::uword >
 CGmAppendBuffer< double >
 ►CGmAppendBuffer< GmSparseMatrixTripletData< T > >
 CGmBcTagInfoA helper struct to store bc tag information
 CGmBlasTempUpdateNumThreadsA RAII class used to temporarily adjust the number of OpenBlas threads in effect. If the number of threads is zero, does nothing
 ►CGmBoundaryConditionBaseA base class used to implement the common part between GmBoundaryCondition and GmContactBoundaryCondition. Should NOT be instanced directly
 CGmBVHAcceleration
 ►CGmBVHVisibility
 ►CGmCellBase interface for mesh cells
 CGmCell3DIntersectionCoordAccessorA simple accessor used to access 3d surface cell intersection data with possible unit conversion from the mesh coordinate unit to the desired unit. IMPORTANT: This class does NOT implement all the standard methods of a GmValueAccessor object. Those implemented, though, follow the SAME semantics
 CGmCellMesh::GmCellBboxStatistics
 ►CGmCellBoundaryThis class stores a set of cell edges or cell faces that together form a piece of the boundary of a mesh
 CGmCellMesh::GmCellEdgeStatistics
 CGmCellGeometryA class used to return static metadata information about a cell geometry, along with some methods for calculating geometric properties for a cell, given its coordinate matrix
 CGmCellGeometryIntegrationRuleSet< GaussR, LobattoR, CNewtonR, ONewtonR >A helper class used to store the class types for each rule type. Template parameters are the implementation classes, for an element type, for each of the possible rule types. If a rule type is not supported for an element, just pass GmCellGeometryNullIntegrationRule as template parameter
 CGmCellGeometryIntegrationRuleSetDefaultRules< DefType, DefGaussRule, DefLobattoRule, DefCNewtonRule, DefONewtonRule >A helper class used to store the default rules for each rule type. Template parameters are the default integration rule type + a default rule number for each of the possible rule types. If a rule type is not supported for an element, just pass -1 for the associated default rule
 CGmCellGeometryIntegrationRuleSetDoubleParDefaultRules< DefType, DefGaussRule1, DefGaussRule2, DefLobattoRule1, DefLobattoRule2, DefCNewtonRule1, DefCNewtonRule2, DefONewtonRule1, DefONewtonRule2 >A helper class used to store the default rules for elements where the default is expressed by two values (like in the wedge case). Implements only the adjustParameters() method by choosing the appropriate rule to apply
 CGmCellGeometryIntegrationRuleSetMultiFaceDefaultRules< TriDefaults, QuadDefaults >A helper class used to store the default rules for elements with more than one face type (like wedges). Template parameters should be GmCellGeometryIntegrationRuleSetDefaultRules<> instances for TRI and QUAD faces. Implements only the adjustFaceParameters() method by choosing the appropriate rule to apply
 ►CGmCellGeometryMetadataPlane structure storing the full set of geometric metadata for a cell type
 CGmCellGeometryNullIntegrationRuleA type used to represent a 'unexistant" integration rule. Should be used as template parameter for GmCellGeometryIntegrationRuleSet<> when a type does not have an implementation for a rule type (Gauss, Lobatto, open or closed Newton)
 ►CGmCellGroupSetInterface for helping managing mesh cell groups and returning the elements in their union
 CGmCellMeshTopologyBase interface class for mesh topological queries
 ►CGmCellTaskDataSetBase class for accessing the set of cells belonging to a mesh partition
 CGmCompact2DSegmentCellIntersectionA (much more) compact version of GmSegmentCellIntersection for 2d intersections only. Must be created on the heap by a call to instance()
 CGmCRMatrixAn auxiliary matrix WRAPPER that binds the matrix to a CONST memory area with data already inicialized and interpreted in COLUMN MAJOR FORMAT
 CGmCRVectorAn auxiliary vector WRAPPER that binds the vector to a CONST memory area with data already initialized
 CGmCSxSMLIndexTypeData< U >A helper class used to provide the different types and sizes needed by GmCSxSparseMatrixLayout<IndexType, T>::indexWorker due to the different possibilities for IndexType
 CGmCSxSMLIndexTypeData< arma::uword >GmCSxSparseMatrixLayoutIndexWorkerTypeData specialization for int64 indices
 CGmCSxSMLIndexTypeData< int >GmCSxSparseMatrixLayoutIndexWorkerTypeData specialization for int32 indices
 CGmDataDeserializerA deserializer object used to read mesh data from several file formats
 ►CGmDiscontinuityThe geometric representation for a single discontinuity from the Discontinuity set. For 2D meshes, it is a polyline. For 3D meshes is a triangulated surface. It can also be represented by edge or face lists
 CGmDiscontinuitySetBase interface for providing discontinuity geometry information for spatial indices
 ►CGmDofMapAn interface for a simple class returning the dof number associated to a local matrix column
 ►CGmDualVector< T >A vector tailored for storing mesh related data for the common scenario where elements are added to the mesh but the number of added elements is much smaller than the original mesh size. Although conceptually a single vector, internally the storage is split in two parts. A fixed one with the original mesh information and a second one that grows as new elements are added to the mesh. Since the second part is small, standard vector growing practices are not too hurtfull
 CGmFileExtraNodesAn auxiliary class for emiting extra mesh nodes needed by standard GeMA element transformations that can be used while exporting data
 CGmFileFilterA generic auxiliary class for managing the various options that can be used to define the set of nodes and cells that should be exported, independently of the file format & writer in use. It also helps in managing extra nodes needed by cell transformation options. It automatically detects if the mesh has cell types that can not be exported to the given file format and ignores them
 ►CGmFileFormatBasic interface for describing high level file format capabilities
 CGmFileNodeRenumberingAn auxiliary class for renumbering nodes when filtering cells from an output mesh. Filtering can be done based on active cells, cells belonging to a cell group and/or by cell type (ignoring cells whose type can not be exported to a file format). The renumbered node sequence only includes nodes that belong to unfiltered cells. A second option allows for the renumbering to consider geometry nodes only, ghost nodes only or both It can also be used to create a map for partitioned meshes() where the original node ordering has gaps in it
 ►CGmFileReaderBasic interface for file deserializers
 ►CGmFileWriterBasic interface for file serializers
 CGmFilterableCoordinateSetBiding< N >A extension for implementing filtering of points inside a coordinateSetBiding Mostly useful for discontinuity aware interpolation
 ►CGmFilterableCoordinateSetBiding< 16 >
 ►CGmFilterableCoordinateSetBiding< 256 >
 ►CGmFilterableCoordinateSetBiding< 64 >
 CGmFilteredBorderIterator< Filter >An iterator class that traverses all mesh border cells, subject to the given filter object / function. For each mesh border side, the filter function is called, getting as parameters the cell pointer, the side index and the border index. It should return true if the side is to be returned by the iterator or false if it should be skipped. If skipRemote is set to true, and is also configured in the PCR object, remote halo cells will not be included in the set of iterated cells
 CGmFilteredCellIterator< Filter >An iterator class that traverses all mesh cells, subject to the given filter object / function. For each mesh cell, the filter function is called, getting as parameters the cell pointer. It should return true if the cell is to be returned by the iterator or false if it should be skipped. If skipRemote is set to true, and is also configured in the PCR object, remote halo cells will not be included in the set of iterated cells
 ►CGmForeachCellHelperClassBase< T >Base helper class for the GmForeachXxxx() family of macros
 ►CGmGaussCoordinatesA helper class that returns the coordinates of an element's Gauss points. This class should not be instanced directly. Use GmSingleGaussCoordinates or GmMultiGaussCoordinates instead
 ►CGmGaussIndexA class storing an index capable of determining the number of integration points belonging to a mesh, to a cell group set or to a cell list, possibly filtered by the set of active elements, and capable of determining the linear index of the gauss point from the element id + local integration point number
 CGmGaussIntegrationTablesA class storing tables with (position, weight) pairs for line, triangle and tetrahedron Gauss integration rules
 ►CGmGroupDumpItemA basic interface used for creating dump items for objects that can be dumped by a composition of multiple individual dump items
 CGmHashSparseVector< T >
 ►CGmHdf5ModelA helper class with enums and methods common to GmHdf5ModelWriter & GmHdf5ModelReader
 ►CGmIntegrationRuleIntegration rule base classe
 ►CGmInterpolatorInterpolator class used for managing available interpolator algorithms and providing basic support functions with operations common to every derived class.
 ►CGmInterpolatorCoordinateSetBindingBasic interface for a set storing point cartesian coordinates. This set can be filled with points from nodes or Gauss points, from one or several cells/elements, according to the concrete implementation used
 ►CGmInterpolatorInputDataBindingBinding class used to store the set of known values associated with the points used in the interpolation. Might store one ore more values per point
 ►CGmInterpolatorObjectInterface class for the implementation of each of the possible interpolation algorithms available in GmInterpolatorType
 CGmInterpolatorOutputCoordinateBindingBinding class used to provide the coordinate of the interpolated point, either in cartesian or natural coordinates, according to the interpolator requirements
 ►CGmInterpolatorOutputDataBindingBinding class used to host the data structure where calculated interpolated values will be stored. Might store one ore more values per point. It also hosts the dimension specification used when converting vector values to scalar ones
 ►CGmInterpolatorOutputMultiDataBindingBinding class used to host the data structure where calculated interpolated values will be stored for several points. Might store one ore more values per point.
It also hosts the dimension specification used when converting vector values to scalar ones
 CGmLinkedSparseVector< T >
 CGmLobattoIntegrationTablesA class storing tables with (position, weight) pairs for line Lobatto integration rules
 CGmLogCategoryClass representing a category with multiple logging levels
 CGmLogIdentClearerRAII object to clear the identation level to log messages, restoring to the previous identation when the object is destroyed
 CGmLogIdenterRAII object to add an identation level to log messages, reverting the settings when the object is destroyed
 CGmMatrixSet
 CGmMemoryBufferListA helper class that can store a list of buffers and their sizes, allowing for GmMemoryDumpItem instances to return multi part buffers from getDataBuffer() and setDataBuffer()
 CGmMemoryDumpClass storing a memory dump containing several dump items
 ►CGmMemoryDumpItemInterface for an object that can be dumped and undumped to either file or memory by GmMemoryDump
 CGmMemoryDumpItemScopedBufferOpA simple RAII style class that can be used to call MemoryDumpItem buffer operations while making sure that bufferReleased() will always be called, even on error conditions
 CGmModelDataAuxiliar class used to store the complete set of model data for a simulation
 CGmNewtonIntegrationTablesA class storing tables with (position, weight) pairs for line, triangle and tetrahedron Open & closed Newton Cotes integration rules
 ►CGmNodeSetThis class stores a set of nodes belonging to a mesh. The nodes can belong to the mesh boundary but that is not necessary
 ►CGmNodeTaskDataSetBase class for accessing the set of nodes belonging to a mesh partition
 CGmNumSolverPrinterA proxy class that can wrap and behave like a GmNumSolver object, adding the possibility for printing and / or saving the linear system matrices and vectors according to the given configuration. This feature was not included directly in the numeric solver API since numeric solvers can be shared between multiple solver processes with different print options
 CGmOmpTempUpdateNumThreadsA RAII class used to temporarily adjust the number of OMP threads in effect
 ►CGmPackedBufferThe basic interface for a shared buffer storing interleaved data for a group of value sets
 CGmPackedBufferInfoA class used for storing and managing the order of the value sets inside a pack
 CGmPathClass used to store releveant system and project paths, providing functions for path macro translations
 CGmPluginDataThis class is a simple wrapper over a generic Lua table, provided in the model, that also handles the necessary steps to allow for user provided functions to be callable from multiple simulation threads
 CGmPluginInfoBase class used to store information about a generic plugin
 CGmPluginLoaderClass responsible for managing discovery and loading of plugins
 ►CGmPluginLoaderAdderAuxiliar class used to add objects parsed by GmPluginLoader::loadPluginObjectList() to it's destiny
 ►CGmPluginObjectBase interface class for all object plugins
 CGmPluginObjectFactoryFactory class exported by every plugin object
 CGmpMmGaussData
 CGmPODVector< T, ControlSize, Grow, UseNew >A simple vector for Plain Old Data (POD) types with the control size variable type parameterized to allow for a smaller class size with ControlSize = unsigned int, with smaller vector size limits, or for a bigger class with ControlSize = size_t. Also receives as parameter the default growing strategy applied by its resize procedure and a flag stating if the memory allocation should be done in old C style (realloc / free) or in the new C++ style (operators new[] / delete[]). Using the old style is the default and allows us to, hopefully, benefit from realloc(). That can be an issue when using the takeData() method to transfer data ownership to other classes expecting to be able to release memory with operator delete[]. For those cases, set UseNew to true
 CGmPODVector< char, size_t, GmPODVectorTightGrow >
 CGmPolygonTriangulator
 ►CGmPolylineSegmentT
 CGmpRefDist< T >
 CGmPrintUtilsGroups utilitary routines for pretty printing data
 CGmProcessMethodRedirector< T >Class simmilar to LuaUpMethod, changed so that the redirector method can optionally log the time taken by the process execution and also its memory usage
 ►CGmResultsDataSrcInfoA basic interface with the metadata common to all results data src types. This is the information that is broadcasted to monitoring programs and represents each entry in a ResultDataSet
 CGmResultsEvalSetA class storing the evaluation points for a set of rules
 ►CGmResultsRuleA result rule represents an action that will be executed over one or more data sets at the moments (times, iterations, etc) defined by one or more time sets. This action can be, for example, saving the data to a file, printing the data or sending it through the monitor server. This base class implements the common part for any action, loading and managing the data sets list and the time sets list. The executed action is delegated to the corresponding derived class
 CGmResultsRuleAggregatorA helper class to help combining values evaluated at every integration point into a single value, according to the given aggregation rule. The aggregated value is built on the provided buffer. For non scalar data, aggregation is performed by component, as if done over multiple scalar values
 CGmResultsTimeSetA rule specifying the execution moments (time, iterations, etc) that a result rule should be executed
 CGmResultsTrackedDataA tracked data value. Can be either a double vector or a string. Thanks to the implicitly shared nature of a QVector/QString, the result data can be transfered to and from a message object without copying
 CGmResultsTrackedIndexDataThe index data for a result rule, storing "evaluation point" data for node, cell or gauss based indices. Thanks to the implicitly shared nature of a QVector, the result data can be transfered to and from a message object without copying
 CGmRleSparseVector< T >
 ►CGmRunProgressA RAII class used to simplify tracking an item with a progressStats object. When the object is created, an itemStart() call is made. When destroyed, the corresponding itemEnd() call is made. If an invalid item is passed as parameter (-1), does nothing. This can simplify the code for optional attributes that are collected only on detailed cases
 CGmRunProgressReportA class used to create formatted reports based on ProgressStats item attribute values
 CGmSegmentCell2DIntersectionCoordAccessorA simple accessor used to access 2d segment cell intersection data with possible unit conversion from the mesh coordinate unit to the desired unit. IMPORTANT: This class does NOT implement all the standard methods of a GmValueAccessor object. Those implemented, though, follow the SAME semantics
 CGmSegmentCellIntersectionRepresentation for the intersection between a polyline segment and a mesh cell. Can be used both in 2D and in 3D
 ►CGmShapeShape function handling base classe.
 CGmShapeOrthogonalPolOrthogonal polynomial calculation
 CGmSimulationDataAuxiliar class used to store the complete set of simulation data
 CGmSingleVector< T >A class with the same API as GmDualVector storing a single vector. No query "if" overhead. Ideal for static meshes
 CGmSolutionDataAuxiliar class used to store the complete set of solution methods data for a simulation
 ►CGmSolverMatrixBase interface class for Solver Matrix objects.
 ►CGmSparseMatrixLayoutBuilderAn interface for building the layout structure of a sparse matrix
 CGmSparseMatrixOptionsSet of configuration options for Sparse matrices
 CGmSparseMatrixTripletData< T >Aux structure used when building sparse matrices with the help of a triplet list. The tripet structure stores 2 ints
 CGmSpinLockerRAII object used to acquire a spin lock and release it upon object destruction
 CGmStateDumpPresents a higher level of abstraction over GmMemoryDump, storing accessor data, vector data or user buffers
 CGmStateVarAuxiliar class used to store the definition of a state variable.
 CGmTaskManagerTask manager used for handling parallel executions
 CGmThreadOur thread wrapper, specialized for running tasks from the thread manager queue
 CGmThreadManagerThread manager used for handling parallel executions
 CGmThreadTaskInterface for a task executed by a thread manager thread
 CGmTimeAdderRAII class used to add the elapsed time to a counter received by reference. Counter is incremented in nano seconds
 CGmTimeMsgRAII object used to measure the elapsed time of an operation
 CGmTLBuffer< T, Align >A class similar to GmTLS that creates a buffer for each possible thread in the GmThreadManager, plus an additional one for the main thread
 CGmTLBuffer< bool, true >
 CGmTLBuffer< double, GM_VALUESET_ALIGNED_BUFFERS >
 CGmTLBuffer< double, true >
 CGmTLBuffer< GmMatrix, true >
 CGmTLBuffer< GmVector, true >
 CGmTLBuffer_Alloc< T, Align >Aux structure to define the allocation strategy for GmTLBuffer
 CGmTLBuffer_Alloc< T, false >GmTLBuffer_Alloc specialization for unaligned buffers
 CGmTLBuffer_Alloc< T, true >GmTLBuffer_Alloc specialization for aligned buffers
 CGmTLS< T, Align >A class that works together with GmThreadManager to provide thread local storage
 CGmTLS< bool * >
 CGmTLS< double * >
 CGmTLS< double ** >
 CGmTLS< GmMatrix * >
 CGmTLS< GmUserFunctionContext * >
 CGmTLS< GmValueSetEvalContext::CacheAlignedData, true >
 CGmTLS< GmVector * >
 CGmTLS< GmVector, true >
 CGmTLS< LuaEnv *, false >
 CGmTLS< LuaFunction * >
 CGmTLS< QQueue, false >
 CGmTLS< QVarLengthArray< T >, false >
 CGmTLS< T * >
 CGmTLS_Alloc< DataT, Align >Aux structure to define the allocation strategy for GmTLS
 CGmTLS_Alloc< DataT, false >GmTLS_Alloc specialization for unaligned buffers
 CGmTLS_Alloc< DataT, true >GmTLS_Alloc specialization for aligned buffers
 CGmTLS_DataT< T, Align >Aux structure to define the data type, cache aligned or not, for the GmTLS class
 CGmTLS_DataT< T, false >GmTLS_Data specialization for unaligned data
 CGmTLS_DataT< T, true >GmTLS_Data specialization for aligned data (can't just hold a typedef since the alignment clause must be applied to a struct member)
 ►CGmUnfilteredGaussIndexBaseA helper class that implements a GaussIndex like interface for the basic case where the ENTIRE mesh is being indexed (more precisely, the valid values for a queried cellId MUST be equal to the set of indexed cells)
 CGmUserFunctionClass used to store the definition of a user function and its parameters
 CGmUserFunctionContextThe context received by C methods giving access to parameters data and metadata
 CGmUserFunctionEvaluatorClass responsible for evaluating a UserFunction over a node / cell
 CGmUserFunction::GmUserFunctionParameterAuxiliar structure for storing function parameter information
 ►CGmValueAccessorInterface class for accessing and setting values from an "indexable" collection of values
 CGmValueInfoAuxiliar class used to store the definition of a value. It can be used to store informations about state variables, attributes and properties
 ►CGmValueSetDataThe generic interface implemented by every GmValueSetData object. Its purpose is to provide a base class that can be used without concerns about the effective layout of the stored data
 CGmValueSetEvalContex
 CGmValueSetEvalContextAuxiliar class used to store the needed information to translate an user function id / user function into an user function evaluator
 ►CGmValueSetGroupThis class manages a group of ValueSets that have all the same size and must grow (or shrink) together. It also manages the memory used by each value set, allowing for "packed" layouts where data from different value sets are interleaved in memory for better cache access. As a bonus, it keeps track of a map from data id to their value sets
 CGmVectorResizer< T >A RAII auxiliary class tailored for resizing a GmSingleVector or a GmDualVector and reverting to the original size on the destructor if the commit method was not called
 CGmVectorSet
 CGmFileIOUtils::GmWBuffer
 CGmXdmfHdf5A support class for saving data to a HDF5 file. Hdf5 files are self-describing but do not have a fixed semantic, so this file is usually accompanied by another file that describes the semantic of the tables exported in the HDF5 file
 CGmFileFilter::Indexer
 CGmCellGeometryMetadata::InterfaceDataAux structure storing information about interface element "contact" and "aperture" sides. All vector are empty for non interface elements
 CGmFileIO::InternalVsDataA helper structure to store data for the value sets created to enable Gauss to node interpolations & BC tag saving
 CGmFileIO::InterpDataA helper structure to collect all the needed interpolation configuration options
 CGmSegmentCellIntersection::IntersectionPoint
 ►CGmResultsTimeSet::Interval
 CGmMemoryDump::ItemHeaderThe in memory control header for every data item
 CGmDualVector< T >::iteratorAn iterator class to enable usage of the vector with standard algorithms such as std::sort
 CGmHdf5ModelReader::MeshInfoGeneral mesh information (only the "metadata" is loaded - table contents are not loaded, except for dictionaries)
 CGmProcessMethodRedirector< T >::MethodRegistryClasse auxiliar para registro dos nomes e métodos a serem chamados
 CGmResultsTimeSet::Moments
 CGmRunProgressStatsItem::NestedItemData
 CGmNfFileFormat::nfrElement
 CGmNfFileFormat::nfrType
 CGmPolygonTriangulator::Node
 CNotifyProgress
 CGmUserFunctionEvaluator::ParamContextAuxiliar class storing the information needed to collect a parameter value
 ►CQAtomicInteger [external]
 ►CQObject [external]
 ►CQtNanBoxedValue
 ►CQtTaggedPtr
 CRayIntersection
 CGmAttributeResultsManager::RegisteredAttrDataThe data associated with registered attributes. It includes the object "owner" to allow for auto deregistering when the object is destroyed. This helps to solve some destruction order dependencies related to objects holding a simulation model data pointer, used to access the results data only to unregister attributes on the object destructor (see the comments on SVN revision 4139)
 CGmNfFileFormat::SupportedTypesT
 CGmXdmfFileFormat::SupportedTypesTRegistered information about each element type. Needed to export said type in Xdmf format. An entry for each supported cell type should be registered by a call to registerSupportedCellType() before any attempt to save a file
 CGmThreadManager::ThreadConfigThe set of configured thread management options
 CGmResultsTimeSet::TimeDataThe time data internal structure.Notice that QVectors are implicitely copied, so we don't have problem storing them by value
Generated on Mon Aug 3 2026 09:53:16 for GemaCoreLib by doxygen 1.12.0