|
Itasca C++ Interface
|
| CAVector2< T > | 2D 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 |
| ►CCallback0< R > | |
| ►CCallback1< R, Arg1 > | |
| ►CCallback2< R, Arg1, Arg2 > | |
| ►CCallback3< R, Arg1, Arg2, Arg3 > | |
| ►CCallback4< R, Arg1, Arg2, Arg3, Arg4 > | |
| 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 |
| 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::ConstitutiveModel | The base class for constitutive model plug-ins |
| ►Ccmodelsxd::ContactModelState | Holds necessary information to communicate back and forth between the code (e.g., PFC) and the contact model |
| ►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 > | |
| Citascaxd::IAllContactContainer | |
| Czone::IApply | |
| Czone::IApplyItem | |
| Czone::IApplyItemZone | |
| Czone::IApplyList | |
| Czone::IAttachList | Interface for accessing the global list of attachments, IAttachPoint |
| Czone::IAttachPoint | Interface to a attachment object |
| Cpfc::IBall | Interface for a ball |
| Cccfd::IBallFluid | |
| Cpfcthermal::IBallFluid | |
| Cpfc::IBallMechanical | |
| Cpfcthermal::IBallThermal | |
| Cblock::IBeamArray | This interface provides access to beam thing array |
| Cblock::IBeamContact | This interface provides access to beam contact data |
| Cblock::IBeamThing | |
| Cblock::IBFaceArray | Container to store FaceThings (original block faces) ID of FaceThing is stored in offset $KFCPP in Fortran block linked list |
| Cblock::IBlockArray | Container to store blockThings. ID of BlockThing is stored in offset $KBID in Fortran block linked list |
| Cblock::IBlockThing | 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 |
| Cbody::IBody | Interface for the global list of all geomtric data sets IBodySet |
| Citascaxd::IBody | |
| Cbody::IBodyBlock | Interface to provide acces to BodyBlock |
| Citascaxd::IBodyContainer | |
| Cbody::IBodyEdge | |
| Cbody::IBodyFace | |
| Citascaxd::IBodyFluid | |
| Cccfd::IBodyFluidContainer | |
| Czone::IBodyLogic | |
| Citascaxd::IBodyMechanical | |
| Citascaxd::IBodyMechanicalContainer | |
| Cbody::IBodyPoint | |
| Cbody::IBodySet | 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 |
| Citascaxd::IBodyThermal | |
| Cpfc::IBrick | |
| Cblock::ICableArray | This interface provides access to cable thing array |
| Cblock::ICableThing | |
| Cccfd::ICcfdElement | |
| Cccfd::ICcfdHex | |
| Cpython::ICCFDPython | Interface for the PFC module |
| Cccfd::ICcfdTet | |
| Citascaxd::ICellSpace | Interface to a "refining" cell space |
| ►Citasca::ICIterator< T > | Const iterator for an IContainer |
| Cpfc::IClump | 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 |
| Cccfd::IClumpCCFD | |
| Cpfc::IClumpTemplate | 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 |
| Cpfcthermal::IClumpThermal | |
| Citascaxd::ICommandModule | |
| Cblock::IConfigure | This interface provides linked list offsets to access to configuration settings |
| Citascaxd::IContact | Contact class |
| Cblock::IContactArray | This interface provides access to contact thing array |
| Cpfc::IContactBallBall | |
| Cpfc::IContactBallFWallFacet | |
| Cpfc::IContactBallPebble | |
| Cpfcrblock::IContactBallRBlock | |
| Citascaxd::IContactFluid | |
| Cpfcthermal::IContactFluidBallBall | |
| Cpfcthermal::IContactFluidBallFWallFacet | |
| Citascaxd::IContactMechanical | ContactMechanical class |
| ►CIContactModel | |
| ►CIContactModelFluid | |
| Citascaxd::IContactModelList | |
| ►CIContactModelMechanical | |
| ►CIContactModelThermal | |
| Citascaxd::IContactModule | |
| Cpfc::IContactPebbleFWallFacet | |
| Cpfc::IContactPebblePebble | |
| Cpfcrblock::IContactPebbleRBlock | |
| Cpfcrblock::IContactPFCRBlockModule | |
| Cpfcrblock::IContactRBlockFWallFacet | |
| Crblock::IContactRBlockRBlock | |
| Citascaxd::IContactThermal | ContactThermal class |
| Cpfcthermal::IContactThermalBallBall | |
| Cpfcthermal::IContactThermalBallFWallFacet | |
| Cpfcthermal::IContactThermalBallPebble | |
| Crblockthermal::IContactThermalBallRBlock | |
| Cpfcthermal::IContactThermalPebbleFWallFacet | |
| Cpfcthermal::IContactThermalPebblePebble | |
| Crblockthermal::IContactThermalPebbleRBlock | |
| Crblockthermal::IContactThermalRBlockFWallFacet | |
| Crblockthermal::IContactThermalRBlockRBlock | |
| Cblock::IContactThing | |
| Cpfc::IContactWallWall | |
| Citasca::IContainer | Interface for containers of IThings |
| Citascaxd::IContainerActiveContact | |
| Citascaxd::IContainerAllActiveContact | |
| Citascaxd::IContainerContact | Contact container class |
| Czone::ICParticle | A particle being tracked |
| Czone::ICParticleList | The list of all particles being tracked |
| Czone::ICreepModule | Interface to the Creep Module, , see IModuleExtension |
| Czone::ICTrackPt | |
| Cfish::IDebug | |
| Citasca::IDeleteNotice | |
| Cdfn::IDFNCluster | |
| Cdfn::IDFNTemplate | |
| Citascaxd::IDomain | |
| Cblock::IDowelArray | This interface provides access to dowel thing array |
| Cblock::IDowelThing | |
| Czone::IDynamicModule | Interface to the Dynamic Module, see IModuleExtension |
| Czone::IDynNode | Interface to access dynamic node data |
| Csel::IDynSELNode | |
| Czone::IDynZone | Interface to access dynamic zone data |
| Cccfd::IElementContainer | |
| Cccfd::IElementFluidContainer | |
| Citasca::IEnergyMap | Interface to EnergyMap class |
| Citascaxd::IExtension | Interface class for acessing extension stored in the base class of other things |
| Cextruder::IExtrudeBlock | Interface for IExtrudeEdge objects |
| Cextruder::IExtrudeEdge | Interface for IExtrudeEdge objects |
| Cextruder::IExtrudePath | Provides interface to IExtrudePath. Contains containers for points, edges and blocks objects |
| Cextruder::IExtrudePoint | Interface for IExtrudePoint objects |
| Cextruder::IExtrudeRegion | Interface for IExtrudeEdge objects |
| Cextruder::IExtrudeSet | Provides interface to IExtrudeSet. Contains containers for points, edges and blocks objects |
| Cextruder::IExtrudeSetList | Provides interface to IExtrudeSetList, an IContainer of IExtrudeSet objects |
| Czone::IFace | Interface to zone faces |
| Cblock::IFaceArray | Container to store FaceThings (zoned or triangulated block faces). ID of FaceThing is stored in offset $KFCPP in Fortran block linked list |
| Cblock::IFaceBlockArray | Container to store blockThings that are face blocks. ID of BlockThing is stored in offset $KBID in Fortran block linked list |
| Cblock::IFaceData | 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 |
| Czone::IZone::IFacePair | |
| Cblock::IFaceThing | 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 |
| Czone::IFaceWeight | Interface to face weight, used to define the location of a gridpoint in a given face |
| Citascaxd::IFactorOfSafety | |
| Cblock::IFEFaceArray | This interface provides access to beam thing array |
| Cblock::IFEFaceThing | 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 |
| Cblock::IFElementArray | This interface provides access to beam thing array |
| Cblock::IFElementThing | 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 |
| Czone::IFetchFluidProperty | |
| Citascaxd::IFetchProperty | |
| Czone::IFetchThermalProperty | |
| Citascaxd::IFishCallList | |
| ►CIFishLibrary | |
| Citascaxd::IFishPlot | This interface exposes a plot data interface (IGeneralPlot) to FISH |
| Cblock::IFlowKnotArray | Container to store FlowKnotThings |
| Cblock::IFlowKnotThing | 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 |
| Cblock::IFlowPlaneArray | Container to store FlowPlaneThings |
| Cblock::IFlowPlaneThing | |
| Cblock::IFlowPlaneVertexArray | Container to store IFlowPlaneVertexThings |
| Cblock::IFlowPlaneVertexThing | 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 |
| Cblock::IFlowZoneArray | Container to store IFlowZoneThings |
| Cblock::IFlowZoneThing | |
| Czone::IFluidGp | Interface to access fluid gridpoint data |
| Czone::IFluidModule | Interface to the Fluid Module |
| Czone::IFluidPerm | Interface to fluid permeability model |
| Czone::IFluidSat | Interface to fluid permeability model |
| Czone::IFluidZone | Interface to access fluid zone data |
| Cdfn::IFracNetwork | |
| Cdfn::IFracture | |
| Citascaxd::IFragment | |
| Citascaxd::IFragmentLogic | |
| Citascaxd::IFragmentModule | |
| Cpfc::IFWall | Interface for a faceted wall |
| Cpfcthermal::IFWallFacetFluid | |
| Cpfcthermal::IFWallFacetThermal | |
| Cpfcthermal::IFWallFluid | |
| Cpfcthermal::IFWallThermal | |
| Citascaxd::IGeneralPlot | This class allows user to draw basic geometric plots using FISH functions |
| Cmodule::IGenericModelList | |
| ►Cmodels::IGenericTet | Generic base class for the tetra interface made available to the constitutive model system |
| ►Cmodels::IGenericZone | Generic base class for the zone interface made available to the constitutive model system |
| Citascaxd::IGeomEdge | Interface for a user-defined geometric edge, defined as the line between two IGeomPoint objects |
| Citascaxd::IGeometry | Interface for the global list of all geomtric data sets IGeomSet |
| Citasca::IGeometryImportData | |
| Citasca::IGeomImportExport | |
| Citascaxd::IGeomPoint | Interface for a user-defined geometric point |
| Citascaxd::IGeomPoly | A class representing a single closed polygon made up of a list of edges |
| Citascaxd::IGeomSet | 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 |
| Cpfc::IGhostBall | |
| Cpfc::IGhostPebble | |
| Crblock::IGhostRBlock | |
| Cfish::IGlobalRuntime | |
| Citascaxd::IGlobals | Interface to modele global settings |
| Czone::IGp | Interface to provide access to a gridpoint |
| Cblock::IGpData | 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 |
| Czone::IGpData | Interface that allows access to gridpoint scalar data in a generic way |
| Czone::IGpList | Interface to the global list of all grid points |
| Citasca::IGroup | Interface to a group object |
| Citasca::IGroupList | Group container class |
| Citasca::IGUIInput | The interface to graphics user interface input functionality |
| Citascaxd::IHalfEdge | 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() |
| Citascaxd::IHalfFacet | 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 |
| Cpfc::IHalfFacetParent | |
| Citascaxd::IHalfVertex | 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 |
| Cpfc::IHalfVertexParent | |
| Citascaxd::IHistory | Interface to a particular history being taken by the history logic |
| Citascaxd::IHistoryList | Interface to the list of all IHistories being taken by the history logic |
| Czone::IHysDamp | Interface to hysteretic damping |
| Citasca::IIdent | Central class for information identifying the particular program using the kernel library |
| Cpfc::IInlet | |
| Cfish::IInput | This class provides FISH with input data |
| Citascaxd::IInputItem | |
| Citasca::IInputRecord | The input record maintains a list of all commands used in the creation of the model |
| Czone::IIntElem | Class provides access to the an interface element |
| Czone::IInterface | Class provides access to the an interface |
| Czone::IInterfaceList | Class provides access to the global list of all IIinterface objects in the model |
| Cdfn::IIntersect | |
| Cdfn::IIntersectionSet | |
| Czone::IIntModel | Interface provides access to the constitutive model of a FLAC3D interface |
| Czone::IIntNode | Class provides access to the an interface node |
| Cblock::IJointFaceArray | This interface provides access to jointthing array |
| Cblock::IJointFaceThing | |
| Citasca::IKernel | This Interface provides an entry point for command processing |
| Citascaxd::IKernelBase | |
| Citasca::IKernelInput | Interface describing ALL input support the kernel needs to receive from whatever interface is driving it |
| Citasca::IKernelOutput | Interface describing ALL output support the kernel needs to send information to whatever interface is driving it |
| Citascaxd::ILabel | Interface to a single label |
| Citascaxd::ILabelList | Interface to the list of all labels in the system |
| Cblock::ILinerArray | This interface provides access to liner thing array |
| Cblock::ILinerThing | |
| Cfish::IMain | |
| Citasca::IParse::IMark | Opaque position indicator class. Do not attempt to use directly for anything |
| Citascaxd::IMaxwellDamp | Interface to maxwell damping |
| Cpfc::IMeasure | |
| Citasca::IModelList | |
| Cpfc::IModuleBall | Interface for the Ball module. This is the interface for the Ball module |
| Cccfd::IModuleBallFluid | |
| Cpfcthermal::IModuleBallFluid | |
| Cpfc::IModuleBallMechanical | |
| Cpfcthermal::IModuleBallThermal | |
| Cblock::IModuleBlock | |
| Cpython::IModuleBlockPython | |
| Cblocksel::IModuleBlockSEL | |
| Cbody::IModuleBody | |
| Cpfc::IModuleBrick | |
| Cccfd::IModuleCCFD | Interface for the PFC ccfd module |
| Cpfc::IModuleClump | Interface 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 | |
| Cpfcsel::IModulePFCSEL | |
| Crblocksel::IModuleRBlockSEL | |
| Csel::IModuleSEL | |
| Cpython::IModuleSELPython | |
| Cpfc::IModuleWall | Interface for the wall module |
| Czone::IModuleZone | |
| Cpython::IModuleZonePython | |
| Czonesel::IModuleZoneSEL | |
| Citasca::IMultiContainer::IMultiCallInfo | |
| Citasca::IMultiContainer | |
| CIMutexLocker | An automatic QMutex lock/unlock helper class |
| CinnerLoopMS< T, SX, SY, I, J, K > | |
| CinnerLoopMS< T, SX, SY, I, J, 1 > | |
| Czone::INode | Interface to access node data |
| Citasca::INoticeManager | Interface to the notification system |
| Citasca::InputContext | |
| Citasca::InputLine | Provides a interface for getting text |
| ►Cstd::integral_constant | |
| Citasca::IContainer::IOpaqueIterator | Interface class for iterating through the container that has a null implementation |
| Cfish::IOutput | This class provides FISH with output data |
| Cfish::IParameter | |
| Citasca::IParentToChildContainer | Provides a class to use as the parent to a child container, or the main container of all of the children |
| Citasca::IParse | Interface to the main command processing class |
| Citascaxd::IParticleTrace | Interface to a particular particle trace being taken by the particle trace logic |
| Citascaxd::IParticleTraceList | Interface to the list of all IParticleTraces being taken by the particle trace logic |
| Cccfd::IPebbleCCFD | |
| Cpfcthermal::IPebbleThermal | |
| Cpfc::IPFCModule | Interface for the PFC module |
| Cpython::IPFCPythonModule | Interface for the PFC module |
| Cpfcthermal::IPFCThermalModule | |
| Cpython::IPFCThermalPython | Interface for the PFC module |
| Citascaxd::IPiece | |
| Citascaxd::IPieceContainer | |
| Citascaxd::IPieceExtension | |
| Citascaxd::IPieceFluid | |
| Citascaxd::IPieceMechanical | |
| Citascaxd::IPieceMechanicalData | |
| Citascaxd::IPieceThermal | |
| Citascaxd::IPlane | Interface for the definition of a Plane in 3D space |
| Citascaxd::IProcess | |
| Citascaxd::IProcessList | |
| Citasca::IProgram | The main program access point |
| Cpython::IPythonModule | Interface for the PYTHON module |
| Citasca::IRandom | Interface to the random number generator |
| Citascaxd::IRange | Interface to a filter, used as the main method for filtering objects |
| Citascaxd::IRangeElementContact | Interface to a RangeElement of contacts specifying activity, type, model name, etc |
| Cdfn::IRangeElementDFNGen | Interface to a RangeElement of dfns, where you want objects within a certain distance to fractures in sets of dfns. |
| Citascaxd::IRangeElementExtra | This part of a filter element interface describes which extra index is being referred to |
| Citascaxd::IRangeElementFish | Interface for providing an IRangeElement extension for a RangElementFish |
| Citascaxd::IRangeElementGeometryDistance | Interface to a RangeElement of a geometry set, where you want objects within a certain distance to this geometry set |
| Citascaxd::IRangeElementGeometrySpace | Interface to a RangeElement of a geometry set, where you want objects withion a certain space to this geometry sets (space ranger) |
| Cblock::IRangeElementGInt | Interface to a group intersection filter element, used to filter objects by group intersection |
| Citascaxd::IRangeElementGroup | Interface to a group filter element, used to filter objects by group assignment |
| Citascaxd::IRangeElementIdentifierList | Interface to to a Range Element that matches string to a list of stored strings |
| Czone::IRangeElementModel | Interface to a filter element that allows user to filter based on a zone model |
| Citascaxd::IRangeElementName | Interface to a RangeElement exposing the IThing getName method |
| Citascaxd::IRangeElementNamed | Interface to a Range Element that is actually a named filter |
| Citascaxd::IRangeElementNameList | Interface to to a Range Element that matches string to a list of stored strings |
| Cblock::IRangeElementOrientation | This interface provides access to orientation filters |
| Citascaxd::IRangeElementOrientation | |
| Czone::IRangeElementOrientation | Interface to a filter element that allows user to filter based on the orientation of zone faces |
| Citascaxd::IRangeElementPlane | Interface to a RangeElement of a plane in space, where you want objects above, below, or within a certain distance of the filter |
| Citascaxd::IRangeElementPolygonBased | Interface for accessing informations in the three drawable "interactive" filter elements in kernel/src/rangeelementinteractive.h (polygon,rectangle,ellipse) |
| Citascaxd::IRangeElementPosition | A filter element specified as a geometric region inside a capped cylinder, defined by a segment [begin-end] of radius Rad2 |
| Citascaxd::IRangeElementReal | Base for a filter that can be represented by a real number filter |
| Citascaxd::IRangeElementRegistry | Interface to a access the list of filter elements types registered with the engine |
| Csel::IRangeElementSELType | Interface to a filter element that allows user to filter based on a SEL type |
| Citascaxd::IRangeElementSet | Interface to a RangeElement of a general set. A IThing has getIsSet and getSet methods to return the appropriate information |
| Citascaxd::IRangeElementSphere | A filter element described as a sphere in space |
| Cblock::IRangeElementState | Interface to a filter element that allows user to filter based on a zone state |
| Czone::IRangeElementState | Interface to a filter element that allows user to filter based on a zone state |
| Cblock::IRangeElementSurface | |
| Citascaxd::IRangeElementSurface | Interface to a filter element that allows user to filter based on connection to a "surface" of the zones |
| Cblock::IRangeElementTwoInt | IRangeElement for RangeElementMaterialIntersection |
| Citascaxd::IRangeElementUIntPtr | Interface to to a Range Element that selects integers between two values |
| Citascaxd::IRangeElementUIntPtrList | Interface to to a Range Element that matches an integer to a list of stored integers |
| Czone::IRangeElementVolume | Interface to a filter element that allows user to filter based on a volume |
| Citascaxd::IRangeList | Interface to the global list of all named filters |
| Citascaxd::IRayleighDamp | Interface to hysteretic damping |
| Crblock::IRBlock | |
| Crblock::IRBlockModule | |
| Cpython::IRBlockPythonModule | Interface for the RBlock module |
| Crblock::IRBlockTemplate | |
| Crblockthermal::IRBlockThermal | |
| Crblockthermal::IRBlockThermalModule | Interface for the RBlock thermal module |
| Cblock::IReinforcementArray | This interface provides access to reinforcement thing array |
| Cblock::IReinforcementThing | |
| Citascaxd::IRigidBodyMechanical | |
| Csel::ISEL | Interface to the structural elements base class |
| Csel::ISELBeam | Interface to beam structural elements |
| Csel::ISELCable | Interface to cable structural elements |
| Csel::ISELDowel | Interface to dowel structural elements |
| Csel::ISELGeogrid | Interface to geogrid structural elements |
| Csel::ISELHybrid | Interface to hybrid structural elements |
| Csel::ISELLiner | Interface to liner structural elements |
| Csel::ISELLiner2d | Interface to 2d liner structural elements |
| Csel::ISELLink | Interface to provide access to structural element links |
| Csel::ISELLinkList | Interface to the global list of all structural elements links |
| Csel::ISELLinkModel | |
| Csel::ISELList | Interface to the global list of all structural elements |
| Csel::ISELNode | Interface to provide access to structural element nodes |
| Cblock::ISELNodeArray | 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) |
| Csel::ISELNodeList | Interface to the global list of all structural elements nodes |
| Cblock::ISELNodeThing | 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 |
| Csel::ISELPile | Interface to pile structural elements |
| Cblock::ISelProp | This interface provides access to cable thing. The fortran offset for the SelProp ID is $ktypcpp in the Fortran sel property data array |
| Cblock::ISelPropArray | This interface provides access to SelProp array |
| Csel::ISELShell | Interface to shell structural elements |
| Citasca::ISettings | Interface for accessing kernel settings |
| Citasca::ISlot | Interface to a slot object |
| ►Citasca::ISlotID | |
| Citascaxd::ISolveData | Interface for accessing solve command limits |
| Citascaxd::ISphere | Interface for the definition of a Sphere |
| Cblock::ISubcontactArray | Container to store SubcontactThings. ID of SubcontactThing is stored in offset $KCXCPP in Fortran subcontac linked list |
| Cblock::ISubcontactThing | 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 |
| Czone::ISurface | Interface to provide access to surfaces, see command GEN SURFACE |
| Czone::ISurfaceList | Interface to the global list of all surfaces, see command GEN SURFACE |
| Cfish::ISymbol | |
| Citasca::ITable | Interface to a particular table of values |
| Citasca::ITableList | Interface to the global list of all tables |
| ►Cbase::iterator | |
| Citasca::ITextInput | |
| Citasca::ITextOutput | Provides a interface for simple writing of text |
| Czone::IThermAnaSource | Interface to the thermal analytical source |
| Czone::IThermAnaSourceList | Interface to the global list of all thermal analytical sources |
| Czone::IThermGp | Interface to access gridpoint thermal data |
| Czone::IThermModule | Interface to the thermal module |
| Czone::IThermZone | Interface to access zone thermal data |
| Citasca::IThing | Base class for items that will be stored in containers |
| Cpfc::ITriPoly | Interface for a TriPoly |
| Cblock::IType3DEC | |
| Citascaxd::IUDPos | Interface 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::IVertexArray | Container to store VertexThings. ID of VertexThing is stored in offset $KVCPP in Fortran vertex linked list |
| Cdfn::IVertexDFN | |
| Cblock::IVertexThing | 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 |
| Cpfc::IWall | 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 |
| Cwallsel::IWallSelModule | |
| Cblock::IWater | This interface provides access to functions used to define a water surface |
| Czone::IWaterTable | Interface for accessing water table data |
| Cblock::IZoneArray | Container to store ZoneThings. ID of BlockThing is stored in offset $KZCPP in Fortran zone linked list |
| Cblock::IZoneData | 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 |
| Czone::IZoneData | Access to zone scalar data |
| Cblock::IZoneFieldData | 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 |
| Czone::IZoneFieldData | Interface for accessing the zone field data class |
| Czone::IZoneGlobals | Interface to access FLAC3D data, see SET and CONFIG commands |
| Cblock::IZoneInterpolate | Interface for accessing the zone interpolation class |
| Czone::IZoneInterpolate | Interface for accessing the zone interpolation class |
| Czone::IZoneList | Interface for accessing the global list of zones, IZoneList |
| Cjmodels::JointModel | The 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 | |
| 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 |
| Cfish::ParameterValue | |
| ►CPropBase | |
| Cbase::PropDesc | |
| Cmodels::PropertyBlock | The class provides reference count for model properties |
| Citasca::IModelList::PropInfo | |
| Cmodule::IGenericModelList::PropInfo | |
| CQList< T > | |
| CQStringCIEqual2 | |
| CQStringCIHash2 | |
| CQStringCILess2 | |
| CQStringLocalLess2 | |
| ►CQTextStream | |
| 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 |
| ►Cstd::queue | |
| 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::State | The structure used to pass information to the joint constitutive model |
| Cmodels::State | The 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 > | |
| CSymTensor | A symmetric 2nd order tensor |
| CSymTensorInfo | SymTensor 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 | |
| CVariant | A 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 |
| 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 |
1.10.0