| ►Nbase | |
| CPropDesc | |
| CProperty | |
| CPropertyConvertException | |
| ►Nblock | |
| CIBeamArray | This interface provides access to beam thing array |
| CIBeamContact | This interface provides access to beam contact data |
| CIBeamThing | |
| CIBFaceArray | Container to store FaceThings (original block faces) ID of FaceThing is stored in offset $KFCPP in Fortran block linked list |
| CIBlockArray | Container to store blockThings. ID of BlockThing is stored in offset $KBID in Fortran block linked list |
| CIBlockThing | This is the interface for BlockThing, a class that holds extra data not in the fortran arrays. This will be stored in a container and the ID will be stored in offset $KBID in the fortran block linked list. This inherits from Thing so we can use groups and extra variables |
| CICableArray | This interface provides access to cable thing array |
| CICableThing | |
| CIConfigure | This interface provides linked list offsets to access to configuration settings |
| CIContactArray | This interface provides access to contact thing array |
| CIContactThing | |
| CIDowelArray | This interface provides access to dowel thing array |
| CIDowelThing | |
| CIFaceArray | Container to store FaceThings (zoned or triangulated block faces). ID of FaceThing is stored in offset $KFCPP in Fortran block linked list |
| CIFaceBlockArray | Container to store blockThings that are face blocks. ID of BlockThing is stored in offset $KBID in Fortran block linked list |
| CIFaceData | This class maintains a list of scalar data .
getNames() returns the names of the data available through this interface.
Which data is being accessed is specified by setIndex().
This class is used in contour plotting and profiling, as a generic way to get the same list of gp data to use for various purposes |
| CIFaceThing | This is the interface for FaceThing, a class that holds extra data not in the fortran arrays. This will be stored in a container and the ID will be stored in offset $KFCPP in the fortran block linked list. This inherits from Thing so we can use groups and extra variables |
| CIFEFaceArray | This interface provides access to beam thing array |
| CIFEFaceThing | This is the interface for FEFaceThing, a C++ wrapper for finite element faces. This will be stored in a container and the ID will be stored in offset $kfefcpp in the fortran block linked list. This inherits from Thing so we can use groups and extra variables |
| CIFElementArray | This interface provides access to beam thing array |
| CIFElementThing | This is the interface for FElementThing, a C++ wrapper for finite elements. This will be stored in a container and the ID will be stored in offset $kfeid in the fortran block linked list. This inherits from Thing so we can use groups and extra variables |
| CIFlowKnotArray | Container to store FlowKnotThings |
| CIFlowKnotThing | This is the interface for FlowKnotThing, a C++ wrapper for a flow knot This will be stored in a container and the ID will be stored in offset $KNOTCPP in the fortran flow knot linked list. This inherits from Thing so we can use groups and extra variables |
| CIFlowPlaneArray | Container to store FlowPlaneThings |
| CIFlowPlaneThing | |
| CIFlowPlaneVertexArray | Container to store IFlowPlaneVertexThings |
| CIFlowPlaneVertexThing | This is the interface for FlowPlaneVertexThing, a C++ wrapper for a flow plane vertex This will be stored in a container and the ID will be stored in offset $KEXTCPP in the fortran flow plane vertex linked list. This inherits from Thing so we can use groups and extra variables |
| CIFlowZoneArray | Container to store IFlowZoneThings |
| CIFlowZoneThing | |
| CIGpData | This class maintains a list of scalar data (x-position, density, velocity magnitude, etc).
getNames() returns the names of the data available through this interface.
Which data is being accessed is specified by setIndex().
This class is used in contour plotting and profiling, as a generic way to get the same list of gp data to use for various purposes |
| CIJointFaceArray | This interface provides access to jointthing array |
| CIJointFaceThing | |
| CILinerArray | This interface provides access to liner thing array |
| CILinerThing | |
| CIModuleBlock | |
| CIRangeElementGInt | Interface to a group intersection filter element, used to filter objects by group intersection |
| CIRangeElementOrientation | This interface provides access to orientation filters |
| CIRangeElementState | Interface to a filter element that allows user to filter based on a zone state |
| CIRangeElementSurface | |
| CIRangeElementTwoInt | IRangeElement for RangeElementMaterialIntersection |
| CIReinforcementArray | This interface provides access to reinforcement thing array |
| CIReinforcementThing | |
| CISELNodeArray | Container to store SELNodeThings. ID of SELNodeThing is stored in id offset of Fortran linked list (42 for beams and cables, 21 for liner nodes) |
| CISELNodeThing | This is the interface for SELNodeThing, a class that holds extra data not in the fortran arrays. This will be stored in a container and the ID will be stored in the corresponding offset $xxCPP in the appropriate fortran array This inherits from Thing so we can use groups and extra variables |
| CISelProp | This interface provides access to cable thing. The fortran offset for the SelProp ID is $ktypcpp in the Fortran sel property data array |
| CISelPropArray | This interface provides access to SelProp array |
| CISubcontactArray | Container to store SubcontactThings. ID of SubcontactThing is stored in offset $KCXCPP in Fortran subcontac linked list |
| CISubcontactThing | This is the interface for SubcontactThing, a class that holds extra data not in the fortran arrays. This will be stored in a container and the ID will be stored in offset $KCXCPP in the fortran subcontact linked list. This inherits from Thing so we can use groups and extra variables There is also two-way accessibility with the corresponding fortran data block |
| CIType3DEC | |
| CIVertexArray | Container to store VertexThings. ID of VertexThing is stored in offset $KVCPP in Fortran vertex linked list |
| CIVertexThing | This is the interface for VertexThing. This will be stored in a container and the ID will be stored in offset $KGCPP in the fortran vertex linked list. This inherits from Thing so we can use groups and extra variables |
| CIWater | This interface provides access to functions used to define a water surface |
| CIZoneArray | Container to store ZoneThings. ID of BlockThing is stored in offset $KZCPP in Fortran zone linked list |
| CIZoneData | Access to zone scalar data in a generic way. This class maintains a list of scalar data (sxx, density, porosity, etc).
getNames() returns the names of the data available through this interface.
Which data is being accessed is specified by setIndex().
This class is used in contour plotting and profiling, as a generic way to get the same list of zone data to use for various purposes |
| CIZoneFieldData | Interface for accessing the zone field data class. This class allows access to both gp and zone scalar field data (like density, displacement magnitude, sxx, etc) at any point in the model, not necessarily where a gridpoint or a zone centroid fall.
Interpolation may be necessary for zone-based variables, and the specifics of that process can be set through the IZoneInterpolate interface |
| CIZoneInterpolate | Interface for accessing the zone interpolation class |
| CIZoneThing | This is the interface for ZoneThing, a class that holds extra data not in the fortran arrays. This will be stored in a container and the ID will be stored in offset $KZCPP in the fortran zone linked list. This inherits from Thing so we can use CellSpace |
| ►Nblocksel | |
| CIModuleBlockSEL | |
| ►Nbody | |
| CIBody | Interface for the global list of all geomtric data sets IBodySet |
| CIBodyBlock | Interface to provide acces to BodyBlock |
| CIBodyEdge | |
| CIBodyFace | |
| CIBodyPoint | |
| CIBodySet | A container for a single "set" of body-block elements. A body-block set is a named collection of body-block elements (points, edges, polygons, blocks) as an organization layer |
| CIModuleBody | |
| ►Nccfd | Ccfd namespace |
| CIBallFluid | |
| CIBodyFluidContainer | |
| CICcfdElement | |
| CICcfdHex | |
| CICcfdTet | |
| CIClumpCCFD | |
| CIElementContainer | |
| CIElementFluidContainer | |
| CIModuleBallFluid | |
| CIModuleCCFD | Interface for the PFC ccfd module |
| CIModuleClumpCCFD | |
| CIPebbleCCFD | |
| ►Ncmodelsxd | |
| CContactModel | Contact model implementation |
| CContactModelFluid | |
| CContactModelFluidState | |
| CContactModelMechanical | Mechanical contact model implementation |
| CContactModelMechanicalState | The ContactModelMechnicalState class holds necessary information to communicate back and forth between the code (e.g., PFC) and the contact model. It is derived from ContactModelState, and adds necessary information for mechanical contact models. contactmodel |
| CContactModelState | Holds necessary information to communicate back and forth between the code (e.g., PFC) and the contact model |
| CContactModelThermal | |
| CContactModelThermalState | |
| ►Ndfn | |
| CIDFNCluster | |
| CIDFNTemplate | |
| CIFracNetwork | |
| CIFracture | |
| CIIntersect | |
| CIIntersectionSet | |
| CIModuleDFN | |
| CIRangeElementDFNGen | Interface to a RangeElement of dfns, where you want objects within a certain distance to fractures in sets of dfns.
|
| CIVertexDFN | |
| ►Nextruder | |
| CIExtrudeBlock | Interface for IExtrudeEdge objects |
| CIExtrudeEdge | Interface for IExtrudeEdge objects |
| CIExtrudePath | Provides interface to IExtrudePath. Contains containers for points, edges and blocks objects |
| CIExtrudePoint | Interface for IExtrudePoint objects |
| CIExtrudeRegion | Interface for IExtrudeEdge objects |
| CIExtrudeSet | Provides interface to IExtrudeSet. Contains containers for points, edges and blocks objects |
| CIExtrudeSetList | Provides interface to IExtrudeSetList, an IContainer of IExtrudeSet objects |
| ►Nfish | |
| CIDebug | |
| CIGlobalRuntime | |
| CIInput | This class provides FISH with input data |
| CIMain | |
| CIOutput | This class provides FISH with output data |
| CIParameter | |
| CISymbol | |
| CLibraryData | |
| CParameterValue | |
| ►Nfmt | |
| Cformatter< IVariant > | |
| Cformatter< QString > | |
| Cformatter< QVariant > | |
| Cformatter< Vector2< T > > | |
| Cformatter< Vector3< T > > | |
| ►Nitasca | Namespace Itasca |
| Cconditional_container | A container, which either stores its value as a value or a pointer depending on the condition |
| Cconditional_container< false, T > | |
| Cconditional_container< true, T > | |
| CICIterator | Const iterator for an IContainer |
| ►CIContainer | Interface for containers of IThings |
| CIOpaqueIterator | Interface class for iterating through the container that has a null implementation |
| CIDeleteNotice | |
| CIDXFData | Handle geometric data generated by a IDXFReader |
| CIDXFReader | DXF Reader interface class |
| CIEnergyMap | Interface to EnergyMap class |
| CIGeometryImportData | |
| CIGeomImportExport | |
| CIGroup | Interface to a group object |
| CIGroupID | |
| CIGroupList | Group container class |
| CIGUIInput | The interface to graphics user interface input functionality |
| CIIdent | Central class for information identifying the particular program using the kernel library |
| ►CIInputRecord | The input record maintains a list of all commands used in the creation of the model |
| CFileData | |
| CFileDataHash | |
| CIIterator | Iterator for an IContainer |
| ►CIKernel | This Interface provides an entry point for command processing |
| CResultsDesc | |
| CIKernelInput | Interface describing ALL input support the kernel needs to receive from whatever interface is driving it |
| CIKernelOutput | Interface describing ALL output support the kernel needs to send information to whatever interface is driving it |
| ►CIModelList | |
| CModelInfo | |
| CModelQueryInfo | |
| CPropInfo | |
| ►CIMultiContainer | |
| CIMultiCallInfo | |
| CINoticeManager | Interface to the notification system |
| CInputContext | |
| CInputLine | Provides a interface for getting text |
| CIParentToChildContainer | Provides a class to use as the parent to a child container, or the main container of all of the children |
| ►CIParse | Interface to the main command processing class |
| CIMark | Opaque position indicator class. Do not attempt to use directly for anything |
| CIPollster | Polling interface - kernel should call periodically during longs tasks to give the interface a chance to respond to user commands |
| CIProgram | The main program access point |
| CIRandom | Interface to the random number generator |
| CISettings | Interface for accessing kernel settings |
| CISlot | Interface to a slot object |
| CISlotID | |
| CITable | Interface to a particular table of values |
| CITableList | Interface to the global list of all tables |
| CITextInput | |
| CITextOutput | Provides a interface for simple writing of text |
| ►CIThing | Base class for items that will be stored in containers |
| CBreakLock | |
| CHandle | |
| CLock | |
| CLockIf | |
| CMat | |
| CNegMatExcept | |
| Ctype_selector | Class used to select between two types based on a given condition |
| Ctype_selector< false, if_true, if_false > | |
| Ctype_selector< true, if_true, if_false > | |
| ►Nitascaxd | Itasca Library standard namespace, specific to 2D or 3D |
| CCLinkType | Same as LynkType, but with a constant pointer object |
| CIAllContactContainer | |
| CIBody | |
| CIBodyContainer | |
| CIBodyFluid | |
| CIBodyMechanical | |
| CIBodyMechanicalContainer | |
| CIBodyThermal | |
| CICellSpace | Interface to a "refining" cell space |
| CICommandModule | |
| CIContact | Contact class |
| CIContactFluid | |
| CIContactMechanical | ContactMechanical class |
| CIContactModelList | |
| CIContactModule | |
| CIContactThermal | ContactThermal class |
| CIContainerActiveContact | |
| CIContainerAllActiveContact | |
| CIContainerContact | Contact container class |
| CIData | |
| CIDomain | |
| CIExtension | Interface class for acessing extension stored in the base class of other things |
| CIFactorOfSafety | |
| CIFetchProperty | |
| CIFishCallList | |
| CIFishPlot | This interface exposes a plot data interface (IGeneralPlot) to FISH |
| CIFragment | |
| CIFragmentLogic | |
| CIFragmentModule | |
| CIGeneralPlot | This class allows user to draw basic geometric plots using FISH functions |
| CIGeomEdge | Interface for a user-defined geometric edge, defined as the line between two IGeomPoint objects |
| CIGeometry | Interface for the global list of all geomtric data sets IGeomSet |
| CIGeomPoint | Interface for a user-defined geometric point |
| CIGeomPoly | A class representing a single closed polygon made up of a list of edges |
| CIGeomSet | A container for a single "set" of geometric elements. A geometric set is a named collection of geometry elements (points, edges, polygons) as an organization layer |
| CIGlobals | Interface to modele global settings |
| CIHalfEdge | Interface for an edge used in the faceted wall logic. This is the interface for an edge used in the faceted wall logic. An edge is a line segment that starts at the vertex returned by getOrigin() and terminates at the vertex returned by getEnd() |
| CIHalfFacet | Interface for a facet used in the faceted wall logic. This is the interface for a triangular facet as used in the faceted wall logic. A facet consists of three vertices and three edges and the next facet in the local list (for a single faceted wall) can be obtained via the getNextIHalfFacet() method. The centroid is taken to be the average location of the facet vertices. Facets, at some level, are used as Pieces and/or PieceMechanical objects and, as such, must return a pointer |
| CIHalfVertex | Interface for a vertex used in the faceted wall logic. This is the interface for a vertex used in the faceted wall logic. A vertex is simply a point in space that can have a linear velocity. When a vertex has a linear velocity then the associated wall translational and angular velocities are set to 0. The user is responsible for ensuring that the wall remains orientable and manifold if the positions or velocities are set through this interface |
| CIHistory | Interface to a particular history being taken by the history logic |
| CIHistoryList | Interface to the list of all IHistories being taken by the history logic |
| CIInputItem | |
| ►CIKernelBase | |
| CSkip | |
| CILabel | Interface to a single label |
| CILabelList | Interface to the list of all labels in the system |
| CIMaxwellDamp | Interface to maxwell damping |
| CIParticleTrace | Interface to a particular particle trace being taken by the particle trace logic |
| CIParticleTraceList | Interface to the list of all IParticleTraces being taken by the particle trace logic |
| CIPiece | |
| CIPieceContainer | |
| CIPieceExtension | |
| CIPieceFluid | |
| CIPieceMechanical | |
| CIPieceMechanicalData | |
| CIPieceThermal | |
| CIPlane | Interface for the definition of a Plane in 3D space |
| CIProcess | |
| CIProcessList | |
| CIRange | Interface to a filter, used as the main method for filtering objects |
| CIRangeElement | Interface to a filter element, which is a member of a IRange. |
| CIRangeElementContact | Interface to a RangeElement of contacts specifying activity, type, model name, etc |
| CIRangeElementExtra | This part of a filter element interface describes which extra index is being referred to |
| CIRangeElementFish | Interface for providing an IRangeElement extension for a RangElementFish |
| CIRangeElementGeometryDistance | Interface to a RangeElement of a geometry set, where you want objects within a certain distance to this geometry set |
| CIRangeElementGeometrySpace | Interface to a RangeElement of a geometry set, where you want objects withion a certain space to this geometry sets (space ranger) |
| CIRangeElementGroup | Interface to a group filter element, used to filter objects by group assignment |
| CIRangeElementIdentifierList | Interface to to a Range Element that matches string to a list of stored strings |
| CIRangeElementName | Interface to a RangeElement exposing the IThing getName method |
| CIRangeElementNamed | Interface to a Range Element that is actually a named filter |
| CIRangeElementNameList | Interface to to a Range Element that matches string to a list of stored strings |
| CIRangeElementOrientation | |
| CIRangeElementPlane | Interface to a RangeElement of a plane in space, where you want objects above, below, or within a certain distance of the filter |
| CIRangeElementPolygonBased | Interface for accessing informations in the three drawable "interactive" filter elements in kernel/src/rangeelementinteractive.h (polygon,rectangle,ellipse) |
| CIRangeElementPosition | A filter element specified as a geometric region inside a capped cylinder, defined by a segment [begin-end] of radius Rad2 |
| CIRangeElementReal | Base for a filter that can be represented by a real number filter |
| CIRangeElementRegistry | Interface to a access the list of filter elements types registered with the engine |
| CIRangeElementSet | Interface to a RangeElement of a general set. A IThing has getIsSet and getSet methods to return the appropriate information |
| CIRangeElementSphere | A filter element described as a sphere in space |
| CIRangeElementSurface | Interface to a filter element that allows user to filter based on connection to a "surface" of the zones |
| CIRangeElementUIntPtr | Interface to to a Range Element that selects integers between two values |
| CIRangeElementUIntPtrList | Interface to to a Range Element that matches an integer to a list of stored integers |
| CIRangeList | Interface to the global list of all named filters |
| CIRayleighDamp | Interface to hysteretic damping |
| CIRigidBodyMechanical | |
| CISolveData | Interface for accessing solve command limits |
| CISphere | Interface for the definition of a Sphere |
| CIUDPos | Interface to the position in space of user-defined data that requires it |
| CIUDScalar | Interface to user-defined scalar data |
| CIUDScalarList | Interface for the list of all IUDScalar (user defined tensor) |
| CIUDTensor | Interface to user-defined tensor data |
| CIUDTensorList | Interface for the list of all IUDTensor (user defined tensor) |
| CIUDType | Interface to data values of different types associated with position in space, as user-defined data |
| CIUDTypeList | Interface to a container of user-define data value types |
| CIUDVector | Interface to user-defined vector data Implemented as an IUDType<DVect> |
| CIUDVectorList | Interface for the list of all IUDVector (user defined tensor) |
| CLinkType | Interface for LinkType<> objects, POD that contain both the pointer to the next object and an index for reference within the next object. A LinkType<> object is used to simplify linked-lists that need to refer both to the destination object and to a reference index within that destination object. The classic example is a list of all Zones connected to a GridPoint, each connection on the list needs to know the index of the GridPoint in the Zone following |
| ►Njmodels | The Joint Constitutive Model interface library |
| CJointModel | The base class for joint constitutive model plug-ins |
| CState | The structure used to pass information to the joint constitutive model |
| ►Nmodels | The Constitutive Model interface library |
| CConstitutiveModel | The base class for constitutive model plug-ins |
| CIGenericTet | Generic base class for the tetra interface made available to the constitutive model system |
| CIGenericZone | Generic base class for the zone interface made available to the constitutive model system |
| CPropertyBlock | The class provides reference count for model properties |
| CSharedPropertyBlock | This class allows zones to share model properties minimizing memery usage. Models currently using this class are: elastic, mohr, subi |
| CState | The structure used to pass information to the constitutive model |
| ►Nmodule | |
| ►CIGenericModelList | |
| CModelInfo | |
| CModelQueryInfo | |
| CPropInfo | |
| ►Npfc | PFC namespace |
| CIBall | Interface for a ball |
| CIBallMechanical | |
| CIBrick | |
| CIClump | Interface for a clump. This is the interface for a clump. A clump is a collection of pebbles that define the clump surface (see IPebble for more information). This interface provides basic functionality for accessing the Body Attributes and Piece properties associated with a clump |
| CIClumpTemplate | Interface for a clump template. This is the interface for a clump template. A clump template is composed of a clump, a surface description, and a reference orientation |
| CIContactBallBall | |
| CIContactBallFWallFacet | |
| CIContactBallPebble | |
| CIContactPebbleFWallFacet | |
| CIContactPebblePebble | |
| CIContactWallWall | |
| CIFWall | Interface for a faceted wall |
| CIGhostBall | |
| CIGhostPebble | |
| CIHalfFacetParent | |
| CIHalfVertexParent | |
| CIInlet | |
| CIMeasure | |
| CIModuleBall | Interface for the Ball module. This is the interface for the Ball module |
| CIModuleBallMechanical | |
| CIModuleBrick | |
| CIModuleClump | Interface for the Clump module. This is the interface for the Clump module |
| CIModuleContactBallClump | |
| CIModuleContactBallWall | |
| CIModuleContactClumpWall | |
| CIModuleMeasure | |
| CIModuleWall | Interface for the wall module |
| CIPebble | |
| CIPFCModule | Interface for the PFC module |
| CITriPoly | Interface for a TriPoly |
| CIWall | Interface for a generic wall. This is the interface for a generic wall. Specific wall types must derive from this. A wall is meant to be some geometric object with which other model components (balls and clumps) can interact but walls do not react. Thus they act to provide boundary conditions. This interface provides basic functionality for accessing the Body and Pieces associated with a wall. The properties that can be accessed through this interface are the position, rotation point, velocity, angular velocity, displacement, angular displacement, force, and moment. The meaning of the position is implementation dependent. All of these properties can be set with the exception of the force and moment |
| ►Npfcrblock | |
| CIContactBallRBlock | |
| CIContactPebbleRBlock | |
| CIContactPFCRBlockModule | |
| CIContactRBlockFWallFacet | |
| ►Npfcsel | |
| CIModulePFCSEL | |
| ►Npfcthermal | |
| CIBallFluid | |
| CIBallThermal | |
| CIClumpThermal | |
| CIContactFluidBallBall | |
| CIContactFluidBallFWallFacet | |
| CIContactThermalBallBall | |
| CIContactThermalBallFWallFacet | |
| CIContactThermalBallPebble | |
| CIContactThermalPebbleFWallFacet | |
| CIContactThermalPebblePebble | |
| CIFWallFacetFluid | |
| CIFWallFacetThermal | |
| CIFWallFluid | |
| CIFWallThermal | |
| CIModuleBallThermal | |
| CIModuleClumpThermal | |
| CIModuleContactFluidBallFWallFacet | |
| CIModuleContactThermalBallFWallFacet | |
| CIModuleContactThermalBallPebble | |
| CIModuleContactThermalPebbleFWallFacet | |
| CIModuleFWallFluid | |
| CIModuleFWallThermal | |
| CIModulePFCFluid | |
| CIPebbleThermal | |
| CIPFCThermalModule | |
| ►Npython | PYTHON namespace |
| CICCFDPython | Interface for the PFC module |
| CIModuleBlockPython | |
| CIModuleDFNPython | |
| CIModuleSELPython | |
| CIModuleZonePython | |
| CIPFCPythonModule | Interface for the PFC module |
| CIPFCThermalPython | Interface for the PFC module |
| CIPythonModule | Interface for the PYTHON module |
| CIRBlockPythonModule | Interface for the RBlock module |
| ►Nrblock | |
| CIContactRBlockRBlock | |
| CIGhostRBlock | |
| CIRBlock | |
| CIRBlockModule | |
| CIRBlockTemplate | |
| ►Nrblocksel | |
| CIModuleRBlockSEL | |
| ►Nrblockthermal | RBLOCKTHERMAL namespace |
| CIContactThermalBallRBlock | |
| CIContactThermalPebbleRBlock | |
| CIContactThermalRBlockFWallFacet | |
| CIContactThermalRBlockRBlock | |
| CIRBlockThermal | |
| CIRBlockThermalModule | Interface for the RBlock thermal module |
| ►Nsel | |
| CIDynSELNode | |
| CIModuleSEL | |
| CIRangeElementSELType | Interface to a filter element that allows user to filter based on a SEL type |
| CISEL | Interface to the structural elements base class |
| CISELBeam | Interface to beam structural elements |
| CISELCable | Interface to cable structural elements |
| CISELDowel | Interface to dowel structural elements |
| CISELGeogrid | Interface to geogrid structural elements |
| CISELHybrid | Interface to hybrid structural elements |
| CISELLiner | Interface to liner structural elements |
| CISELLiner2d | Interface to 2d liner structural elements |
| CISELLink | Interface to provide access to structural element links |
| CISELLinkList | Interface to the global list of all structural elements links |
| CISELLinkModel | |
| ►CISELList | Interface to the global list of all structural elements |
| CSELInfo | |
| CISELNode | Interface to provide access to structural element nodes |
| CISELNodeList | Interface to the global list of all structural elements nodes |
| CISELPile | Interface to pile structural elements |
| CISELShell | Interface to shell structural elements |
| ►Nstd | |
| Chash< IString > | |
| Chash< itasca::IThing::Handle > | |
| Chash< zone::FaceID > | |
| Ctuple_element< N, Vector2< T > > | |
| Ctuple_element< N, Vector3< T > > | |
| Ctuple_size< Vector2< T > > | We want structured binding support for vector types! |
| Ctuple_size< Vector3< T > > | |
| ►Nwallsel | |
| CIWallSelModule | |
| ►Nzone | |
| CFaceID | |
| CIApply | |
| CIApplyItem | |
| CIApplyItemZone | |
| CIApplyList | |
| CIAttachList | Interface for accessing the global list of attachments, IAttachPoint |
| CIAttachPoint | Interface to a attachment object |
| CIBodyLogic | |
| CICParticle | A particle being tracked |
| CICParticleList | The list of all particles being tracked |
| CICreepModule | Interface to the Creep Module, , see IModuleExtension |
| CICTrackPt | |
| CIDynamicModule | Interface to the Dynamic Module, see IModuleExtension |
| CIDynNode | Interface to access dynamic node data |
| CIFace | Interface to zone faces |
| CIFaceWeight | Interface to face weight, used to define the location of a gridpoint in a given face |
| CIFetchFluidProperty | |
| CIFetchThermalProperty | |
| CIFluidGp | Interface to access fluid gridpoint data |
| CIFluidModule | Interface to the Fluid Module |
| CIFluidPerm | Interface to fluid permeability model |
| CIFluidSat | Interface to fluid permeability model |
| CIFluidZone | Interface to access fluid zone data |
| CIGp | Interface to provide access to a gridpoint |
| CIGpData | Interface that allows access to gridpoint scalar data in a generic way |
| CIGpList | Interface to the global list of all grid points |
| CIHysDamp | Interface to hysteretic damping |
| CIIntElem | Class provides access to the an interface element |
| CIInterface | Class provides access to the an interface |
| CIInterfaceList | Class provides access to the global list of all IIinterface objects in the model |
| CIIntModel | Interface provides access to the constitutive model of a FLAC3D interface |
| CIIntNode | Class provides access to the an interface node |
| CIModuleZone | |
| CINode | Interface to access node data |
| CIRangeElementModel | Interface to a filter element that allows user to filter based on a zone model |
| CIRangeElementOrientation | Interface to a filter element that allows user to filter based on the orientation of zone faces |
| CIRangeElementState | Interface to a filter element that allows user to filter based on a zone state |
| CIRangeElementVolume | Interface to a filter element that allows user to filter based on a volume |
| CISurface | Interface to provide access to surfaces, see command GEN SURFACE |
| CISurfaceList | Interface to the global list of all surfaces, see command GEN SURFACE |
| CITet | Interface to one of the tetrahedra used to implement mixed-discretization in a zone |
| CIThermAnaSource | Interface to the thermal analytical source |
| CIThermAnaSourceList | Interface to the global list of all thermal analytical sources |
| CIThermGp | Interface to access gridpoint thermal data |
| CIThermModule | Interface to the thermal module |
| CIThermZone | Interface to access zone thermal data |
| CIWaterTable | Interface for accessing water table data |
| ►CIZone | Interface to provide access to a zone |
| CFaceCheckInput | |
| CFaceCheckOutput | |
| CIFacePair | |
| CIZoneData | Access to zone scalar data |
| CIZoneFieldData | Interface for accessing the zone field data class |
| CIZoneGlobals | Interface to access FLAC3D data, see SET and CONFIG commands |
| CIZoneInterpolate | Interface for accessing the zone interpolation class |
| ►CIZoneList | Interface for accessing the global list of zones, IZoneList |
| CFaceGroupCallbackData | |
| CFaceSelectCallbackData | |
| ►Nzonesel | |
| CIModuleZoneSEL | |
| CAVector | An AVector2 in 2D, an AVector3 in 3D |
| CAVector2 | 2D Angular vector class |
| CAVector3 | 3D Angular vector class |
| CAxes2D | Class for specifying a particular 2D cartesian axes system, and converting to and from it |
| CAxes3D | Class for specifying a particular 3D cartesian axes system, and converting to and from it |
| CBuffer | |
| CCallback0 | |
| CCallback0Method | |
| CCallback0Static | |
| CCallback1 | |
| CCallback1Method | |
| CCallback1Static | |
| CCallback2 | |
| CCallback2Method | |
| CCallback2Static | |
| CCallback3 | |
| CCallback3Method | |
| CCallback3Static | |
| CCallback4 | |
| CCallback4Method | |
| CCallback4Static | |
| CCAxes2D | Class for specifying a particular 2D cartesian axes system, and converting to and from it |
| CCAxes3D | Class for specifying a particular 3D cartesian axes system, and converting to and from it |
| CConditionalLock | |
| CCube | A Class representing a cartesian extent in 3D |
| CDMatrix | DMatrix is a Matrix that defaults to type double.. |
| CDSymMatrix | DSymMatrix is a SymMatrix that defaults to type double.. |
| CDVMatrix | DVMatrix is a double version of VMatrix |
| CException | Base exception class for all Itasca code |
| Cexpected | |
| CExtent | A Extent2<T> in 2D, and a Extent3<T> in 2D |
| CExtent2 | 2D cartesian region in space |
| CExtent3 | A Class representing a cartesian extent in 3D |
| CFArray | An array class that attempts to minimize unnecessary heap access |
| CFArray< T, 0 > | |
| CFishExample | Example implementation of the IFishLibrary interface |
| CFlatArray | |
| CFlatArrayVec | |
| CHexahedron | |
| ►CIHash | |
| Cconst_iterator | |
| Citerator | |
| CIList | |
| ►CIMap | |
| Cconst_iterator | |
| Citerator | |
| ►CIMultiHash | |
| Cconst_iterator | |
| Citerator | |
| ►CIMultiMap | |
| Cconst_iterator | |
| Citerator | |
| CIMutexLocker | An automatic QMutex lock/unlock helper class |
| CinnerLoopMS | |
| CinnerLoopMS< T, SX, SY, I, J, 1 > | |
| CInterruptException | Exception thrown when interruption occurs, e.g. user press ESC key |
| CIQueue | |
| CISet | |
| CIString | |
| CIStringList | |
| CItascaTextStream | |
| CIVariant | |
| CIVector | |
| Climits | Debug checked shorthand for std::numeric_limits<T>:: |
| Cloop2MultiplyMS | |
| Cloop2MultiplyMS< T, SX, SY, I, 1 > | |
| CloopMultiplyMS | |
| CloopMultiplyMS< T, SX, SY, 1 > | |
| CMatrix | A template-based matrix class, size fixed at compile time. Defaults to symmetric sized matrix |
| CMatrix< T, SX, 1 > | A specialization of the Matrix class for the case when SY=1 |
| COrientation2 | Class for storing an "orientation", or a direction in 2D or 3D space |
| COrientation3 | Class for storing an "orientation", or a direction in 2D or 3D space |
| CQList | |
| CQStringCIEqual2 | |
| CQStringCIHash2 | |
| CQStringCILess2 | |
| CQStringLocalLess2 | |
| CQuat2 | 2D quaternion-like utility class. In this case only the angle (in radians) is stored as opposed to the complex number. Multiplication of quaternions is supposed to result in a combined rotation which, in 2D, is the addition of the angles. This is for consitency with the Quat3 class |
| CQuat3 | 3D quaternion utility class |
| CQuitException | Exception thrown when processing is done |
| ►CRandom | |
| CInfo | |
| CReverseLock | |
| CReverseSharedLock | |
| CSpinLock | |
| CStateInfoGroup | |
| CStateInfoValues | |
| CStringCIEqual | |
| CStringCIHash | |
| CStringCILess | |
| CStringList | |
| CSymMatrix | A template-based symmetric matrix class, size fixed at compile time. This primitive template-based matrix class should be used where the matrix size is fixed at compile time |
| CSymTensor | A symmetric 2nd order tensor |
| CSymTensorInfo | SymTensor eigenvalue and direction helper class |
| Cunexpect_t | |
| Cunexpected | |
| ►CVariant | A simpler (and slightly faster) version of a QVariant, added for interfaces that do not use Qt |
| CVUserType | This is a helper class, designed to make it possible to allow user-defined types to be encoded in a Variant.
|
| CVUserType< void * > | Template specialization for void pointers; this should probably never be used, except to determine the size of VUserType for type_selector |
| CVector | A Vector2 in 2D, a Vector3 in 3D |
| CVector2 | 2D vector utility class |
| CVector3 | 3D vector utility class |
| CVersion | |
| CVMatrix | A 1-Dimensional version of Matrix, to represent a vector |
