Itasca C++ Interface
Loading...
Searching...
No Matches
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123]
 CAVector2< T >2D Angular vector class
 CAxes2DClass for specifying a particular 2D cartesian axes system, and converting to and from it
 CAxes3DClass for specifying a particular 3D cartesian axes system, and converting to and from it
 CCallback0< R >
 CCallback1< R, Arg1 >
 CCallback2< R, Arg1, Arg2 >
 CCallback3< R, Arg1, Arg2, Arg3 >
 CCallback4< R, Arg1, Arg2, Arg3, Arg4 >
 CCAxes2DClass for specifying a particular 2D cartesian axes system, and converting to and from it
 CCAxes3DClass for specifying a particular 3D cartesian axes system, and converting to and from it
 Citascaxd::CLinkType< T >Same as LynkType, but with a constant pointer object
 Citasca::conditional_container< false, T >
 Citasca::conditional_container< true, T >
 CConditionalLock< T >
 CConditionalLock< LockType >
 Cshared::Connector
 Cbase::const_iterator
 Cmodels::ConstitutiveModelThe base class for constitutive model plug-ins
 Ccmodelsxd::ContactModelStateHolds necessary information to communicate back and forth between the code (e.g., PFC) and the contact model
 CCube< T >A Class representing a cartesian extent in 3D
 Cstd::exception
 Cexpected< T, E >
 CExtent2< T >2D cartesian region in space
 CExtent3< T >A Class representing a cartesian extent in 3D
 Czone::IZone::FaceCheckInput
 Czone::IZone::FaceCheckOutput
 Czone::IZoneList::FaceGroupCallbackData
 Czone::FaceID
 Czone::IZoneList::FaceSelectCallbackData
 CFArray< T, S >An array class that attempts to minimize unnecessary heap access
 CFArray< DVect >
 CFArray< int, 5 >
 CFArray< TType, 3 >
 Citasca::IInputRecord::FileData
 Citasca::IInputRecord::FileDataHash
 CFlatArray< T >
 Cfmt::formatter
 Citasca::IThing::Handle
 Cstd::hash< IString >
 Cstd::hash< itasca::IThing::Handle >
 Cstd::hash< zone::FaceID >
 CHexahedron
 Citascaxd::IAllContactContainer
 Czone::IApply
 Czone::IApplyItem
 Czone::IApplyItemZone
 Czone::IApplyList
 Czone::IAttachListInterface for accessing the global list of attachments, IAttachPoint
 Czone::IAttachPointInterface to a attachment object
 Cpfc::IBallInterface for a ball
 Cccfd::IBallFluid
 Cpfcthermal::IBallFluid
 Cpfc::IBallMechanical
 Cpfcthermal::IBallThermal
 Cblock::IBeamArrayThis interface provides access to beam thing array
 Cblock::IBeamContactThis interface provides access to beam contact data
 Cblock::IBeamThing
 Cblock::IBFaceArrayContainer to store FaceThings (original block faces) ID of FaceThing is stored in offset $KFCPP in Fortran block linked list
 Cblock::IBlockArrayContainer to store blockThings. ID of BlockThing is stored in offset $KBID in Fortran block linked list
 Cblock::IBlockThingThis 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
 Cbody::IBodyInterface for the global list of all geomtric data sets IBodySet
 Citascaxd::IBody
 Cbody::IBodyBlockInterface to provide acces to BodyBlock
 Citascaxd::IBodyContainer
 Cbody::IBodyEdge
 Cbody::IBodyFace
 Citascaxd::IBodyFluid
 Cccfd::IBodyFluidContainer
 Czone::IBodyLogic
 Citascaxd::IBodyMechanical
 Citascaxd::IBodyMechanicalContainer
 Cbody::IBodyPoint
 Cbody::IBodySetA 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
 Citascaxd::IBodyThermal
 Cpfc::IBrick
 Cblock::ICableArrayThis interface provides access to cable thing array
 Cblock::ICableThing
 Cccfd::ICcfdElement
 Cccfd::ICcfdHex
 Cpython::ICCFDPythonInterface for the PFC module
 Cccfd::ICcfdTet
 Citascaxd::ICellSpaceInterface to a "refining" cell space
 Citasca::ICIterator< T >Const iterator for an IContainer
 Cpfc::IClumpInterface 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
 Cccfd::IClumpCCFD
 Cpfc::IClumpTemplateInterface 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
 Cpfcthermal::IClumpThermal
 Citascaxd::ICommandModule
 Cblock::IConfigureThis interface provides linked list offsets to access to configuration settings
 Citascaxd::IContactContact class
 Cblock::IContactArrayThis interface provides access to contact thing array
 Cpfc::IContactBallBall
 Cpfc::IContactBallFWallFacet
 Cpfc::IContactBallPebble
 Cpfcrblock::IContactBallRBlock
 Citascaxd::IContactFluid
 Cpfcthermal::IContactFluidBallBall
 Cpfcthermal::IContactFluidBallFWallFacet
 Citascaxd::IContactMechanicalContactMechanical class
 CIContactModel
 CIContactModelFluid
 Citascaxd::IContactModelList
 CIContactModelMechanical
 CIContactModelThermal
 Citascaxd::IContactModule
 Cpfc::IContactPebbleFWallFacet
 Cpfc::IContactPebblePebble
 Cpfcrblock::IContactPebbleRBlock
 Cpfcrblock::IContactPFCRBlockModule
 Cpfcrblock::IContactRBlockFWallFacet
 Crblock::IContactRBlockRBlock
 Citascaxd::IContactThermalContactThermal class
 Cpfcthermal::IContactThermalBallBall
 Cpfcthermal::IContactThermalBallFWallFacet
 Cpfcthermal::IContactThermalBallPebble
 Crblockthermal::IContactThermalBallRBlock
 Cpfcthermal::IContactThermalPebbleFWallFacet
 Cpfcthermal::IContactThermalPebblePebble
 Crblockthermal::IContactThermalPebbleRBlock
 Crblockthermal::IContactThermalRBlockFWallFacet
 Crblockthermal::IContactThermalRBlockRBlock
 Cblock::IContactThing
 Cpfc::IContactWallWall
 Citasca::IContainerInterface for containers of IThings
 Citascaxd::IContainerActiveContact
 Citascaxd::IContainerAllActiveContact
 Citascaxd::IContainerContactContact container class
 Czone::ICParticleA particle being tracked
 Czone::ICParticleListThe list of all particles being tracked
 Czone::ICreepModuleInterface to the Creep Module, , see IModuleExtension
 Czone::ICTrackPt
 Cfish::IDebug
 Citasca::IDeleteNotice
 Cdfn::IDFNCluster
 Cdfn::IDFNTemplate
 Citascaxd::IDomain
 Cblock::IDowelArrayThis interface provides access to dowel thing array
 Cblock::IDowelThing
 Citasca::IDXFDataHandle geometric data generated by a IDXFReader
 Citasca::IDXFReaderDXF Reader interface class
 Czone::IDynamicModuleInterface to the Dynamic Module, see IModuleExtension
 Czone::IDynNodeInterface to access dynamic node data
 Csel::IDynSELNode
 Cccfd::IElementContainer
 Cccfd::IElementFluidContainer
 Citasca::IEnergyMapInterface to EnergyMap class
 Citascaxd::IExtensionInterface class for acessing extension stored in the base class of other things
 Cextruder::IExtrudeBlockInterface for IExtrudeEdge objects
 Cextruder::IExtrudeEdgeInterface for IExtrudeEdge objects
 Cextruder::IExtrudePathProvides interface to IExtrudePath. Contains containers for points, edges and blocks objects
 Cextruder::IExtrudePointInterface for IExtrudePoint objects
 Cextruder::IExtrudeRegionInterface for IExtrudeEdge objects
 Cextruder::IExtrudeSetProvides interface to IExtrudeSet. Contains containers for points, edges and blocks objects
 Cextruder::IExtrudeSetListProvides interface to IExtrudeSetList, an IContainer of IExtrudeSet objects
 Czone::IFaceInterface to zone faces
 Cblock::IFaceArrayContainer to store FaceThings (zoned or triangulated block faces). ID of FaceThing is stored in offset $KFCPP in Fortran block linked list
 Cblock::IFaceBlockArrayContainer to store blockThings that are face blocks. ID of BlockThing is stored in offset $KBID in Fortran block linked list
 Cblock::IFaceDataThis 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
 Czone::IZone::IFacePair
 Cblock::IFaceThingThis 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
 Czone::IFaceWeightInterface to face weight, used to define the location of a gridpoint in a given face
 Citascaxd::IFactorOfSafety
 Cblock::IFEFaceArrayThis interface provides access to beam thing array
 Cblock::IFEFaceThingThis 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
 Cblock::IFElementArrayThis interface provides access to beam thing array
 Cblock::IFElementThingThis 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
 Czone::IFetchFluidProperty
 Citascaxd::IFetchProperty
 Czone::IFetchThermalProperty
 Citascaxd::IFishCallList
 CIFishLibrary
 Citascaxd::IFishPlotThis interface exposes a plot data interface (IGeneralPlot) to FISH
 Cblock::IFlowKnotArrayContainer to store FlowKnotThings
 Cblock::IFlowKnotThingThis 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
 Cblock::IFlowPlaneArrayContainer to store FlowPlaneThings
 Cblock::IFlowPlaneThing
 Cblock::IFlowPlaneVertexArrayContainer to store IFlowPlaneVertexThings
 Cblock::IFlowPlaneVertexThingThis 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
 Cblock::IFlowZoneArrayContainer to store IFlowZoneThings
 Cblock::IFlowZoneThing
 Czone::IFluidGpInterface to access fluid gridpoint data
 Czone::IFluidModuleInterface to the Fluid Module
 Czone::IFluidPermInterface to fluid permeability model
 Czone::IFluidSatInterface to fluid permeability model
 Czone::IFluidZoneInterface to access fluid zone data
 Cdfn::IFracNetwork
 Cdfn::IFracture
 Citascaxd::IFragment
 Citascaxd::IFragmentLogic
 Citascaxd::IFragmentModule
 Cpfc::IFWallInterface for a faceted wall
 Cpfcthermal::IFWallFacetFluid
 Cpfcthermal::IFWallFacetThermal
 Cpfcthermal::IFWallFluid
 Cpfcthermal::IFWallThermal
 Citascaxd::IGeneralPlotThis class allows user to draw basic geometric plots using FISH functions
 Cmodule::IGenericModelList
 Cmodels::IGenericTetGeneric base class for the tetra interface made available to the constitutive model system
 Cmodels::IGenericZoneGeneric base class for the zone interface made available to the constitutive model system
 Citascaxd::IGeomEdgeInterface for a user-defined geometric edge, defined as the line between two IGeomPoint objects
 Citascaxd::IGeometryInterface for the global list of all geomtric data sets IGeomSet
 Citasca::IGeometryImportData
 Citasca::IGeomImportExport
 Citascaxd::IGeomPointInterface for a user-defined geometric point
 Citascaxd::IGeomPolyA class representing a single closed polygon made up of a list of edges
 Citascaxd::IGeomSetA 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
 Cpfc::IGhostBall
 Cpfc::IGhostPebble
 Crblock::IGhostRBlock
 Cfish::IGlobalRuntime
 Citascaxd::IGlobalsInterface to modele global settings
 Czone::IGpInterface to provide access to a gridpoint
 Cblock::IGpDataThis 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
 Czone::IGpDataInterface that allows access to gridpoint scalar data in a generic way
 Czone::IGpListInterface to the global list of all grid points
 Citasca::IGroupInterface to a group object
 Citasca::IGroupListGroup container class
 Citasca::IGUIInputThe interface to graphics user interface input functionality
 Citascaxd::IHalfEdgeInterface 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()
 Citascaxd::IHalfFacetInterface 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
 Cpfc::IHalfFacetParent
 Citascaxd::IHalfVertexInterface 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
 Cpfc::IHalfVertexParent
 Citascaxd::IHistoryInterface to a particular history being taken by the history logic
 Citascaxd::IHistoryListInterface to the list of all IHistories being taken by the history logic
 Czone::IHysDampInterface to hysteretic damping
 Citasca::IIdentCentral class for information identifying the particular program using the kernel library
 Cpfc::IInlet
 Cfish::IInputThis class provides FISH with input data
 Citascaxd::IInputItem
 Citasca::IInputRecordThe input record maintains a list of all commands used in the creation of the model
 Czone::IIntElemClass provides access to the an interface element
 Czone::IInterfaceClass provides access to the an interface
 Czone::IInterfaceListClass provides access to the global list of all IIinterface objects in the model
 Cdfn::IIntersect
 Cdfn::IIntersectionSet
 Czone::IIntModelInterface provides access to the constitutive model of a FLAC3D interface
 Czone::IIntNodeClass provides access to the an interface node
 Cblock::IJointFaceArrayThis interface provides access to jointthing array
 Cblock::IJointFaceThing
 Citasca::IKernelThis Interface provides an entry point for command processing
 Citascaxd::IKernelBase
 Citasca::IKernelInputInterface describing ALL input support the kernel needs to receive from whatever interface is driving it
 Citasca::IKernelOutputInterface describing ALL output support the kernel needs to send information to whatever interface is driving it
 Citascaxd::ILabelInterface to a single label
 Citascaxd::ILabelListInterface to the list of all labels in the system
 Cblock::ILinerArrayThis interface provides access to liner thing array
 Cblock::ILinerThing
 Cfish::IMain
 Citasca::IParse::IMarkOpaque position indicator class. Do not attempt to use directly for anything
 Citascaxd::IMaxwellDampInterface to maxwell damping
 Cpfc::IMeasure
 Citasca::IModelList
 Cpfc::IModuleBallInterface for the Ball module. This is the interface for the Ball module
 Cccfd::IModuleBallFluid
 Cpfc::IModuleBallMechanical
 Cpfcthermal::IModuleBallThermal
 Cblock::IModuleBlock
 Cpython::IModuleBlockPython
 Cblocksel::IModuleBlockSEL
 Cbody::IModuleBody
 Cpfc::IModuleBrick
 Cccfd::IModuleCCFDInterface for the PFC ccfd module
 Cpfc::IModuleClumpInterface for the Clump module. This is the interface for the Clump module
 Cccfd::IModuleClumpCCFD
 Cpfcthermal::IModuleClumpThermal
 Cpfc::IModuleContactBallClump
 Cpfc::IModuleContactBallWall
 Cpfc::IModuleContactClumpWall
 Cpfcthermal::IModuleContactFluidBallFWallFacet
 Cpfcthermal::IModuleContactThermalBallFWallFacet
 Cpfcthermal::IModuleContactThermalBallPebble
 Cpfcthermal::IModuleContactThermalPebbleFWallFacet
 Cdfn::IModuleDFN
 Cpython::IModuleDFNPython
 Cpfcthermal::IModuleFWallFluid
 Cpfcthermal::IModuleFWallThermal
 Cpfc::IModuleMeasure
 Cpfcthermal::IModulePFCFluid
 Cpfcsel::IModulePFCSEL
 Crblocksel::IModuleRBlockSEL
 Csel::IModuleSEL
 Cpython::IModuleSELPython
 Cpfc::IModuleWallInterface for the wall module
 Czone::IModuleZone
 Cpython::IModuleZonePython
 Czonesel::IModuleZoneSEL
 Citasca::IMultiContainer::IMultiCallInfo
 Citasca::IMultiContainer
 CIMutexLockerAn automatic QMutex lock/unlock helper class
 CRandom::Info
 CinnerLoopMS< T, SX, SY, I, J, K >
 CinnerLoopMS< T, SX, SY, I, J, 1 >
 Czone::INodeInterface to access node data
 Citasca::INoticeManagerInterface to the notification system
 Citasca::InputContext
 Citasca::InputLineProvides a interface for getting text
 Cstd::integral_constant
 Citasca::IContainer::IOpaqueIteratorInterface class for iterating through the container that has a null implementation
 Cfish::IOutputThis class provides FISH with output data
 Cfish::IParameter
 Citasca::IParentToChildContainerProvides a class to use as the parent to a child container, or the main container of all of the children
 Citasca::IParseInterface to the main command processing class
 Citascaxd::IParticleTraceInterface to a particular particle trace being taken by the particle trace logic
 Citascaxd::IParticleTraceListInterface to the list of all IParticleTraces being taken by the particle trace logic
 Cccfd::IPebbleCCFD
 Cpfcthermal::IPebbleThermal
 Cpfc::IPFCModuleInterface for the PFC module
 Cpython::IPFCPythonModuleInterface for the PFC module
 Cpfcthermal::IPFCThermalModule
 Cpython::IPFCThermalPythonInterface for the PFC module
 Citascaxd::IPiece
 Citascaxd::IPieceContainer
 Citascaxd::IPieceExtension
 Citascaxd::IPieceFluid
 Citascaxd::IPieceMechanical
 Citascaxd::IPieceMechanicalData
 Citascaxd::IPieceThermal
 Citascaxd::IPlaneInterface for the definition of a Plane in 3D space
 Citasca::IPollsterPolling interface - kernel should call periodically during longs tasks to give the interface a chance to respond to user commands
 Citascaxd::IProcess
 Citascaxd::IProcessList
 Citasca::IProgramThe main program access point
 Cpython::IPythonModuleInterface for the PYTHON module
 Citasca::IRandomInterface to the random number generator
 Citascaxd::IRangeInterface to a filter, used as the main method for filtering objects
 Citascaxd::IRangeElementContactInterface to a RangeElement of contacts specifying activity, type, model name, etc
 Cdfn::IRangeElementDFNGenInterface to a RangeElement of dfns, where you want objects within a certain distance to fractures in sets of dfns.
 Citascaxd::IRangeElementExtraThis part of a filter element interface describes which extra index is being referred to
 Citascaxd::IRangeElementFishInterface for providing an IRangeElement extension for a RangElementFish
 Citascaxd::IRangeElementGeometryDistanceInterface to a RangeElement of a geometry set, where you want objects within a certain distance to this geometry set
 Citascaxd::IRangeElementGeometrySpaceInterface to a RangeElement of a geometry set, where you want objects withion a certain space to this geometry sets (space ranger)
 Cblock::IRangeElementGIntInterface to a group intersection filter element, used to filter objects by group intersection
 Citascaxd::IRangeElementGroupInterface to a group filter element, used to filter objects by group assignment
 Citascaxd::IRangeElementIdentifierListInterface to to a Range Element that matches string to a list of stored strings
 Czone::IRangeElementModelInterface to a filter element that allows user to filter based on a zone model
 Citascaxd::IRangeElementNameInterface to a RangeElement exposing the IThing getName method
 Citascaxd::IRangeElementNamedInterface to a Range Element that is actually a named filter
 Citascaxd::IRangeElementNameListInterface to to a Range Element that matches string to a list of stored strings
 Cblock::IRangeElementOrientationThis interface provides access to orientation filters
 Citascaxd::IRangeElementOrientation
 Czone::IRangeElementOrientationInterface to a filter element that allows user to filter based on the orientation of zone faces
 Citascaxd::IRangeElementPlaneInterface to a RangeElement of a plane in space, where you want objects above, below, or within a certain distance of the filter
 Citascaxd::IRangeElementPolygonBasedInterface for accessing informations in the three drawable "interactive" filter elements in kernel/src/rangeelementinteractive.h (polygon,rectangle,ellipse)
 Citascaxd::IRangeElementPositionA filter element specified as a geometric region inside a capped cylinder, defined by a segment [begin-end] of radius Rad2
 Citascaxd::IRangeElementRealBase for a filter that can be represented by a real number filter
 Citascaxd::IRangeElementRegistryInterface to a access the list of filter elements types registered with the engine
 Csel::IRangeElementSELTypeInterface to a filter element that allows user to filter based on a SEL type
 Citascaxd::IRangeElementSetInterface to a RangeElement of a general set. A IThing has getIsSet and getSet methods to return the appropriate information
 Citascaxd::IRangeElementSphereA filter element described as a sphere in space
 Cblock::IRangeElementStateInterface to a filter element that allows user to filter based on a zone state
 Czone::IRangeElementStateInterface to a filter element that allows user to filter based on a zone state
 Cblock::IRangeElementSurface
 Citascaxd::IRangeElementSurfaceInterface to a filter element that allows user to filter based on connection to a "surface" of the zones
 Cblock::IRangeElementTwoIntIRangeElement for RangeElementMaterialIntersection
 Citascaxd::IRangeElementUIntPtrInterface to to a Range Element that selects integers between two values
 Citascaxd::IRangeElementUIntPtrListInterface to to a Range Element that matches an integer to a list of stored integers
 Czone::IRangeElementVolumeInterface to a filter element that allows user to filter based on a volume
 Citascaxd::IRangeListInterface to the global list of all named filters
 Citascaxd::IRayleighDampInterface to hysteretic damping
 Crblock::IRBlock
 Crblock::IRBlockModule
 Cpython::IRBlockPythonModuleInterface for the RBlock module
 Crblock::IRBlockTemplate
 Crblockthermal::IRBlockThermal
 Crblockthermal::IRBlockThermalModuleInterface for the RBlock thermal module
 Cblock::IReinforcementArrayThis interface provides access to reinforcement thing array
 Cblock::IReinforcementThing
 Citascaxd::IRigidBodyMechanical
 Csel::ISELInterface to the structural elements base class
 Csel::ISELBeamInterface to beam structural elements
 Csel::ISELCableInterface to cable structural elements
 Csel::ISELDowelInterface to dowel structural elements
 Csel::ISELGeogridInterface to geogrid structural elements
 Csel::ISELHybridInterface to hybrid structural elements
 Csel::ISELLinerInterface to liner structural elements
 Csel::ISELLiner2dInterface to 2d liner structural elements
 Csel::ISELLinkInterface to provide access to structural element links
 Csel::ISELLinkListInterface to the global list of all structural elements links
 Csel::ISELLinkModel
 Csel::ISELListInterface to the global list of all structural elements
 Csel::ISELNodeInterface to provide access to structural element nodes
 Cblock::ISELNodeArrayContainer to store SELNodeThings. ID of SELNodeThing is stored in id offset of Fortran linked list (42 for beams and cables, 21 for liner nodes)
 Csel::ISELNodeListInterface to the global list of all structural elements nodes
 Cblock::ISELNodeThingThis 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
 Csel::ISELPileInterface to pile structural elements
 Cblock::ISelPropThis interface provides access to cable thing. The fortran offset for the SelProp ID is $ktypcpp in the Fortran sel property data array
 Cblock::ISelPropArrayThis interface provides access to SelProp array
 Csel::ISELShellInterface to shell structural elements
 Citasca::ISettingsInterface for accessing kernel settings
 Citasca::ISlotInterface to a slot object
 Citasca::ISlotID
 Citascaxd::ISolveDataInterface for accessing solve command limits
 Citascaxd::ISphereInterface for the definition of a Sphere
 Cblock::ISubcontactArrayContainer to store SubcontactThings. ID of SubcontactThing is stored in offset $KCXCPP in Fortran subcontac linked list
 Cblock::ISubcontactThingThis 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
 Czone::ISurfaceInterface to provide access to surfaces, see command GEN SURFACE
 Czone::ISurfaceListInterface to the global list of all surfaces, see command GEN SURFACE
 Cfish::ISymbol
 Citasca::ITableInterface to a particular table of values
 Citasca::ITableListInterface to the global list of all tables
 Cbase::iterator
 Citasca::ITextInput
 Citasca::ITextOutputProvides a interface for simple writing of text
 Czone::IThermAnaSourceInterface to the thermal analytical source
 Czone::IThermAnaSourceListInterface to the global list of all thermal analytical sources
 Czone::IThermGpInterface to access gridpoint thermal data
 Czone::IThermModuleInterface to the thermal module
 Czone::IThermZoneInterface to access zone thermal data
 Citasca::IThingBase class for items that will be stored in containers
 Cpfc::ITriPolyInterface for a TriPoly
 Cblock::IType3DEC
 Citascaxd::IUDPosInterface to the position in space of user-defined data that requires it
 Citascaxd::IUDType< T >Interface to data values of different types associated with position in space, as user-defined data
 Citascaxd::IUDType< double >
 Citascaxd::IUDType< DVect >
 Citascaxd::IUDType< SymTensor >
 Citascaxd::IUDTypeList< T >Interface to a container of user-define data value types
 Citascaxd::IUDTypeList< IUDScalar >
 Citascaxd::IUDTypeList< IUDTensor >
 Citascaxd::IUDTypeList< IUDVector >
 CIVariantBase
 Cblock::IVertexArrayContainer to store VertexThings. ID of VertexThing is stored in offset $KVCPP in Fortran vertex linked list
 Cdfn::IVertexDFN
 Cblock::IVertexThingThis 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
 Cpfc::IWallInterface 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
 Cwallsel::IWallSelModule
 Cblock::IWaterThis interface provides access to functions used to define a water surface
 Czone::IWaterTableInterface for accessing water table data
 Cblock::IZoneArrayContainer to store ZoneThings. ID of BlockThing is stored in offset $KZCPP in Fortran zone linked list
 Cblock::IZoneDataAccess 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
 Czone::IZoneDataAccess to zone scalar data
 Cblock::IZoneFieldDataInterface 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
 Czone::IZoneFieldDataInterface for accessing the zone field data class
 Czone::IZoneGlobalsInterface to access FLAC3D data, see SET and CONFIG commands
 Cblock::IZoneInterpolateInterface for accessing the zone interpolation class
 Czone::IZoneInterpolateInterface for accessing the zone interpolation class
 Czone::IZoneListInterface for accessing the global list of zones, IZoneList
 Cjmodels::JointModelThe base class for joint constitutive model plug-ins
 Cfish::LibraryData
 Citascaxd::LinkType< T >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
 CLocalLink
 Cstd::lock_guard
 Cloop2MultiplyMS< T, SX, SY, I, J >
 Cloop2MultiplyMS< T, SX, SY, I, 1 >
 CloopMultiplyMS< T, SX, SY, I >
 CloopMultiplyMS< T, SX, SY, 1 >
 Cstd::map
 Citasca::Mat
 CMatrix< T, SX, SY >A template-based matrix class, size fixed at compile time. Defaults to symmetric sized matrix
 CMatrix< double, S, 1 >
 CMatrix< double, SX, SX >
 CMatrix< T, S, 1 >
 CMatrix< T, SX, 1 >A specialization of the Matrix class for the case when SY=1
 CMatrix< T, SX, SY >
 Citasca::IModelList::ModelInfo
 Cmodule::IGenericModelList::ModelInfo
 Citasca::IModelList::ModelQueryInfo
 Cmodule::IGenericModelList::ModelQueryInfo
 Cstd::multimap
 Cstd::numeric_limits
 COrientation2Class for storing an "orientation", or a direction in 2D or 3D space
 COrientation3Class for storing an "orientation", or a direction in 2D or 3D space
 Cfish::ParameterValue
 CPropBase
 Cbase::PropDesc
 Cmodels::PropertyBlockThe class provides reference count for model properties
 Citasca::IModelList::PropInfo
 Cmodule::IGenericModelList::PropInfo
 CQList< T >
 CQStringCIEqual2
 CQStringCIHash2
 CQStringCILess2
 CQStringLocalLess2
 CQTextStream
 CQuat22D 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
 CQuat33D quaternion utility class
 Cstd::queue
 CRandom
 Citasca::IKernel::ResultsDesc
 CReverseLock< T >
 CReverseLock< LockType >
 CReverseSharedLock< T >
 Csel::ISELList::SELInfo
 Cstd::set
 Cmodels::SharedPropertyBlock< T >This class allows zones to share model properties minimizing memery usage. Models currently using this class are: elastic, mohr, subi
 Citascaxd::IKernelBase::Skip
 CSpinLock
 Cjmodels::StateThe structure used to pass information to the joint constitutive model
 Cmodels::StateThe structure used to pass information to the constitutive model
 Cstring
 CStringCIEqual
 CStringCIHash
 CStringCILess
 CSymMatrix< T, SX >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
 CSymMatrix< double, SX >
 CSymTensorA symmetric 2nd order tensor
 CSymTensorInfoSymTensor eigenvalue and direction helper class
 CThingID
 Cstd::tuple_element< N, Vector2< T > >
 Cstd::tuple_element< N, Vector3< T > >
 Citasca::type_selector< condition, if_true, if_false >Class used to select between two types based on a given condition
 Citasca::type_selector< condition, T, T * >
 Citasca::type_selector< false, if_true, if_false >
 Citasca::type_selector< true, if_true, if_false >
 Cunexpect_t
 Cunexpected< E >
 Cstd::unordered_map
 Cstd::unordered_multimap
 CVariantA simpler (and slightly faster) version of a QVariant, added for interfaces that do not use Qt
 Cstd::vector
 CVector2< T >2D vector utility class
 CVector3< T >3D vector utility class
 CVersion
 CVariant::VUserType< T >This is a helper class, designed to make it possible to allow user-defined types to be encoded in a Variant.
 CVariant::VUserType< void * >Template specialization for void pointers; this should probably never be used, except to determine the size of VUserType for type_selector
 CITensorData