 |
GemaCoreLib
The GeMA Core library
|
|
GemaCoreLib
The GeMA Core library
|
| ►NGmFileIOUtils | |
| CBcCellBoundary | Aux class used to store a cell boundary created from a user given list of cells/borders |
| CBcNodeSet | Aux class used to store a node set created either from a GmCellBoundary or from a user given node list |
| CBcTaggedPtr | A wrapper class around QtTaggedPtr providing specific constructors to the type of Gema pointers that need to be stored by a boundary condition |
| CGm3DSurfaceCellIntersection | |
| CGm3DSurfacePointInfo | |
| CGmAccessorProxy | Helper 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) |
| CGmAcResultsDataSrc | Aux class adding an accessor to a basic result data source |
| CGmAcResultsDataSrcBase | A class storing basic information about a result data to be exported (monitored / saved), that is common to node, cell and Gauss data sources |
| CGmAggregator | |
| CGmAppendBuffer | A virtual class representing a buffer of T objects that can be appended in a thread-safe way, growing the buffer as needed |
| CGmArmadilloSolverMatrixBase | An implementation of the GmSolverMatrix interface using as base the Armadillo library |
| CGmArmadilloSparseSolverMatrix | The standard 'Sparse' matrix based on Armadillo |
| CGmAttributeCellAccessor | Extends GmCellAccessor to handle attribute accessors |
| CGmAttributeDiscontinuityAccessor | Extends GmDiscontinuityAccessor to handle attribute accessors |
| CGmAttributeResultsDataSrc | A class implementing the GmResultsDataSrcInfo interface, storing the metadata and id for a result data registered attribute. It also stores the requested unit and the converter when needed. It is built with the result rule definition only (name + unit) and later completed with the data src definition (info + id) when the infoChanged signal is emmited |
| CGmAttributeResultsDataSrcInfo | A basic class used to store meta-data information about result attributes DEFINITIONS |
| ►CGmAttributeResultsManager | A class used to host the metadata and the values for all attributes added to the results data. This includes the attributes referenced by result data sets and attributes created by the progress stats classes, also managing their correspondence. It also controls which attributes are being monitored and among those, which of them should have value changes broadcasted "immediately" |
| CGmBar2CellGeometryInfo | The Bar2 implementation |
| CGmBar2Shape | GmShape specialization for a 2D Bar with 2 nodes object |
| CGmBar3CellGeometryInfo | The Bar3 implementation |
| CGmBar3D2CellGeometryInfo | The Bar3D2 implementation |
| CGmBar3D2Shape | GmShape specialization for a 3D Bar with 2 nodes object |
| CGmBar3D3CellGeometryInfo | The Bar3D3 implementation |
| CGmBar3D3Shape | GmShape specialization for a 3D Bar with 3 nodes object |
| CGmBar3Shape | GmShape specialization for a 2D Bar with 3 nodes object |
| CGmBarShape | GmShape specialization for Bars, containing common functions used by concrete Bar specializations, such as Bar2 or Bar3 |
| CGmBaseCellGroupSet | A helper class implementing common code for handling group sets, specially handling group nodes. Is inherited by GmCellDisjointGroupSet and by GmCellGenericGroupSet |
| CGmBcAccessorProxy | A helper class with common code between GmBoundaryConditionAccessor and GmContactBoundaryConditionAccessor |
| CGmBcTagInfo | A helper struct to store bc tag information |
| CGmBlasTempUpdateNumThreads | A RAII class used to temporarily adjust the number of OpenBlas threads in effect. If the number of threads is zero, does nothing |
| CGmBorderIntegrationRule | Border integration rule base classe |
| CGmBoundaryCondition | A class used to represent a set of boundary conditions of the same type, tied to the same mesh |
| CGmBoundaryConditionAccessor | Proxy object to a value accesor implementing a more convenient interface to retrieve / store values for BoundaryCondition attributes |
| CGmBoundaryConditionBase | A base class used to implement the common part between GmBoundaryCondition and GmContactBoundaryCondition. Should NOT be instanced directly |
| CGmBoundaryConditionStateDumpItem | An auxiliar class used to host the needed code for duming a boundary condition to a state dump. Its purpose os to avoid adding that code to the BC class itself |
| CGmBVHAcceleration | |
| CGmBVHVisibility | |
| CGmBVHVisibility2D | |
| CGmBVHVisibility3D | |
| CGmCell | Base interface for mesh cells |
| CGmCell3DIntersectionCoordAccessor | A 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 |
| CGmCellAccessor | Proxy object to a value accesor implementing a more convenient interface where indices used to retrieve / store values are replaced by a reference to a cell |
| CGmCellAccessorProxy | An accessor proxy + method for saving a cell in the context |
| CGmCellAcResultsDataSrc | A GmAcResultsDataSrc class holding a cell value accessor |
| CGmCellBoundary | This class stores a set of cell edges or cell faces that together form a piece of the boundary of a mesh |
| CGmCellDisjointGroupSet | Cell group set consisting of a set of disjoint mesh cell groups |
| CGmCellGenericGroupSet | Cell group set consisting of a set of mesh cell groups |
| CGmCellGeometry | A 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 |
| CGmCellGeometryInfo | |
| CGmCellGeometryInfoLineElement | An auxiliary class that can be used as base for line (bar) elements. Implements the needed integration rule factories (main element + edge + face) |
| CGmCellGeometryInfoSolidElement | An auxiliary class that can be used as base for solid elements. Implements the needed integration rule factories (main element + edge + face) |
| CGmCellGeometryInfoSurfaceElement | An auxiliary class that can be used as base for surface elements. Implements the needed integration rule factories (main element + edge + face) |
| CGmCellGeometryIntegrationRuleSet | 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 | 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 | 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 | 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 |
| ►CGmCellGeometryMetadata | Plane structure storing the full set of geometric metadata for a cell type |
| CGmCellGeometryNullIntegrationRule | A 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) |
| CGmCellGroupSet | Interface for helping managing mesh cell groups and returning the elements in their union |
| ►CGmCellMesh | Base interface class for CellMesh type plugins |
| CGmCellMeshGroupSet | Cell group set consisting of all the mesh cells |
| CGmCellMeshTopology | Base interface class for mesh topological queries |
| CGmCellSequentialGroupSet | Cell group set consisting of a sequential set of mesh cells with no cell group association |
| CGmCellTaskDataSet | Base class for accessing the set of cells belonging to a mesh partition |
| CGmCompact2DSegmentCellIntersection | A (much more) compact version of GmSegmentCellIntersection for 2d intersections only. Must be created on the heap by a call to instance() |
| CGmContactBoundaryCondition | A class used to represent a set of contact boundary conditions of the same type, tied to the same mesh |
| CGmContactBoundaryConditionAccessor | Proxy object to a value accesor implementing a more convenient interface to retrieve / store values for ContactBoundaryCondition attributes |
| CGmCRMatrix | An auxiliary matrix WRAPPER that binds the matrix to a CONST memory area with data already inicialized and interpreted in COLUMN MAJOR FORMAT |
| CGmCRVector | An auxiliary vector WRAPPER that binds the vector to a CONST memory area with data already initialized |
| CGmCSxSMLIndexTypeData | 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 |
| CGmCSxSparseMatrixLayout | A structure for storing a matrix layout in either CSR or CSC format. The template type defines the type that will be used for storing indices (the Armadillo library, for example, works with a 64 bits index while the LIS library works with a 32 bits index) |
| CGmDataDeserializer | A deserializer object used to read mesh data from several file formats |
| CGmDefaultPCR | An "empty" PCR object that will neither partition, color or renumber the mesh |
| CGmDefValueValueSetStoredData | A GmValueSetStiredData implementation that stores no data and returns the default value, whenever queried, until a different value is written to the set. At that moment, instructs the Value set that owns this data set to exchange it by a base container that will contain the data from that moment on |
| CGmDGHexCellGeometryInfo | The DGHex implementation |
| CGmDGHexShape | |
| CGmDGQuadCellGeometryInfo | The DGQuad implementation |
| CGmDGQuadShape | |
| CGmDiscontinuity | The 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 |
| CGmDiscontinuityAccessor | Proxy object to a value accesor implementing a more convenient interface where indices used to retrieve / store values are replaced by a reference to the discontinuity |
| CGmDiscontinuitySet | Base interface for providing discontinuity geometry information for spatial indices |
| CGmDiscontinuitySetStateDumpItem | |
| CGmDofMap | An interface for a simple class returning the dof number associated to a local matrix column |
| ►CGmDualVector | 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 |
| CGmDualVectorR | A class very simmilar to GmDualVector with support for removing values. Removing values should be used with caution. See the comments on the function |
| CGmEdgeListDiscontinuity | Edge based 2D representation for a discontinuity |
| CGmElement | Base interface for FEM (finite element) mesh elements |
| CGmElementDof | A class to represent the degrees of freedom associated with each node of an element as seen by a physics object |
| CGmElementMesh | Base interface for FEM (finite element) meshes |
| CGmFaceListDiscontinuity | Face based 3D representation for a discontinuity |
| CGmFileExtraNodes | An auxiliary class for emiting extra mesh nodes needed by standard GeMA element transformations that can be used while exporting data |
| ►CGmFileFilter | A 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 |
| CGmFileFormat | Basic interface for describing high level file format capabilities |
| ►CGmFileIO | An object for conducting high level aspects of writing results to export files and / or reading mesh data from input files |
| CGmFileNodeRenumbering | An 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 |
| CGmFileReader | Basic interface for file deserializers |
| CGmFileWriter | Basic interface for file serializers |
| CGmFilterableCoordinateSetBiding | A extension for implementing filtering of points inside a coordinateSetBiding Mostly useful for discontinuity aware interpolation |
| CGmFilteredBorderIterator | 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 | 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 |
| CGmFilteredCellSetGaussIndex | A Gauss index interface indexing a filtered set of mesh elements |
| CGmFilteredGaussIndexBase | A helper class that implements a GaussIndex like interface for the case where the index can filter cells, indexing just a part of the set of mesh cells, either by working with a cell group or by indexing active cells only (or both) |
| CGmFixedMeshSetGaussIndex | A Gauss index interface always indexing ALL the elements in either the full mesh or in the given mesh cell list. Once built, the index is fixed |
| CGmForeachCellHelperClass | Helper class for the GmForeachActiveXxxx() family of macros |
| CGmForeachCellHelperClassBase | Base helper class for the GmForeachXxxx() family of macros |
| CGmForeachOrderedCellHelperClass | Helper class for the GmForeachOrderedActiveXxxx() family of macros |
| CGmFValueSetPackedData | The value set data object for packed data with function support. Very similar to GmFVectorValueSetStoredData. See that class comments for an explanation of the nan box way of storing functions |
| CGmFVectorValueSetStoredData | A GmValueSetStoredData implementation that adds support for storing functions to GmVectorValueSetStoredData |
| CGmGaussAccessor | Proxy object to a value accessor implementing a more convenient interface to retrieve / store values for Gauss attributes |
| CGmGaussAcResultsDataSrc | A GmAcResultsDataSrc class holding a Gauss value accessor |
| CGmGaussCloudToPointInterpolator | Interpolator class for calculating values for a point from a Gauss point cloud surrounding the point |
| CGmGaussCloudToPointMInterpolator | Interpolator class for calculating multiple values for a point from a Gauss point cloud surrounding the point |
| CGmGaussCoordinates | A helper class that returns the coordinates of an element's Gauss points. This class should not be instanced directly. Use GmSingleGaussCoordinates or GmMultiGaussCoordinates instead |
| CGmGaussIndex | A 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 |
| CGmGaussIndexProxy | A helper class that implements a GmGaussIndex interface from a proxy object that includes all the needed functions but DOES NOT inherit from GmGaussIndex (and so does not incur in a virtual function call penalty) |
| CGmGaussIntegrationTables | A class storing tables with (position, weight) pairs for line, triangle and tetrahedron Gauss integration rules |
| CGmGaussNeighborsToNodeInterpolator | Interpolator class for calculating node values from a Gauss point cloud surrounding the node |
| CGmGaussNeighborsToNodeMInterpolator | Interpolator class for calculating multiple node values from a Gauss point cloud surrounding the node |
| CGmGaussToElementNodeInterpolator | Interpolator class for calculating element node values from data stored on the element Gauss points |
| CGmGaussToElementNodeMInterpolator | Interpolator class for calculating multiple element node values from multiple data stored on the element Gauss points |
| CGmGaussToElementPointInterpolator | Interpolator class for calculating element internal point values from data stored on the element Gauss points |
| CGmGaussToElementPointMInterpolator | Interpolator class for calculating multiple element internal point values from multiple data stored on the element Gauss points |
| CGmGaussValueSet | Inheriting from GmValueSet, this class adds the peculiarities needed for saving values in Gauss points |
| CGmGaussValueSetGroup | A derived class from GmValueSetGroup storing GmGaussValueSet objects |
| CGmGenericNodeSet | |
| CGmGhostNodeAccessor | A proxy class that receives as parameters two accessors for the same data, one for the common node data and the other for ghost node data, reimplementing the interface defined by GmValueAccessor to use one accessor or the other depending on the given node index |
| CGmGroupDumpItem | A basic interface used for creating dump items for objects that can be dumped by a composition of multiple individual dump items |
| CGmHashCSxSparseMatrixLayoutBuilder | A class for creating a CSR/CSC matrix layout by using an intermediary hash table to consolidate the (row, column) pairs |
| CGmHashSparseVector | |
| CGmHdf5Model | A helper class with enums and methods common to GmHdf5ModelWriter & GmHdf5ModelReader |
| ►CGmHdf5ModelReader | A helper class used to parse and retrieve data from am hdf5 model file. Used by the mesh plugin to read mesh data and by the core to read boundary conditions & discontinuity set data |
| CGmHdf5ModelWriter | A class used to export parts of a GeMA model to an HDF5 file. Its API includes both GeMA centric functions, exporting the model based on the contents from a GmModelData object, and more "neutral" functions, exporting the model contents from primitives that receive their data from standard vectors. The second set of functions is appropriate to be called from external codes using the GeMA core library as a helper to create the HDF5 model file |
| CGmHElement | Hierarchical element |
| CGmHex20CellGeometryInfo | The hex20 implementation |
| CGmHex20Shape | GmShape specialization for a Hexahedron with 20 nodes object |
| CGmHex27CellGeometryInfo | The hex27 implementation |
| CGmHex27Shape | GmShape specialization for a Hexahedron with 27 nodes object |
| CGmHex8CellGeometryInfo | The hex8 implementation |
| CGmHex8Shape | GmShape specialization for a Hexahedron with 8 nodes object |
| CGmHexEdgeIntegrationRule | Integration rule for Hex element edges |
| CGmHexFaceIntegrationRule | Integration rule for Hex element faces |
| CGmHexGaussEdgeIntegrationRule | Gauss integration rule for Hex element borders (edges) |
| CGmHexGaussFaceIntegrationRule | Gauss integration rule for Hex element borders (faces) |
| CGmHexGaussIntegrationRule | 3D Isotropic / anisotropic Gauss integration rules for Hex elements |
| CGmHexLobattoEdgeIntegrationRule | Lobatto integration rule for Hex element borders (edges) |
| CGmHexLobattoFaceIntegrationRule | Lobatto integration rule for Hex element borders (faces) |
| CGmHexLobattoIntegrationRule | 3D Isotropic / anisotropic Lobatto integration rules for Hex elements |
| CGmHexNewtonIntegrationRule | 3D Isotropic / anisotropic Newton cotes integration rules for Hex elements |
| CGmHexShape | GmShape specialization for Hexahedrons, containing common functions used by concrete Hex specializations, such as Hex8 or Hex27 |
| CGmHHexPCellGeometryInfo | The HHexP implementation |
| CGmHHexPShape | Hierarchical shape functions for a HHEXP element |
| CGmHPDGHexCellGeometryInfo | The base class for both HHexP & DGHex implementations. Most functions are analogue to a Hex8 implementation |
| CGmHPDGQuadCellGeometryInfo | The base class for both HQuadP & DGQuad implementations. Most functions are analogue to a Quad4 implementation |
| CGmHQuadPCellGeometryInfo | The HQuadP implementation |
| CGmHQuadPShape | Hierarchical shape functions for a HQUADP element |
| CGmHShape | Shape function handling base classe for hierarchical elements |
| CGmIdwInterpolatorObject | Implements the Inverse Distance Weighted interpolation method |
| CGmInt2DL4CellGeometryInfo | The Int2DL4 implementation |
| CGmInt2DL4Shape | GmShape specialization for a 2D linear interface element with 4 nodes object |
| CGmInt2DL6CellGeometryInfo | The Int2DL6 implementation |
| CGmInt2DL6Shape | GmShape specialization for a 2D coupled interface element with 6 nodes object with 4 nodes (x, y, p) and 2 nodes only of pore pressure |
| CGmInt2DQ6CellGeometryInfo | The Int2DQ6 implementation |
| CGmInt2DQ6Shape | GmShape specialization for a 2D quadratic interface element with 6 nodes object |
| CGmInt2DQ8CellGeometryInfo | The Int2DQ8 implementation |
| CGmInt2DQ8Shape | GmShape specialization for a 2D quadratic interface element with 8 nodes object 2 nodes (x, y), 4 nodes (x, y, p) and 2 middle-nodes only of pore pressure |
| CGmInt2DShape | GmShape specialization for Cohesive elements, containing common functions used to model fracture process, joints and composites. Such as: Int2dl4 or Int2dl6 |
| CGmInt3DL12CellGeometryInfo | The Int3DL12 implementation |
| CGmInt3DL12Shape | GmShape specialization for a 2D coupled cohesive element with 6 nodes object 4 nodes (x, y, p) and 2 nodes only of pore pressure |
| CGmInt3DL6CellGeometryInfo | The Int3DL6 implementation |
| CGmInt3DL6Shape | GmShape specialization for a 3D triangular interface element with 8 nodes object |
| CGmInt3DL8CellGeometryInfo | The Int3DL8 implementation |
| CGmInt3DL8Shape | GmShape specialization for a 3D cohesive element with 8 nodes object |
| CGmInt3DL9CellGeometryInfo | The Int3DL9 implementation |
| CGmInt3DL9Shape | GmShape specialization for a 2D coupled cohesive element with 6 nodes object 4 nodes (x, y, p) and 2 nodes only of pore pressure |
| CGmInt3DQ12CellGeometryInfo | The Int3DQ12 implementation |
| CGmInt3DQ12Shape | GmShape specialization for a 3D triangular interface element with 8 nodes object |
| CGmInt3DQ15CellGeometryInfo | The Int3DQ15 implementation |
| CGmInt3DQ15Shape | GmShape specialization for a 2D coupled cohesive element with 6 nodes object 4 nodes (x, y, p) and 2 nodes only of pore pressure |
| CGmInt3DQ16CellGeometryInfo | The Int3DQ16 implementation |
| CGmInt3DQ16Shape | GmShape specialization for a 3D cohesive element with 8 nodes object |
| CGmInt3DQ20CellGeometryInfo | The Int3DQ20 implementation |
| CGmInt3DQ20Shape | GmShape specialization for a 2D coupled cohesive element with 6 nodes object 4 nodes (x, y, p) and 2 nodes only of pore pressure |
| CGmInt3DShape | GmShape specialization for 3D Cohesive elements, containing common functions used to model fracture process, joints amd composites. Such as: Int3dl8 or Int3dl16 |
| CGmInt3DTriShape | GmShape specialization for Wedge interface elements, containing common functions used by Wedge interface specializations, such as Int3dl6, Int3dl9, Int3dq12 or Int3dq15 |
| CGmIntegrationRule | Integration rule base classe |
| CGmInternalThread | The internal thread class, inheriting from QThread, used for calling the GmThread::run() method |
| CGmInterpolator | Interpolator class used for managing available interpolator algorithms and providing basic support functions with operations common to every derived class. |
| CGmInterpolatorCellNodeCoordinateSetBinding | A node coordinate set that iterates over nodes from a single mesh cell / element. Nodes are returned in the same order as they appear at the cell/element |
| CGmInterpolatorCoordinateSetBinding | Basic 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 |
| CGmInterpolatorElementGaussCoordinateSetBinding | A Gauss coordinate set that iterates over Gauss points from a single mesh element. Nodes are returned in the same order as they are returned by the associated integration rule |
| CGmInterpolatorGaussCoordinateSetBinding | Interface for a coordinate set that stores Gauss point coordinates. Besides returning coordinates, can also return the Gauss point element and integration point index associated with each coordinate |
| CGmInterpolatorGaussDataBinding | A GmInterpolatorInputDataBinding implementation returning values provided by a Gauss value accessor. Its base class is a template parameter so that we can share the same implementation for an GmInterpolatorInOutDataBinding descendent. The second template should be either a const GmGaussAccessor* or a GmGaussAccessor* |
| CGmInterpolatorGaussInOutDataBinding | GmInterpolatorInOutDataBinding implementation working with values provided by a Gauss value accessor |
| CGmInterpolatorGaussListCoordinateSetBinding | A Gauss coordinate set that iterates over the specified Gauss points |
| CGmInterpolatorGaussOutputDataBinding | GmInterpolatorOutputDataBinding implementation storing a single value in a Gauss point through an accessor |
| CGmInterpolatorInOutDataBinding | A version of GmInterpolatorInputDataBinding that lets us to also update the stored data |
| CGmInterpolatorInputDataBinding | Binding 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 |
| CGmInterpolatorMatrixInputDataBinding | GmInterpolatorInputDataBinding implementation returning values provided by a matrix |
| CGmInterpolatorMatrixOutputMultiDataBinding | GmInterpolatorOutputMultiDataBinding implementation storing a single value in a matrix |
| CGmInterpolatorMeshGaussCoordinateSetBinding | A Gauss coordinate set that iterates over ALL the Gauss points from mesh, optionaly filtered by the set of active cells. Values are returned ordered by cell id and, for each cell, in the same order as they are returned by the associated integration rule |
| CGmInterpolatorMeshNodesCoordinateSetBinding | A node coordinate set that iterates over all geometry nodes from a mesh. Nodes are returned in the same order as they appear in the mesh |
| CGmInterpolatorMGaussDataBinding | A GmInterpolatorInputDataBinding implementation returning values provided by a list of Gauss value accessors. Its base class is a template parameter so that we can share the same implementation for an GmInterpolatorInOutDataBinding descendent. The second template should be either a const GmGaussAccessor* or a GmGaussAccessor* |
| CGmInterpolatorMGaussInOutDataBinding | GmInterpolatorInOutDataBinding implementation working with values provided by a list of Gauss value accessors |
| CGmInterpolatorMGaussOutputDataBinding | GmInterpolatorOutputDataBinding implementation storing multiple values in a Gauss point through an accessor list |
| CGmInterpolatorMMatrixInputDataBinding | GmInterpolatorInputDataBinding implementation returning values provided by a list of matrices |
| CGmInterpolatorMMatrixOutputMultiDataBinding | GmInterpolatorOutputMultiDataBinding implementation storing multiple values in a matrix list |
| CGmInterpolatorMNodeDataBinding | A GmInterpolatorInputDataBinding implementation returning values provided by a list of node value accessors. Its base class is a template parameter so that we can share the same implementation for an GmInterpolatorInOutDataBinding descendent. The second template should be either a const GmValueAccessor* or a GmValueAccessor* |
| CGmInterpolatorMNodeInOutDataBinding | GmInterpolatorInOutDataBinding implementation working with values provided by a list of node value accessors |
| CGmInterpolatorMNodeOutputDataBinding | GmInterpolatorOutputDataBinding implementation storing multiple values in a node through an accessor list |
| CGmInterpolatorMVectorOutputDataBinding | GmInterpolatorOutputDataBinding implementation storing multiple values in a vector list |
| CGmInterpolatorNeighborGaussCoordinateSetBinding | A Gauss coordinate set that iterates over Gauss points from elements adjacent to a given node. The set of Gauss points can include all points in the neighboring elements or only those closest to the node |
| CGmInterpolatorNodeCoordinateSetBinding | Interface for a coordinate set that stores node coordinates. Besides returning coordinates, can also return the mesh node index associated with each coordinate |
| CGmInterpolatorNodeDataBinding | A GmInterpolatorInputDataBinding implementation returning values provided by a node value accessor. Its base class is a template parameter so that we can share the same implementation for an GmInterpolatorInOutDataBinding descendent. The second template should be either a const GmValueAccessor* or a GmValueAccessor* |
| CGmInterpolatorNodeInOutDataBinding | GmInterpolatorInOutDataBinding implementation working with values provided by a node value accessor |
| CGmInterpolatorNodeListCoordinateSetBinding | A node coordinate set that iterates over nodes from a node list. Nodes are returned in the same order as they appear in the list |
| CGmInterpolatorNodeOutputDataBinding | GmInterpolatorOutputDataBinding implementation storing a single value in a node attribute through an accessor |
| CGmInterpolatorNodeSetCoordinateSetBinding | A node coordinate set that iterates over all nodes from a node set. Nodes are returned in the same order as they appear in the set |
| CGmInterpolatorObject | Interface class for the implementation of each of the possible interpolation algorithms available in GmInterpolatorType |
| CGmInterpolatorOutputCoordinateBinding | Binding class used to provide the coordinate of the interpolated point, either in cartesian or natural coordinates, according to the interpolator requirements |
| CGmInterpolatorOutputDataBinding | Binding 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 |
| CGmInterpolatorOutputMultiDataBinding | Binding 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 |
| CGmInterpolatorVectorOutputDataBinding | GmInterpolatorOutputDataBinding implementation storing a single value in a vector |
| CGmIntGaussIntegrationRule | Gauss Integration rule for 3D triangular interface. Similar to GmTriGaussIntegrationRule but uses natural coordinates with only two components |
| CGmIntNewtonIntegrationRule | Newton Cotes Integration rule for 3D triangular interface. Similar to GmTriNewtonIntegrationRule but uses natural coordinates with only two components |
| CGmLinearMultiTableIntegrationRule | A helper class used to combine 1, 2 or 3 single "line" integration rule tables into a multi-dimensional integration rule. The combined rule has the same number of natural coordinates as the number of supplied tables. Also, each rule parameter corresponds to a table and rule degree |
| CGmLineGaussIntegrationRule | 1D Gauss Integration rules (for bar elements) |
| CGmLineLobattoIntegrationRule | 1D Lobatto Integration rules (for bar elements) |
| CGmLineNewtonIntegrationRule | 1D Newton cotes Integration rules (for bar elements) |
| CGmLinkedSparseVector | |
| CGmLobattoIntegrationTables | A class storing tables with (position, weight) pairs for line Lobatto integration rules |
| CGmLogCategory | Class representing a category with multiple logging levels |
| CGmLogContextData | Auxiliary structure with global Log configuration |
| CGmLogIdentClearer | RAII object to clear the identation level to log messages, restoring to the previous identation when the object is destroyed |
| CGmLogIdenter | RAII object to add an identation level to log messages, reverting the settings when the object is destroyed |
| CGmLogSignalEmitter | Aux class whose only purpose is to allow loggers to emit a logMessage signal, if configured to do so |
| CGmMatrixDof | A class to represent the degrees of freedom associated with the set of matrix columns, as seen by a physics object |
| CGmMatrixSet | |
| CGmMemoryBufferList | A 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() |
| ►CGmMemoryDump | Class storing a memory dump containing several dump items |
| CGmMemoryDumpItem | Interface for an object that can be dumped and undumped to either file or memory by GmMemoryDump |
| CGmMemoryDumpItemScopedBufferOp | A 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 |
| CGmMesh | Base interface class for Mesh type plugins |
| CGmMeshGaussIndex | A Gauss index interface always indexing ALL the elements of a mesh, with support for mesh growing |
| CGmMeshNodeSet | A node set wrapper over a common mesh. Constant (no support for setNodeData()) |
| CGmMlsInterpolatorObject | Implements the Moving Least Squares interpolation method |
| CGmModelData | Auxiliar class used to store the complete set of model data for a simulation |
| CGmMonitorResultsRule | A results rule used to send the associated data sets to the monitor server thread |
| CGmMonitorResultsRuleTester | A helper class used to help testing monitor rules without the need for a connected external server |
| CGmMultiGaussCoordinates | A helper class that returns the coordinates of an element's Gauss points, tailored to be used inside a loop over a set of elements |
| CGmNanBoxedIndex | A helper class to store an usigned index as the boxed nan value |
| CGmNanBoxedValue | A wrapper class around QtNanBoxedValue providing specific constructors to store user functions / user function evaluators together with double values |
| CGmNewtonIntegrationTables | A class storing tables with (position, weight) pairs for line, triangle and tetrahedron Open & closed Newton Cotes integration rules |
| ►CGmNfFileFormat | File format specifications for the "Neutral File" file format |
| CGmNfFileReader | A file deserializer for reading data in the "Neutral File" file format |
| ►CGmNfFileWriter | A file serializer for saving data in the "Neutral File" file format |
| CGmNnInterpolatorObject | Implements the Nearest Neighbor interpolation method |
| CGmNodeAcResultsDataSrc | A GmAcResultsDataSrc class holding a node value accessor |
| CGmNodeCloudToPointConformInterpolator | Interpolator class for calculating values for a point from a node cloud surrounding the point with custom selection based on visibility and element sign |
| CGmNodeCloudToPointInterpolator | Interpolator class for calculating values for a point from a node cloud surrounding the point |
| CGmNodeCloudToPointMInterpolator | Interpolator class for calculating multiple values for a point from a node cloud surrounding the point |
| CGmNodeSet | This class stores a set of nodes belonging to a mesh. The nodes can belong to the mesh boundary but that is not necessary |
| CGmNodeTaskDataSet | Base class for accessing the set of nodes belonging to a mesh partition |
| CGmNodeToCellPointInterpolator | Interpolator class for calculating values for a point inside a cell, from data stored on the cell nodes |
| CGmNodeToCellPointMInterpolator | Interpolator class for calculating multiple values for a point inside a cell, from multiple data stored on the cell nodes |
| CGmNodeToElementPointInterpolator | Interpolator class for calculating values for a point inside an element, from data stored on the element nodes |
| CGmNodeToElementPointInterpolatorH | Interpolator class for calculating single value for a point inside an element, from single data stored on the discontinuous and hierarchical elements nodes |
| CGmNodeToElementPointMInterpolator | Interpolator class for calculating multiple values for a point inside an element, from multiple data stored on the element nodes |
| CGmNoFunctionValueSetDataAccessor | An accessor implementation that can work with any kind of GmValueSetData, without support for functions and unit conversion |
| CGmNoFValueSetPackedData | The value set data object for packed data without function support. Very similar to GmVectorValueSetStoredData |
| CGmNumSolver | Base interface class for NumSolver type plugins |
| CGmNumSolverPrinter | A 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 |
| CGmOmpTempUpdateNumThreads | A RAII class used to temporarily adjust the number of OMP threads in effect |
| CGmPackedBuffer | The basic interface for a shared buffer storing interleaved data for a group of value sets |
| CGmPackedBufferImpl | The concrete implementation for GmPackedBuffer. The template parameter defines the kind of vector used for storing the data. Can be instanced with Vector equal to GmSingleVector or GmDualVectorR (dual vector with support for remove values) |
| CGmPackedBufferInfo | A class used for storing and managing the order of the value sets inside a pack |
| CGmPath | Class used to store releveant system and project paths, providing functions for path macro translations |
| CGmPCR | Base interface class for Partition-Color-Renumber object plugins |
| CGmPerThreadAppendBuffer | An implementation of the GmAppendBuffer interface based on a "per thread" growing buffer |
| CGmPhysics | Base interface class for Physics type plugins |
| CGmPhysicsUserFunctions | Base interface class for Physics type plugins to export user functions that can be used to provide attributes / property values |
| CGmPluginData | This 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 |
| CGmPluginInfo | Base class used to store information about a generic plugin |
| CGmPluginLoader | Class responsible for managing discovery and loading of plugins |
| CGmPluginLoaderAdder | Auxiliar class used to add objects parsed by GmPluginLoader::loadPluginObjectList() to it's destiny |
| CGmPluginLoaderObjMemberAdder | Especialization of GmPluginLoaderAdder to add objects to a container 'U' by calling one member function of this container with a signature that receives a pointer to a 'T' object (that must inherit from GmPluginObject) and returns a boolean indicating wheater the insertion was successfull or not |
| CGmPluginObject | Base interface class for all object plugins |
| CGmPluginObjectFactory | Factory class exported by every plugin object |
| CGmpMmGaussData | |
| CGmPODVector | 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 |
| ►CGmPolygonTriangulator | |
| CGmPolylineDiscontinuity | Polyline 2D representation for a discontinuity |
| CGmPolylineSegment | |
| CGmpRefDist | |
| CGmPrintResultsRule | A results rule printing the associated data sets to the logger |
| CGmPrintUtils | Groups utilitary routines for pretty printing data |
| CGmProcess | Base interface class for Process type plugins |
| ►CGmProcessMethodRedirector | 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 |
| CGmPropertyCellAccessor | Extends GmCellAccessor to handle property accessors |
| CGmPropertyDiscontinuityAccessor | Extends GmDiscontinuityAccessor to handle property accessors |
| CGmPropertySet | Interface storing property descriptions and values |
| CGmProxyBorderIntegrationRule | Common code for border integration rules based on a given integration rule that is used to implement most of the border interface methods |
| CGmPyra13CellGeometryInfo | The Pyra13 implementation |
| CGmPyra13Shape | GmShape specialization for a Tetrahedron with 4 nodes object |
| CGmPyra5CellGeometryInfo | The Pyra5 implementation |
| CGmPyra5Shape | GmShape specialization for a Pyramid with 5 nodes object |
| CGmPyraGaussEdgeIntegrationRule | Gauss integration rule for Tet element borders (edges) |
| CGmPyraGaussFaceIntegrationRule | Newton Integration rule for pyramid elements. Should be included |
| CGmPyraGaussIntegrationRule | 3D integration rules for Pyramid elements |
| CGmPyraShape | GmShape specialization for Pyramid, containing common functions used by concrete Pyra specializations, such as pyra5 or pyra13 |
| CGmQuad3D4CellGeometryInfo | The Quad3D4 implementation |
| CGmQuad3D4Shape | GmShape specialization for a 3D Quadrilateral with 4 nodes object |
| CGmQuad3D8CellGeometryInfo | The Quad3D8 implementation |
| CGmQuad3D8Shape | GmShape specialization for a 3D Quadrilateral with 8 nodes object |
| CGmQuad4CellGeometryInfo | The Quad4 implementation |
| CGmQuad4Shape | GmShape specialization for a Quadrilateral with 4 nodes object |
| CGmQuad8CellGeometryInfo | The Quad8 implementation |
| CGmQuad8Shape | GmShape specialization for a Quadrilateral with 8 nodes object |
| CGmQuad9CellGeometryInfo | The Quad9 implementation |
| CGmQuad9Shape | GmShape specialization for a Quadrilateral with 9 nodes object |
| CGmQuadEdgeIntegrationRule | Integration rule for Quad element borders |
| CGmQuadGaussEdgeIntegrationRule | Gauss integration rule for Quad element borders |
| CGmQuadGaussIntegrationRule | 2D Isotropic / anisotropic Gauss integration rules for Quad elements |
| CGmQuadLobattoEdgeIntegrationRule | Lobatto integration rule for Quad element borders |
| CGmQuadLobattoIntegrationRule | 2D Isotropic / anisotropic Lobatto integration rules for Quad elements |
| CGmQuadNewtonIntegrationRule | 2D Isotropic / anisotropic Newton cotes integration rules for Quad elements |
| CGmQuadShape | GmShape specialization for Quadrilaterals, containing common functions used by concrete Quad specializations, such as Quad4, Quad8 or Quad9 |
| CGmReducedBarycentricSingleTableIntegrationRule | An especialization of the barycentric, single table, integration rule class to treat the case when the number of coordinates used by the integration rule is one less than the number of coordinates in the rule table. In that case, the FIRST barycentric coordinate from the table is IGNORED. That is used by some interface elements |
| CGmRegularGridMesh | Base interface class for Regular Grid Mesh type plugins |
| CGmResultsData | Auxiliar class used to store the complete set of results data for a simulation |
| CGmResultsDataSet | A set storing what should be exported (saved / printed / monitored) by the result rule classes |
| CGmResultsDataSrcInfo | A 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 |
| CGmResultsEvalSet | A class storing the evaluation points for a set of rules |
| CGmResultsRule | A 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 |
| CGmResultsRuleAggregator | A 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 |
| ►CGmResultsTimeManager | Collects all the time data from several TimeSet objects, controlling the next time "moments" (time, iterations, etc) where a results rule should be "activated" |
| ►CGmResultsTimeSet | A rule specifying the execution moments (time, iterations, etc) that a result rule should be executed |
| CGmResultsTrackedData | A 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 |
| CGmResultsTrackedIndexData | The 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 | |
| CGmRunProgress | A 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 |
| CGmRunProgressOnMainThread | An alternative implementation of GmRunProgress that when called from a worker thread does nothing |
| ►CGmRunProgressReport | A class used to create formatted reports based on ProgressStats item attribute values |
| CGmRunProgressStats | A class used to store time, memory and additional values statistics related to the simulation loading and execution |
| ►CGmRunProgressStatsItem | An item used to store time, memory and additional values statistics related to the simulation loading and execution. This is not a general purpose class and should be used only by GmRunProgressStats. In fact it is not declared inside GmRunProgressStats due to its need to inherit from QObject |
| CGmSaveResultsRule | A results rule saving the associated data sets to a file |
| CGmSegmentCell2DIntersectionCoordAccessor | A 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 |
| ►CGmSegmentCellIntersection | Representation for the intersection between a polyline segment and a mesh cell. Can be used both in 2D and in 3D |
| CGmSeqBlockCellTaskDataSet | A GmCellTaskDataSet implementation returning a continuous block of cells, optionally filtered for active cells only. Expects M to be a GmCellMesh or a GmCellGroupSet |
| CGmSeqBlockNodeSetTaskDataSet | |
| CGmSeqBlockNodeTaskDataSet | A GmNodeTaskDataSet implementation returning a continuous block of nodes |
| CGmShape | Shape function handling base classe. |
| CGmShapeInterpolatorObject | Implements the Shape function and linear shape function interpolation methods |
| CGmShapeOrthogonalPol | Orthogonal polynomial calculation |
| CGmSimulationData | Auxiliar class used to store the complete set of simulation data |
| ►CGmSingleAppendBuffer | An implementation of the GmAppendBuffer interface based on synchoronized access to a shared buffer |
| CGmSingleGaussCoordinates | A helper class that returns the coordinates of an element's Gauss points. Should be used when we want to get coordinates from a SINGLE element. If you are going to get coordinates for multiple elements in a loop, prefer using GmMultiGaussCoordinates |
| CGmSingleTableIntegrationRule | A helper class used to implement rules based on a single table storing the full natural coordinate + its weight. It can be used, for example, to implement triangular, tetrahedron and pyramid integration rules. The N template parameter defines the number of natural coordinates returned by the rule |
| CGmSingleVector | A class with the same API as GmDualVector storing a single vector. No query "if" overhead. Ideal for static meshes |
| CGmSolutionData | Auxiliar class used to store the complete set of solution methods data for a simulation |
| CGmSolverMatrix | Base interface class for Solver Matrix objects. |
| CGmSparseMatrix | A class for wrapping up a sparse matrix, either using CSR or CSC format. Can also differ on the type used for storing line and column indices |
| CGmSparseMatrixBase | A base class derived from QObject. Needed since GmSparseMatrix is a template and so can't inherit directly from QObject |
| CGmSparseMatrixLayout | A base structure for storing layout data for sparse matrices (fill structure or non zero positions). The matrix data itself is not stored, allowing for the layout to be shared among several matrices if needed |
| CGmSparseMatrixLayoutBuilder | An interface for building the layout structure of a sparse matrix |
| CGmSparseMatrixOptions | Set of configuration options for Sparse matrices |
| CGmSparseMatrixPerThreadTripletBuffer | Especialization of the GmPerThreadAppendBuffer class using the GmSparseMatrixTripletBuffer interface |
| CGmSparseMatrixSingleTripletBuffer | Especialization of the GmSingleAppendBuffer class using the GmSparseMatrixTripletBuffer interface |
| CGmSparseMatrixTripletBuffer | An especialization of GmAppendBufffer for triplet data with an extra method for returning the buffer already sorted |
| CGmSparseMatrixTripletData | Aux structure used when building sparse matrices with the help of a triplet list. The tripet structure stores 2 ints |
| CGmSpatialIndex | Base interface class for Spatial Index type plugins |
| CGmSpinLock | A simple spin lock implementation based on a loop using test and set over an atomic int to change its value from 0 to 1 |
| CGmSpinLocker | RAII object used to acquire a spin lock and release it upon object destruction |
| CGmStateDump | Presents a higher level of abstraction over GmMemoryDump, storing accessor data, vector data or user buffers |
| CGmStateDumpAccessorDataItem | Interface responsible for providing information of mesh and if the accessors stored in derived classes contains geometry node information |
| CGmStateDumpArmaDataItem | Class responsible for storing either a GmVector / GmMatrix object |
| CGmStateDumpBaseDataItem | Ensure that all dump items stored by GmStateDump have an id() and a logger |
| ►CGmStateDumpBufferDataItem | Class responsible for storing one or more user buffer objects |
| CGmStateDumpDiscontinuityStreamItem | |
| CGmStateDumpFileItem | Class responsible for storing the needed data to rollback an "append only" file to a previous state |
| CGmStateDumpFunctionMapDataItem | Class responsible for storing a table mapping function pointers (either an user function or a function evaluator) to function ids |
| CGmStateDumpLuaDataItem | Class responsible for storing Lua global / local values |
| CGmStateDumpMapDataItem | Class responsible for storing a QMap of values. Useful for storing generic sets of "scalar" attributes |
| CGmStateDumpMatrixDataItem | Class responsible for storing a GmMatrix object |
| CGmStateDumpSDVectorDataItem | Class responsible for storing a GmSingleVector or a GmDualVector |
| CGmStateDumpSplitIntVecDataItem | Class responsible for storing the contents provided by a list of int vectors, each with its own size, possibly empty. The list size can also change over time |
| CGmStateDumpStreamableItem | General class for QT streamable objects |
| CGmStateDumpValueSetDataItem | A GmMemoryDumpItem implementation loading / storing values from the GmValueSetData object associated with the given accessor, by directly reading / writing from its internal buffer. The accessor MUST inherit from GmTrackedValueAccessor and the value set data object MUST implement the dumpBuffer() interface (unless it is a GmDefValueValueSetData object) |
| CGmStateDumpVariantMapDataItem | Class responsible for a QVariantMap of values. Useful for storing generic sets of "scalar" attributes |
| CGmStateDumpVectorDataItem | Class responsible for storing a GmVector object |
| CGmStateVar | Auxiliar class used to store the definition of a state variable. |
| CGmStrideCellTaskDataSet | A GmCellTaskDataSet implementation with strided access, optionally filtered for active cells only. Expects M to be a GmCellMesh or a GmCellGroupSet |
| CGmStrideNodeTaskDataSet | A GmNodeTaskDataSet implementation with strided access |
| CGmTaskManager | Task manager used for handling parallel executions |
| CGmTet10CellGeometryInfo | The Tet10 implementation |
| CGmTet10Shape | GmShape specialization for a Tetrahedron with 4 nodes object |
| CGmTet4CellGeometryInfo | The Tet4 implementation |
| CGmTet4Shape | GmShape specialization for a Tetrahedron with 4 nodes object |
| CGmTetGaussEdgeIntegrationRule | Gauss integration rule for Tet element borders (edges) |
| CGmTetGaussFaceIntegrationRule | Gauss integration rule for Tet element faces |
| CGmTetGaussIntegrationRule | 3D integration rules for Tet elements |
| CGmTetNewtonIntegrationRule | Newton Integration rule for tetrahedron elements. Accepts both open and closed rules |
| CGmTetShape | GmShape specialization for Tetrahedrons, containing common functions used by concrete Hex specializations, such as Tet4 or Tet10 |
| CGmThread | Our thread wrapper, specialized for running tasks from the thread manager queue |
| ►CGmThreadManager | Thread manager used for handling parallel executions |
| CGmThreadTask | Interface for a task executed by a thread manager thread |
| CGmTimeAdder | RAII class used to add the elapsed time to a counter received by reference. Counter is incremented in nano seconds |
| CGmTimeMsg | RAII object used to measure the elapsed time of an operation |
| CGmTLBuffer | 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_Alloc | 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 | A class that works together with GmThreadManager to provide thread local storage |
| CGmTLS_Alloc | 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 | 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) |
| CGmTrackedValueAccessor | Auxiliary class responisble for allowing a value accessor to track changes to the referenced value set data inside a GmValueSet. This is necessary to create locked accessors and to enable value sets storing no data, that always return the default value until the set is written to, when it reverts to a standard data set |
| CGmTri3CellGeometryInfo | The Tri3 implementation |
| CGmTri3D3CellGeometryInfo | The Tri3D3 implementation |
| CGmTri3D3Shape | GmShape specialization for a 3D Triangle with 3 nodes object |
| CGmTri3D6CellGeometryInfo | The Tri3D6 implementation |
| CGmTri3D6Shape | GmShape specialization for a 3D Triangle with 6 nodes object |
| CGmTri3Shape | GmShape specialization for a Triangle with 3 nodes object |
| CGmTri6CellGeometryInfo | The Tri6 implementation |
| CGmTri6Shape | GmShape specialization for a Triangle with 6 nodes object |
| CGmTriGaussEdgeIntegrationRule | Gauss integration rule for Tri element borders |
| CGmTriGaussIntegrationRule | Gauss Integration rule for triangle elements. Base on Felippa, IFEM, section 24.2 |
| CGmTriNewtonIntegrationRule | Newton Integration rule for triangle elements. Accepts both open and closed rules |
| CGmTriShape | GmShape specialization for Triangles, containing common functions used by concrete Tri specializations, such as Tri3 or Tri6 |
| CGmTriSurfaceDiscontinuity | Surface 3D representation for a discontinuity |
| CGmUnfilteredGaussIndexBase | A 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) |
| CGmUnitConversionDataAccessor | A template class to add unit conversion support to the given base class |
| ►CGmUserFunction | Class used to store the definition of a user function and its parameters |
| CGmUserFunctionContext | The context received by C methods giving access to parameters data and metadata |
| ►CGmUserFunctionEvaluator | Class responsible for evaluating a UserFunction over a node / cell |
| CGmValueAccessor | Interface class for accessing and setting values from an "indexable" collection of values |
| CGmValueAccessorBase | An implementation of basic attributes and functions that should be common for most value accessor implementations |
| CGmValueInfo | Auxiliar class used to store the definition of a value. It can be used to store informations about state variables, attributes and properties |
| CGmValueSet | Basic class used to store sets of values, bound to a common definition, on behalf of another object (a mesh most likely) that contains a known maximum size of values (nodes or cells, for example) |
| CGmValueSetData | The 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 |
| CGmValueSetDataAccessor | An accessor implementation that can work with any kind of GmValueSetData, with or without functions, but without unit conversion support |
| CGmValueSetDataAccessorBase | Common code for both GmNoFunctionValueSetDataAccessor and GmValueSetDataAccessor |
| CGmValueSetEvalContex | |
| ►CGmValueSetEvalContext | Auxiliar class used to store the needed information to translate an user function id / user function into an user function evaluator |
| CGmValueSetGroup | This 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 |
| CGmValueSetPackedData | The generic GmValueSetData interface for packed storage |
| CGmValueSetStoredData | The generic GmValueSetData interface for classes that do store their own data |
| ►CGmVectorCSxSparseMatrixLayoutBuilder | A class for creating a CSR/CSC matrix layout by using an intermediary vector based structure to consolidate the (row, column) pairs |
| CGmVectorResizer | 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 | |
| CGmVectorValueSetStoredData | A GmValueSetStoredData implementation that supports efficient storing for numeric values, either scalar or multi-dimensional, in a vector storage |
| CGmWedge15CellGeometryInfo | The Wedge15 implementation |
| CGmWedge15Shape | GmShape specialization for a Wedge with 6 nodes object |
| CGmWedge6CellGeometryInfo | The Wedge6 implementation |
| CGmWedge6Shape | GmShape specialization for a Wedge with 6 nodes object |
| CGmWedgeGaussEdgeIntegrationRule | Gauss integration rule for Wedge element borders (edges) |
| CGmWedgeGaussFaceIntegrationRule | Gauss integration rule for Wedge element faces |
| CGmWedgeGaussIntegrationRule | 3D Gauss integration rules for Wedge elements |
| CGmWedgeShape | GmShape specialization for Wedges, containing common functions used by Wedge elements, such as Wedge6 or Wedge15 |
| ►CGmXdmfFileFormat | File format specifications for the Xdmf file format |
| CGmXdmfFileWriter | A file serializer for saving data in the "Xdmf (Hdf5)" file format |
| ►CGmXdmfHdf5 | A 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 |
| CNotifyProgress | |
| CRayIntersection | |
| CStringListAccessor | A simple accessor used to retrieve strings from a list when valueStr() is called. All other functions return 0.0 |
1.12.0