| Cchrono::sensor::AccelData | Accelerometer data |
| Cchrono::utils::MixtureIngredient::AddBodyCallback | Class to be used as a callback interface for some user-defined action to be taken each time the generator creates and adds a body based on this mixture ingredient to the system |
| Cchrono::particlefactory::ChRandomShapeCreator::AddBodyCallback | Class to be used as a callback interface for some user-defined action to be taken each time a body is generated and added to the system |
| Cchrono::ChContactContainer::AddContactCallback | Class to be used as a callback interface for some user defined action to be taken each time a contact is added to the container |
| Cchrono::ChProximityContainer::AddProximityCallback | Class to be used as a callback interface for some user defined action to be taken each time a proximity info is added to the container |
| Cchrono::synchrono::ApproachLane | Lane that is grouped into an approach with other ApproachLanes |
| Cchrono::fea::AverageSectionParameters | The aeverage section properties of tapered section could be stored in this struct |
| Cchrono::sensor::Background | Information about the background of the scene |
| Cchrono::gpu::BC_params_t< T, T3 > | Big enum to handle all possible boundary conditions |
| Cchrono::BodyExchange | Structure of data for sending a new body to a rank |
| Cchrono::vehicle::BodyState | Structure to communicate a full body state |
| Cchrono::ChSystemDistributed::BodyState | Stores all data needed to fully update the state of a body |
| Cchrono::BodyUpdate | Structure of data for sending an update of an existing body to a rank |
| Cchrono::vehicle::ChVehicleGeometry::BoxShape | Box shape for visualization and/or collision |
| Cchrono::collision::ChCollisionSystem::BroadphaseCallback | Class to be used as a callback interface for user-defined actions to be performed for each 'near enough' pair of collision shapes found by the broad-phase collision step |
| Cchrono::collision::btArcArcCollisionAlgorithm | Custom override of the default Bullet algorithm for 2Darc-2Darc collision |
| Cchrono::collision::btArcSegmentCollisionAlgorithm | Custom override of the default Bullet algorithm for 2Dsegment-2Darc collision |
| Cchrono::collision::btCapsuleBoxCollisionAlgorithm | Custom override of the default Bullet algorithm for capsule-box collision |
| Cchrono::collision::btCEtriangleShapeCollisionAlgorithm | Custom override of the default Bullet algorithm for triangle-triangle collision |
| Cchrono::collision::btCylshellBoxCollisionAlgorithm | Custom override of the default Bullet algorithm for cylshell-box collision |
| Cchrono::collision::btSphereCylinderCollisionAlgorithm | Custom override of the default Bullet algorithm for sphere-cylinder collision |
| Cchrono::sensor::ByteImageData | Stores image data |
| CCameraMissParameters | The parameters associated with camera miss data. A.K.A background data |
| CCameraParameters | The parameters needed to define a camera |
| Cchrono::Ch_enable_bitmask_operators< E > | Helper for adding bitmask operators | ^ & etc |
| Cchrono::utils::ChAbsorbed_Power_Vertical | Filter for vertical absorbed power |
| Cchrono::sensor::ChAccelerometerSensor | Accelerometer class |
| Cchrono::vehicle::ChAdaptiveSpeedController | Data collection from the speed controller can be started (restarted) and suspended (stopped) as many times as desired |
| ►Cchrono::utils::ChAnalogueFilter | Base class for simulated analogue filters in the time domain |
| Cchrono::utils::ChFilterD | Caclulate the time derivation of an input signal: H(s) = Td * s |
| Cchrono::utils::ChFilterI | Calculate the integral of an input signal in the time domain: H(s) = 1 / ( Ti * s) |
| Cchrono::utils::ChFilterPD1 | PD1 controller: H(s) = Kdt1 * ( Td1 * s + 1 ) |
| Cchrono::utils::ChFilterPDT1 | PDT1 controller: H(s) = Kp * ( Td1 * s + 1 ) / ( T1 * s + 1) |
| Cchrono::utils::ChFilterPT1 | Delay an input signal: H(s) = Kpt1 / ( T1 * s + 1 ) |
| ►Cchrono::ChArchive | This is a base class for archives with pointers to shared objects |
| ►Cchrono::ChArchiveIn | This is a base class for serializing from archives |
| Cchrono::ChArchiveInBinary | This is a class for serializing from binary archives |
| Cchrono::ChArchiveInJSON | This is a class for deserializing from JSON archives |
| Cchrono::ChArchiveInXML | This is a class for deserializing from XML archives |
| ►Cchrono::ChArchiveOut | This is a base class for serializing into archives |
| Cchrono::ChArchiveAsciiDump | ASCII 'LOG' ARCHIVES (only output, for debugging etc.) |
| Cchrono::ChArchiveExplorer | A helper class to provide some basic mechanism of C++ reflection (introspection) |
| Cchrono::ChArchiveOutBinary | This is a class for serializing to binary archives |
| Cchrono::ChArchiveOutJSON | This is a class for serializing to JSON |
| Cchrono::ChArchiveOutXML | This is a class for serializing to XML file format |
| Cchrono::ChAssemblyAnalysis | Class for assembly analysis |
| ►Cchrono::ChAsset | Classes for adding user data (such as rendering shapes, reference to files) to ChPhysicsItem objects |
| Cchrono::cascade::ChCascadeShapeAsset | Class for an asset that contains an OpenCASCADE shape |
| ►Cchrono::ChAssetLevel | Class for grouping assets in a level |
| Cchrono::fea::ChVisualizationFEAmesh | Class for a FEA mesh visualization |
| Cchrono::ChCamera | Class for defining a videocamera point of view with basic settings |
| Cchrono::ChColorAsset | Base class for assets that carry basic informations about the surface color for visualization assets |
| Cchrono::ChEmitterAsset | Class that attaches a ChParticleEmitter to a physics item (most often that item is a ChBody) |
| Cchrono::ChTexture | Base class for assets that define basic textures |
| ►Cchrono::ChVisualization | Base class for assets that define something about visualization (rendering, post processing, etc.) It contains basic information about position, color, and visibility |
| Cchrono::ChBarrelShape | Class for referencing a barrel shape (a lathed arc) that can be visualized in some way |
| Cchrono::ChBoxShape | Class for a box shape that can be visualized in some way |
| Cchrono::ChCapsuleShape | Class for referencing a capsule shape that can be visualized in some way |
| Cchrono::ChConeShape | Class for referencing a cone shape that can be visualized in some way |
| Cchrono::ChCylinderShape | Class for referencing a cylinder shape that can be visualized in some way |
| Cchrono::ChEllipsoidShape | Class for referencing an ellipsoid shape that can be visualized in some way |
| Cchrono::ChGlyphs | Class for referencing a set of 'glyphs', that are simple symbols such as arrows or points to be drawn for showing vector directions etc |
| ►Cchrono::ChLineShape | Class for referencing a ChLine that can be visualized in some way |
| ►Cchrono::ChPointPointDrawing | Base class for visualization of some deformable line shape between two moving points related to the parent ChPhysicsItem |
| Cchrono::ChPointPointSegment | Class to visualize a line segment between two moving points related to the parent ChPhysicsItem |
| Cchrono::ChPointPointSpring | Class to visualize a coil spring between two moving points related to the parent ChPhysicsItem |
| Cchrono::ChObjShapeFile | Class for referencing a Wavefront/Alias .obj file containing a shape that can be visualized in some way |
| Cchrono::ChPathShape | Class for referencing a ChLinePath that can be visualized in some way |
| Cchrono::ChRoundedBoxShape | Class for referencing a rounded box shape that can be visualized in some way |
| Cchrono::ChRoundedConeShape | Class for referencing a rounded cone shape that can be visualized in some way |
| Cchrono::ChRoundedCylinderShape | Class for referencing a rounded cylinder shape that can be visualized in some way |
| Cchrono::ChSphereShape | Class for referencing a sphere shape that can be visualized in some way |
| Cchrono::ChSurfaceShape | Class for referencing a ChSurface u,v, parametric surface that can be visualized in some way |
| Cchrono::ChTriangleMeshShape | Class for referencing a triangle mesh shape that can be visualized in some way |
| Cchrono::ChVisualMaterial | Class for setting a color (used by ChVisualization) |
| Cchrono::irrlicht::ChIrrNodeAsset | Class for adding Irrlicht visualization to a ChPhysicsItem |
| Cchrono::postprocess::ChPovRayAsset | Class for telling to the POV ray exporter that the ChPhysicsItem that contain this asset should be exported to POV scripts |
| Cchrono::postprocess::ChPovRayAssetCustom | Class for adding custom commands to POVray objects saved with ChBody items; for example you can specify pigment{...} or texture{...} stuff here |
| Cchrono::vehicle::ChAxle | Base class for a suspension subsystem |
| Cchrono::geometry::ChBasisToolsBspline | Tools for evaluating basis functions for B-splines, parametrized with parameter u (as lines) These bases are often called "N" in literature |
| Cchrono::geometry::ChBasisToolsBsplineSurfaces | Tools for evaluating basis functions for tensor-product surface B-splines, parametrized with parameters u,v (as lines) These bases are often called "R" in literature |
| Cchrono::geometry::ChBasisToolsNurbs | Tools for evaluating basis functions for NURBS, parametrized with parameter u (as lines) These bases are often called "R" in literature |
| Cchrono::geometry::ChBasisToolsNurbsSurfaces | Tools for evaluating basis functions for tensor-product surface NURBS, parametrized with parameter u,v (as lines) These bases are often called "R" in literature |
| ►Cchrono::fea::ChBeamMaterialInternalData | Base class for internal variables of materials |
| Cchrono::fea::ChInternalDataLumpedCosserat | Internal variables for basic lumped plasticity in Cosserat beams |
| ►Cchrono::fea::ChBeamSection | Base class for properties of beam sections |
| Cchrono::fea::ChBeamSectionCable | Simplified geometry for a 'cable' beam section in 3D, that is a beam without torsional stiffness and with circular section (i.e.same Ixx and Iyy properties) |
| ►Cchrono::fea::ChBeamSectionCosserat | Base class for properties of beam sections of Cosserat type (with shear too) such as ChElementBeamIGA |
| Cchrono::fea::ChBeamSectionCosseratEasyCircular | A simple specialization of ChBeamSectionCosserat if you do not need to define its separate models for elasticity, plasticity, damping and inertia |
| Cchrono::fea::ChBeamSectionCosseratEasyRectangular | A simple specialization of ChBeamSectionCosserat if you do not need to define its separate models for elasticity, plasticity, damping and inertia |
| ►Cchrono::fea::ChBeamSectionEuler | Base class for all constitutive models of sections of Euler beams |
| ►Cchrono::fea::ChBeamSectionEulerAdvancedGeneric | General purpose section of an Euler-Bernoulli beam in 3D, not assuming homogeneous density or homogeneous elasticity, given basic material properties |
| ►Cchrono::fea::ChBeamSectionRayleighAdvancedGeneric | This works exactly as ChBeamSectionEulerAdvancedGeneric, but adds the effect of Jyy Jzz rotational sectional inertias |
| ►Cchrono::fea::ChBeamSectionTimoshenkoAdvancedGeneric | Base class for all constitutive models of sections of Timoshenko beams |
| Cchrono::fea::ChBeamSectionTimoshenkoAdvancedGenericFPM | For composite beams such as wind turbine blades and helicopter rotor blades, the cross-sectional stiffness properties in axial, shear, bending and torsion directions are coupled with each other, hence the fully-populated matrix(FPM) of cross-sectional stiffness properties is used to describe this complex coupling |
| ►Cchrono::fea::ChBeamSectionEulerSimple | Basic section of an Euler-Bernoulli beam in 3D, for a homogeneous density and homogeneous elasticity, given basic material properties (Izz and Iyy moments of inertia, area, Young modulus, etc.) |
| Cchrono::fea::ChBeamSectionEulerAdvanced | Advanced section of an Euler-Bernoulli beam in 3D, for a homogeneous density and homogeneous elasticity, given basic material properties (Izz and Iyy moments of inertia, area, Young modulus, etc.), but also supporting the advanced case of Iyy and Izz axes rotated respect reference, elastic center with offset from centerline reference, and shear center with offset from centerline reference |
| Cchrono::fea::ChBeamSectionEulerEasyCircular | A simple specialization of ChBeamSectionEuler if you just need the simplest model for a beam with circular centered section, with uniform elasticity and uniform density |
| Cchrono::fea::ChBeamSectionEulerEasyRectangular | A simple specialization of ChBeamSectionEuler if you just need the simplest model for a rectangular centered beam, with uniform elasticity and uniform density |
| ►Cchrono::fea::ChBeamSectionRayleighSimple | This works exactly as ChBeamSectionEulerSimple, but adds the effect of Jyy Jzz rotational sectional inertias, whereas the conventional Euler theory would assume the mass to be concentrated in the center of mass, hence Jyy Jzz =0 |
| Cchrono::fea::ChBeamSectionRayleighEasyCircular | This works exactly as ChBeamSectionEulerEasyCircular, but adds the effect of Jyy Jzz rotational sectional inertias |
| Cchrono::fea::ChBeamSectionRayleighEasyRectangular | This works exactly as ChBeamSectionEulerEasyRectangular, but adds the effect of Jyy Jzz rotational sectional inertias |
| ►Cchrono::fea::ChBeamSectionShape | Base class for drawing tesselated profiles of beams in 3D views, if needed |
| Cchrono::fea::ChBeamSectionShapeCircular | A ready-to-use class for drawing properties of circular beams |
| Cchrono::fea::ChBeamSectionShapePolyline | A class for drawing properties of beams whose section is a set of M polylines, each with N points |
| Cchrono::fea::ChBeamSectionShapeRectangular | A ready-to-use class for drawing properties of rectangular beams |
| ►Cchrono::fea::ChBeamSectionTaperedTimoshenkoAdvancedGeneric | Base class for all constitutive models of sections of Tapered Timoshenko beams |
| Cchrono::fea::ChBeamSectionTaperedTimoshenkoAdvancedGenericFPM | Base class for all constitutive models of fully-populated matrix(FPM) sections of Tapered Timoshenko beams |
| Cchrono::utils::ChBenchmarkFixture< TEST, SKIP > | Generic benchmark fixture for Chrono tests |
| Cchrono::utils::ChBenchmarkTest | Base class for a Chrono benchmark test |
| Cchrono::ChBezierCurve | Definition of a piece-wise cubic Bezier approximation of a 3D curve |
| Cchrono::ChBezierCurveTracker | Definition of a tracker on a ChBezierCurve path |
| ►Cchrono::ChBinaryArchive | Base class for streams (either in or out) based on binary formats |
| ►Cchrono::ChStreamInBinary | This is a base class for all BINARY INPUT streams, in a way such that the stream is platform independent (see the 'little endian' stuff in 'floating point to persistent data' topics..) Defines some << operators from basic types, converting all them into calls to the Output() function |
| Cchrono::ChStreamInBinaryFile | This is a specialized class for BINARY input on system's file, |
| Cchrono::ChStreamInBinaryStream | This is a specialized class for BINARY input from wrapped std::istream, |
| Cchrono::ChStreamInBinaryVector | This is a specialized class for BINARY input from wrapped std::vector<char>, |
| ►Cchrono::ChStreamOutBinary | This is a base class for all BINARY OUTPUT streams, in a way such that the stream is platform independent (see the 'little endian' stuff in 'floating point to persistent data' topics..) Defines some << operators from basic types, converting all them into calls to the Output() function |
| Cchrono::ChStreamOutBinaryFile | This is a specialized class for BINARY output on system's file, |
| Cchrono::ChStreamOutBinaryStream | This is a specialized class for BINARY output to wrapped std::ostream, |
| Cchrono::ChStreamOutBinaryVector | This is a specialized class for BINARY output to wrapped std::vector<char>, |
| Cchrono::collision::ChBroadphase | Class for performing broad-phase collision detection |
| Cchrono::fea::ChBuilderBeamANCF | Utility class for creating complex beams using ChElementBeamANCF_3333 elements, for example subdivides a segment in multiple finite elements |
| Cchrono::fea::ChBuilderBeamEuler | Utility class for creating complex beams using ChElementBeamEuler elements, for example subdivides a segment in multiple finite elements |
| Cchrono::fea::ChBuilderBeamIGA | Utility class for creating complex beams using ChElementBeamIGA elements, for example subdivides a segment in multiple finite elements |
| Cchrono::fea::ChBuilderBeamTaperedTimoshenko | Utility class for creating complex beams using ChElementBeamTaperedTimoshenko elements, for example subdivides a segment in multiple finite elements |
| Cchrono::fea::ChBuilderBeamTaperedTimoshenkoFPM | Utility class for creating complex beams using ChElementBeamTaperedTimoshenkoFPM elements, for example subdivides a segment in multiple finite elements |
| Cchrono::fea::ChBuilderCableANCF | Utility class for creating complex beams using ChElementCableANCF elements, for example subdivides a segment in multiple finite elements |
| Cchrono::utils::ChButterworth_Highpass | Butterworth high-pass filter |
| Cchrono::utils::ChButterworth_Lowpass | Butterworth low-pass filter |
| Cchrono::cascade::ChCascadeDoc | Class that contains an OCAF document (a tree hierarchy of shapes in the OpenCascade framework) |
| Cchrono::cascade::ChCascadeMeshTools | Tools to convert an OpenCASCADE shapes into triangle meshes |
| ►Cchrono::cascade::ChCascadeTriangulate | Base class for storing settings on openCASCADE tesselation of shapes |
| Cchrono::cascade::ChCascadeTriangulateNone | Class for storing settings on openCASCADE tesselation of shapes |
| Cchrono::cascade::ChCascadeTriangulateTolerances | Class for storing settings on openCASCADE tesselation of shapes |
| Cchrono::utils::ChChaseCamera | Utility class for a generic chase camera which can be associated with any ChBody in a Chrono system |
| Cchrono::ChClassFactory | A class factory |
| ►Cchrono::ChClassRegistrationBase | Base class for all registration data of classes whose objects can be created via a class factory |
| Cchrono::ChClassRegistration< t > | Macro to create a ChDetect_ArchiveINconstructor
|
| Cchrono::collision::ChCollisionData | Global data for the custom Chrono multicore collision system |
| Cchrono::collision::ChCollisionInfo | Class defining basic geometric information for collision pairs |
| ►Cchrono::collision::ChCollisionModel | Class defining the geometric model for collision detection |
| Cchrono::collision::ChCollisionModelBullet | Class defining the Bullet geometric model for collision detection |
| ►Cchrono::collision::ChCollisionModelChrono | Geometric model for the custom multicore Chrono collision system |
| Cchrono::collision::ChCollisionModelDistributed | This class adds the ability to track the axis-aligned bounding box for the entire model so that an entire body can be classified by which sub-domains it intersects |
| Cchrono::collision::ChCollisionPair | Class for storing information about a collision point |
| ►Cchrono::collision::ChCollisionShape | Class defining a collision shape |
| Cchrono::collision::ChCollisionShapeBullet | Collision shape for Bullet collision detection system |
| Cchrono::collision::ChCollisionShapeChrono | Collision shape for the custom multicore Chrono collision system |
| ►Cchrono::collision::ChCollisionSystem | Base class for generic collision engine |
| Cchrono::collision::ChCollisionSystemBullet | Collision engine based on the Bullet library |
| Cchrono::collision::ChCollisionSystemBulletMulticore | Collision engine based on the 'Bullet' library |
| ►Cchrono::collision::ChCollisionSystemChrono | Chrono custom multicore collision system |
| ►Cchrono::collision::ChCollisionSystemChronoMulticore | Chrono custom multicore collision system |
| Cchrono::collision::ChCollisionSystemDistributed | This class scaffolds on ChCollisionSystemChronoMulticore in order to manage collision data for the system during MPI exchanges |
| Cchrono::ChColor | Class for setting a color (used by ChVisualization) |
| Cchrono::ChCommDistributed | This class holds functions for processing the system's bodies to determine when a body needs to be sent to another rank for either an update or for creation of a ghost |
| ►Cchrono::ChConstraint | Base class for representing constraints to be used with variational inequality solvers, used with Linear/CCP/LCP problems including inequalities, equalities, nonlinearities, etc |
| Cchrono::ChConstraintTwoTuples< chrono::fea::ChNodeFEAxyz, chrono::fea::ChTriangleOfXYZnodes > | |
| Cchrono::ChConstraintTwoTuples< chrono::fea::ChNodeFEAxyz, chrono::fea::ChTriangleOfXYZROTnodes > | |
| ►Cchrono::ChConstraintTwoTuples< typecarr_a, typecarr_b > | |
| Cchrono::ChConstraintTwoTuplesContactN< typecarr_a, typecarr_b > | |
| Cchrono::ChConstraintTwoTuplesFrictionT< typecarr_a, typecarr_b > | |
| Cchrono::ChConstraintTwoTuplesRollingN< typecarr_a, typecarr_b > | |
| Cchrono::ChConstraintTwoTuplesRollingT< typecarr_a, typecarr_b > | |
| Cchrono::ChConstraintNgeneric | This class implements the functionality for a constraint between N objects of type ChVariables(), and defines three constraint matrices, whose column number automatically matches the number of elements in variables vectors |
| ►Cchrono::ChConstraintThree | This class is inherited by the base ChConstraint(), which does almost nothing |
| Cchrono::ChConstraintThreeBBShaft | A class for representing a constraint between two bodies (2x6dof in space) and a 1D dof (a shaft) |
| Cchrono::ChConstraintThreeGeneric | This class is inherited by the base ChConstraintThree(), which is a base for triple constraints |
| ►Cchrono::ChConstraintTwo | This class implements the functionality for a constraint between a COUPLE of TWO objects of type ChVariables(), and defines two constraint matrices, whose column number automatically matches the number of elements in variables vectors |
| Cchrono::ChConstraintTwoBodies | This class implements the functionality for a constraint between a couple of two objects of type ChVariablesBody |
| ►Cchrono::ChConstraintTwoGeneric | This class implements the functionality for a constraint between a COUPLE of TWO objects of type ChVariables(), with generic number of scalar variables each (ex.ChVariablesGeneric() or ChVariablesBody() ) and defines two constraint matrices, whose column number automatically matches the number of elements in variables vectors |
| Cchrono::ChConstraintTwoGenericBoxed | This class is inherited from the base ChConstraintTwoGeneric, which can be used for most pairwise constraints, and adds the feature that the multiplier must be l_min < l < l_max that is, the multiplier is 'boxed' |
| ►Cchrono::ChConstraintTwoTuples< Ta, Tb > | This constraint is built on top of two ChConstraintTuple objects, each with a tuple of 1 or 2 or 3 differently-sized jacobian chunks |
| Cchrono::ChConstraintTwoTuplesContactN< Ta, Tb > | This class is inherited from the ChConstraintTwoTuples, It is used to represent the normal reaction between two objects, each represented by a tuple of ChVariables objects, ONLY when also two ChConstraintTwoTuplesFrictionT objects are used to represent friction |
| Cchrono::ChConstraintTwoTuplesFrictionT< Ta, Tb > | Base class for friction constraints between two objects, each represented by a tuple of ChVariables objects |
| Cchrono::ChConstraintTwoTuplesRollingN< Ta, Tb > | This class is inherited from ChConstraintTwoTuples, It is used to represent the normal reaction between two objects, each represented by a tuple of ChVariables objects, ONLY when also two ChConstraintTwoTuplesFrictionT objects are used to represent friction |
| Cchrono::ChConstraintTwoTuplesRollingT< Ta, Tb > | Base class for friction constraints between two objects, each represented by a tuple of ChVariables objects |
| Cchrono::ChConstraintBilateral | Bilateral (joint) constraints |
| Cchrono::ChConstraintRigidRigid | Unilateral (contact) constraints |
| Cchrono::ChConstraintTuple_1vars< T > | This is a container for 'half' of a constraint, and contains a tuple of 1 or 2 or 3 differently-sized jacobian chunks |
| Cchrono::ChConstraintTuple_2vars< T > | Case of tuple with reference to 2 ChVariable objects: |
| Cchrono::ChConstraintTuple_3vars< T > | Case of tuple with reference to 3 ChVariable objects: |
| Cchrono::ChConstraintTuple_4vars< T > | Case of tuple with reference to 4 ChVariable objects: |
| ►Cchrono::ChConstraintTwoTuplesFrictionTall | This is enough to use dynamic_casting<> to detect all template types from ChConstraintTwoTuplesFrictionT |
| Cchrono::ChConstraintTwoTuplesFrictionT< typecarr_a, typecarr_b > | |
| Cchrono::ChConstraintTwoTuplesFrictionT< Ta, Tb > | Base class for friction constraints between two objects, each represented by a tuple of ChVariables objects |
| ►Cchrono::ChConstraintTwoTuplesRollingNall | This is enough to use dynamic_casting<> to detect all template types from ChConstraintTwoTuplesRollingN |
| Cchrono::ChConstraintTwoTuplesRollingN< typecarr_a, typecarr_b > | |
| Cchrono::ChConstraintTwoTuplesRollingN< Ta, Tb > | This class is inherited from ChConstraintTwoTuples, It is used to represent the normal reaction between two objects, each represented by a tuple of ChVariables objects, ONLY when also two ChConstraintTwoTuplesFrictionT objects are used to represent friction |
| ►Cchrono::ChConstraintTwoTuplesRollingTall | This is enough to use dynamic_casting<> to detect all template types from ChConstraintTwoTuplesRollingT |
| Cchrono::ChConstraintTwoTuplesRollingT< typecarr_a, typecarr_b > | |
| Cchrono::ChConstraintTwoTuplesRollingT< Ta, Tb > | Base class for friction constraints between two objects, each represented by a tuple of ChVariables objects |
| Cchrono::ChContactable | Interface for objects that generate contacts One should inherit from ChContactable_1vars, ChContactable_2vars etc |
| ►Cchrono::fea::ChContactNodeXYZ | Proxy to FEA nodes, to grant them the features needed for collision detection |
| Cchrono::fea::ChContactNodeXYZsphere | Proxy to FEA nodes for collisions, with spheres associated to nodes, for point-cloud type of collisions |
| ►Cchrono::fea::ChContactNodeXYZROT | Proxy to FEA nodes with 3 xyz + 3 rot coords, to grant them the features needed for collision detection |
| Cchrono::fea::ChContactNodeXYZROTsphere | Proxy to FEA nodes for collisions, with spheres associated to nodes, for point-cloud type of collisions |
| ►Cchrono::fea::ChContactSurface | Base class for contact surfaces in FEA meshes |
| Cchrono::fea::ChContactSurfaceMesh | Class which defines a contact surface for FEA elements, using a mesh of triangles |
| Cchrono::fea::ChContactSurfaceNodeCloud | Class which defines a contact surface for FEA elements, where only xyz nodes in the FEA model are used as contact items for the collision detection |
| ►Cchrono::ChContactTuple< Ta, Tb > | Base class for contact between two generic ChContactable objects |
| ►Cchrono::ChContactNSC< Ta, Tb > | Class for non-smooth contact between two generic ChContactable objects |
| Cchrono::ChContactNSCrolling< Ta, Tb > | Class for non-smooth contact between two generic ChContactable objects |
| Cchrono::ChContactSMC< Ta, Tb > | Class for smooth (penalty-based) contact between two generic contactable objects |
| ►Cchrono::fea::ChContinuumMaterial | Base class for properties of materials in a continuum |
| Cchrono::ChContinuumSPH | Class for SPH fluid material, with basic property of incompressible fluid |
| ►Cchrono::fea::ChContinuumElastic | Class for the basic properties of materials in an elastic continuum |
| ►Cchrono::fea::ChContinuumElastoplastic | Class for all elastic materials that can undergo plastic flow |
| Cchrono::fea::ChContinuumDruckerPrager | Class for the basic properties of elastoplastic materials of Drucker-Prager type, that are useful for simulating soils |
| Cchrono::fea::ChContinuumPlasticVonMises | Class for the basic properties of materials in an elastoplastic continuum, with strain yield limit based on Von Mises yield |
| ►Cchrono::fea::ChContinuumPoisson3D | Class for the basic properties of scalar fields P in 3D FEM problems that can be described by Laplace PDEs of type rho dP/dt + div [C] grad P = 0 |
| Cchrono::fea::ChContinuumElectrostatics | Class for material for FEA electrostatic problems |
| Cchrono::fea::ChContinuumThermal | Class for thermal fields, for FEA problems involving temperature, heat, etc |
| ►Cchrono::collision::ChConvexDecomposition | Base interface class for convex decomposition |
| Cchrono::collision::ChConvexDecompositionHACD | Class for wrapping the HACD convex decomposition code by Khaled Mamou |
| Cchrono::collision::ChConvexDecompositionHACDv2 | Class for wrapping the HACD convex decomposition code revisited by John Ratcliff |
| Cchrono::utils::ChConvexHull2D | Simple 2D convex hull class |
| Cchrono::collision::bt_utils::ChConvexHullLibraryWrapper | Wrapper for using and exporting the Bullet implementation of the convex hull library |
| Cchrono::ChCoordsys< Real > | COORDSYS: |
| Cchrono::ChCoordsys< double > | |
| Cchrono::cosimul::ChCosimulation | Class for cosimulation interface |
| Cchrono::ChCubicSpline | Implementation of 1-D piece-wise cubic spline curves |
| ►Cchrono::fea::ChDampingCosserat | Base interface for structural damping of beam sections of Cosserat type, where xyz force "n" and xyz torque "m" are a 6-dimensional function of generalized strain speeds, "e'" traction/shear speed and "k'" curvature speed, as: {n,m}=f({e',k'}) Children classes implement this function in different ways |
| Cchrono::fea::ChDampingCosseratLinear | Simple linear lumped damping of beam sections of Cosserat type, {n,m}=f({e',k'}) where damping is proportional to speed of deformation/curvature via linear constants: |
| Cchrono::fea::ChDampingCosseratRayleigh | Simple Rayleigh damping of beam sections of Cosserat type, where damping is proportional to stiffness via a beta coefficient |
| ►Cchrono::fea::ChDampingKirchhoff | Base interface for damping of thin shells (Kirchoff-Love shell theory, without shear effects) to be used in a ChMaterialShellKirchhoff |
| Cchrono::fea::ChDampingKirchhoffRayleigh | Simple Rayleight damping of a Kirchhoff shell layer, where damping is proportional to stiffness via a beta coefficient |
| ►Cchrono::fea::ChDampingReissner | Base interface for damping of 6-field Reissner-Mindlin shells (kinematically-exact shell theory as in Witkowski et al.) to be used in a ChMaterialShellReissner |
| Cchrono::fea::ChDampingReissnerRayleigh | Simple Rayleight damping of a Reissner-mindlin shell, where damping is proportional to stiffness via a beta coefficient |
| Cchrono::ChDistributedDataManager | A class for storing data for maintaining a consistent view of a distributed simulation consisting of multiple wrapped instances of ChSystemMulticoreSMC |
| ►Cchrono::ChDistribution | Base class for all random distributions |
| Cchrono::ChConstantDistribution | Class for a distribution with a single 'value' that has probability 1.0 (that is, the distribution has a spike corresponding to 'value' and zero elsewhere) |
| Cchrono::ChContinuumDistribution | Class that can be used to generate sample numbers according to a probability distribution |
| Cchrono::ChDiscreteDistribution | Class that can be used to generate sample numbers according to a discrete probability distribution |
| Cchrono::ChMinMaxDistribution | Class for a distribution with uniform probability between a lower 'min' value and upper 'max' value (that is, the distribution looks like a rectangle) |
| Cchrono::ChNormalDistribution | Class that generates the Gauss normal distribution (the 'bell' distribution) using the Box�Muller transform |
| Cchrono::ChWeibullDistribution | Class that generates the Weibull distribution |
| Cchrono::ChZhangDistribution | Class that generates the Zhang distribution, a modified exponential distribution |
| Cchrono::ChDomainDistributed | This class maps sub-domains of the global simulation domain to each MPI rank |
| ►Cchrono::vehicle::ChDriver | Base class for a vehicle driver system |
| Cchrono::synchrono::ChMultiPathFollowerACCDriver | A driver model that is very similar with ChPathFollowerACCDriver but it uses multiple path steering controller |
| ►Cchrono::vehicle::ChAIDriver | Driver |
| Cchrono::vehicle::AIDriver | Driver |
| Cchrono::vehicle::ChDataDriver | Driver inputs from data file |
| Cchrono::vehicle::ChHumanDriver | Closed-loop path-follower and speed maintaining driver model |
| Cchrono::vehicle::ChIrrGuiDriver | Interactive driver model using keyboard inputs |
| Cchrono::vehicle::ChPathFollowerACCDriver | Closed-loop path-follower driver model |
| Cchrono::vehicle::ChPathFollowerDriver | Closed-loop path-follower driver model |
| Cchrono::vehicle::ChPathFollowerDriverSR | |
| Cchrono::vehicle::ChPathFollowerDriverStanley | |
| Cchrono::vehicle::ChPathFollowerDriverXT | Alternative closed-loop path-follower driver model |
| Cchrono::vehicle::generic::Generic_FuncDriver | Open-loop driver model for use with a generic vehicle |
| ►Cchrono::vehicle::ChDriverSTR | Base class for a suspension test rig driver system |
| Cchrono::vehicle::ChDataDriverSTR | Driver inputs for a suspension test rig from data file |
| Cchrono::vehicle::ChIrrGuiDriverSTR | Irrlicht-based GUI driver for the a suspension test rig |
| ►Cchrono::vehicle::ChDriverTTR | Base class for a track test rig driver system |
| Cchrono::vehicle::ChDataDriverTTR | Driver inputs for a track test rig from data file |
| Cchrono::vehicle::ChIrrGuiDriverTTR | Irrlicht-based GUI driver for the a track test rig.This class implements the functionality required by its base ChDriverSTR class using keyboard inputs |
| Cchrono::vehicle::ChRoadDriverTTR | Driver inputs for a track test rig based on road profile |
| Cchrono::sensor::ChDynamicsManager | Class for managing dynamic sensors |
| ►Cchrono::fea::ChElasticityCosserat | Base interface for elasticity of beam sections of Cosserat type, where xyz force "n" and xyz torque "m" are a 6-dimensional function of generalized strains, "e" traction/shear and "k" curvatures, as: {n,m}=f({e,k}) There are various children classes that implement this function in different ways |
| Cchrono::fea::ChElasticityCosseratAdvancedGeneric | Advanced linear elasticity for a Cosserat section, not assuming homogeneous elasticity |
| Cchrono::fea::ChElasticityCosseratAdvancedGenericFPM | A Cosserat section which allows to input the material fully-populated stiffness matrix(FPM) of cross-section directly |
| Cchrono::fea::ChElasticityCosseratGeneric | Generic linear elasticity for a Cosserat beam using directly a 6x6 matrix [E] as user-input data |
| Cchrono::fea::ChElasticityCosseratMesh | Elasticity for a beam section in 3D, where the section is defined by a mesh of triangles |
| ►Cchrono::fea::ChElasticityCosseratSimple | Simple linear elasticity model for a Cosserat beam, using basic material properties (zz and yy moments of inertia, area, Young modulus, etc.) |
| Cchrono::fea::ChElasticityCosseratAdvanced | Advanced linear elasticity for a Cosserat beam |
| ►Cchrono::fea::ChElasticityKirchhoff | Base interface for elasticity of thin shells (Kirchoff-Love shell theory, without shear effects) to be used in a ChMaterialShellKirchhoff |
| Cchrono::fea::ChElasticityKirchhoffGeneric | Generic linear elasticity for thin shells (Kirchoff-Love shell theory, without shear effects) to be used in a ChMaterialShellKirchhoff |
| Cchrono::fea::ChElasticityKirchhoffIsothropic | Isothropic elasticity for thin shells (Kirchoff-Love shell theory, without shear effects) to be used in a ChMaterialShellKirchhoff |
| Cchrono::fea::ChElasticityKirchhoffOrthotropic | Orthotropic elasticity for thin shells (Kirchoff-Love shell theory, without shear effects) to be used in a ChMaterialShellKirchhoff |
| ►Cchrono::fea::ChElasticityReissner | Base interface for elasticity of 6-field Reissner-Mindlin shells (kinematically-exact shell theory as in Witkowski et al.) to be used in a ChMaterialShellReissner |
| Cchrono::fea::ChElasticityReissnerGeneric | Generic linear elasticity for 6-field Reissner-Mindlin shells (kinematically-exact shell theory as in Witkowski et al.) to be used in a ChMaterialShellReissner |
| Cchrono::fea::ChElasticityReissnerIsothropic | Elasticity of 6-field Reissner-Mindlin shells (kinematically-exact shell theory as in Witkowski et al.) to be used in a ChMaterialShellReissner |
| Cchrono::fea::ChElasticityReissnerOrthotropic | Elasticity of 6-field Reissner-Mindlin shells (kinematically-exact shell theory as in Witkowski et al.) to be used in a ChMaterialShellReissner |
| ►Cchrono::fea::ChElementBase | Base class for all finite elements, that can be used in the ChMesh physics item |
| ►Cchrono::fea::ChElementGeneric | Class for all elements whose stiffness matrix can be seen as a NxN block-matrix to be splitted between N nodes |
| Cchrono::fea::ChElementBar | Simple finite element with two nodes and a bar that connects them |
| ►Cchrono::fea::ChElementBeam | Base class for most structural elements of 'beam' type |
| Cchrono::fea::ChElementBeamANCF_3243 | ANCF beam element with two nodes |
| Cchrono::fea::ChElementBeamANCF_3333 | ANCF beam element with three nodes |
| Cchrono::fea::ChElementBeamEuler | Simple beam element with two nodes and Euler-Bernoulli formulation |
| Cchrono::fea::ChElementBeamIGA | Isogeometric formulation (IGA) of a Cosserat rod, with large displacements, based on the Geometrically Exact Beam Theory |
| ►Cchrono::fea::ChElementBeamTaperedTimoshenko | Classical Timoshenko beam element with two nodes, and tapered sections |
| Cchrono::fea::ChElementBeamTaperedTimoshenkoFPM | For composite beams such as wind turbine blades and helicopter rotor blades, the cross-sectional stiffness properties in axial, shear, bending and torsion directions are coupled with each other, hence the fully-populated matrix(FPM) of cross-sectional stiffness properties is used to describe this complex coupling |
| Cchrono::fea::ChElementCableANCF | Simple beam element with two nodes and ANCF gradient-deficient formulation |
| Cchrono::fea::ChElementHexaANCF_3813 | Hexahedronal solid element with 8 nodes (with EAS) |
| Cchrono::fea::ChElementHexaANCF_3813_9 | Hexahedronal solid element with 8 nodes and a central curvature node |
| Cchrono::fea::ChElementHexaANCF_3843 | ANCF brick element with eight nodes |
| Cchrono::fea::ChElementHexaCorot_20 | Class for FEA elements of hexahedron type (isoparametric 3D bricks) with 20 nodes |
| Cchrono::fea::ChElementHexaCorot_8 | Class for FEA elements of hexahedron type (isoparametric 3D bricks) with 8 nodes |
| ►Cchrono::fea::ChElementShell | Base class for most structural elements of 'shell' type |
| Cchrono::fea::ChElementShellANCF_3423 | ANCF laminated shell element with four nodes |
| Cchrono::fea::ChElementShellANCF_3443 | ANCF shell element with four nodes |
| Cchrono::fea::ChElementShellANCF_3833 | ANCF shell element with four nodes |
| Cchrono::fea::ChElementShellBST | A Kirchhoff-Love thin shell element of triangular shape |
| Cchrono::fea::ChElementShellReissner4 | Laminated thick shell with geometrically exact kinematics, with 4 nodes |
| Cchrono::fea::ChElementSpring | Simple finite element with two nodes and a spring/damper between the two nodes |
| Cchrono::fea::ChElementTetraCorot_10 | Tetrahedron FEA element with 10 nodes |
| Cchrono::fea::ChElementTetraCorot_4 | Tetrahedron FEA element with 4 nodes |
| Cchrono::fea::ChElementTetraCorot_4_P | Tetrahedron FEM element with 4 nodes for scalar fields (for Poisson-like problems) |
| ►Cchrono::fea::ChElementCorotational | Class for corotational elements (elements with rotation matrices that follow the global motion of the element) |
| Cchrono::fea::ChElementBeamEuler | Simple beam element with two nodes and Euler-Bernoulli formulation |
| Cchrono::fea::ChElementBeamTaperedTimoshenko | Classical Timoshenko beam element with two nodes, and tapered sections |
| Cchrono::fea::ChElementHexaCorot_20 | Class for FEA elements of hexahedron type (isoparametric 3D bricks) with 20 nodes |
| Cchrono::fea::ChElementHexaCorot_8 | Class for FEA elements of hexahedron type (isoparametric 3D bricks) with 8 nodes |
| Cchrono::fea::ChElementTetraCorot_10 | Tetrahedron FEA element with 10 nodes |
| Cchrono::fea::ChElementTetraCorot_4 | Tetrahedron FEA element with 4 nodes |
| Cchrono::fea::ChElementTetraCorot_4_P | Tetrahedron FEM element with 4 nodes for scalar fields (for Poisson-like problems) |
| ►Cchrono::fea::ChElementHexahedron | Base class for a FEA element with hexahedral shape |
| Cchrono::fea::ChElementHexaANCF_3813 | Hexahedronal solid element with 8 nodes (with EAS) |
| Cchrono::fea::ChElementHexaANCF_3813_9 | Hexahedronal solid element with 8 nodes and a central curvature node |
| Cchrono::fea::ChElementHexaANCF_3843 | ANCF brick element with eight nodes |
| Cchrono::fea::ChElementHexaCorot_20 | Class for FEA elements of hexahedron type (isoparametric 3D bricks) with 20 nodes |
| Cchrono::fea::ChElementHexaCorot_8 | Class for FEA elements of hexahedron type (isoparametric 3D bricks) with 8 nodes |
| ►Cchrono::fea::ChElementTetrahedron | Base class for a FEA element with tetrahedral shape |
| Cchrono::fea::ChElementTetraCorot_10 | Tetrahedron FEA element with 10 nodes |
| Cchrono::fea::ChElementTetraCorot_4 | Tetrahedron FEA element with 4 nodes |
| Cchrono::ChEnumMapperBase | Class for mapping enums to ChNameValue pairs that contain a 'readable' ascii string of the selected enum |
| ►Cchrono::ChException | Class for exceptions for throw() catch() mechanism |
| Cchrono::ChExceptionArchive | Macro to create a ChDetect_ArchiveINconstructor that can be used in templates, to select which specialized template to use |
| Cchrono::cosimul::ChExceptionSocket | Class for exceptions that are thrown by TCP socket connections, used for example when connecting with other sw for cosimulation |
| Cchrono::fea::ChExtruderBeamEuler | Class for an object that continuously extrude a beam (composed of ChElementBeamEuler elements) with prescribed velocity |
| Cchrono::fea::ChExtruderBeamIGA | Class for an object that continuously extrude a beam (composed of ChElementBeamIGA elements) with prescribed velocity |
| Cchrono::ChFile_ps_axis_setting | Class for settings of an axis (x or y, or t) of a 2D plotting of a function on a EPS file |
| Cchrono::ChFile_ps_color | Class for RGB color for a PostScript item (line, circle, etc) |
| Cchrono::ChFile_ps_graph_setting | Class for generic settings of a 2D plotting of a function on a EPS file |
| ►Cchrono::sensor::ChFilter | Base class for all filters that can be applied to a sensor after initial rendering |
| Cchrono::sensor::ChFilterAccelerometerUpdate | Class for generating IMU data |
| Cchrono::sensor::ChFilterAccess< BufferType, UserBufferType > | Filter for accessing data from the sensor |
| Cchrono::sensor::ChFilterCameraNoiseConstNormal | A filter that adds Gaussian noise across an image with constant mean and standard deviation |
| Cchrono::sensor::ChFilterCameraNoisePixDep | A filter that adds pixel dependent gaussian noise across an image. Method summarized in paper: () |
| Cchrono::sensor::ChFilterGPSUpdate | Class for generating GPS data for a GPS sensor |
| Cchrono::sensor::ChFilterGrayscale | A filter that, when applied to a sensor, changes the RGB buffer to grayscale |
| Cchrono::sensor::ChFilterGyroscopeUpdate | Class for generating IMU data |
| Cchrono::sensor::ChFilterImageHalf4ToRGBA8 | A filter that converts RGBA Float4 to RGBA8 |
| Cchrono::sensor::ChFilterImageResize | A filter that, when applied to a sensor, resizes the image to the specified dimensions |
| Cchrono::sensor::ChFilterImgAlias | A filter that, when applied to a sensor, reduces the resolution for antialiasing |
| Cchrono::sensor::ChFilterLidarNoiseXYZI | A filter that adds noise based on depth and intensity given data in point cloud format |
| Cchrono::sensor::ChFilterMagnetometerUpdate | Class for generating IMU data |
| Cchrono::sensor::ChFilterONNX | A filter that processes data through a pre-trained neural network, based on ONNX format |
| Cchrono::sensor::ChFilterOptixRender | A filter that generates data for a ChOptixSensor |
| Cchrono::sensor::ChFilterPCfromDepth | A filter that, when applied to a sensor, generates point cloud data from depth values |
| Cchrono::sensor::ChFilterRadarProcess | A filter that, when applied to a sensor, converts the depth values to pointcloud, clusters, and calculates velocity and centroid |
| Cchrono::sensor::ChFilterRadarSavePC | A filter that, when applied to a sensor, saves point cloud data |
| Cchrono::sensor::ChFilterSave | A filter that, when applied to a sensor, saves the data as an image |
| Cchrono::sensor::ChFilterSavePtCloud | A filter that, when applied to a sensor, saves point cloud data |
| Cchrono::sensor::ChFilterUFF | A filter that processes data through a pre-trained neural network, based on UFF format |
| ►Cchrono::sensor::ChFilterVisualize | A filter that, when applied to a sensor, creates a GUI window to visualize the sensor (using GLFW) |
| Cchrono::sensor::ChFilterVisualizePointCloud | A filter that, when applied to a sensor, creates a GUI window to visualize the sensor (using GLFW) |
| Cchrono::ChFmMatrix34< Real > | Special MBD 3x4 matrix [Fm(q)], as in [Fp(q)] * [Fm(q)]' = [A(q)] |
| Cchrono::ChFpMatrix34< Real > | Special MBD 3x4 matrix [Fp(q)], as in [Fp(q)] * [Fm(q)]' = [A(q)] |
| ►Cchrono::ChFrame< Real > | ChFrame: a class for coordinate systems in 3D space |
| Cchrono::ChFrameMoving< Real > | ChFrameMoving: a class for coordinate systems in 3D space |
| ►Cchrono::ChFrame< double > | |
| ►Cchrono::ChFrameMoving< double > | |
| ►Cchrono::ChBodyFrame | Class for objects that represent moving frames in space and contain state variables |
| ►Cchrono::ChBody | Class for rigid bodies |
| ►Cchrono::ChBodyAuxRef | Class for rigid bodies with an auxiliary reference frame |
| Cchrono::cascade::ChBodyEasyCascade | Easy-to-use class for quick creation of rigid bodies with a OpenCASCADE shape |
| Cchrono::cascade::ChBodyEasyCascadeProfile | Easy-to-use class for quick creation of flat "2D" rigid bodies given a 2D 'wire' profile and a thickness |
| Cchrono::ChBodyEasyConvexHullAuxRef | Class for quick creation of rigid bodies with a convex hull shape, with a reference frame distinct from the centroidal frame |
| Cchrono::ChBodyEasyMesh | Class for quick creation of rigid bodies with a mesh shape, with a reference frame distinct from the centroidal frame |
| Cchrono::ChBodyEasyBox | Class for quick creation of rigid bodies with a box shape |
| Cchrono::ChBodyEasyClusterOfSpheres | Class for quick creation of rigid bodies with a shape made of a cluster of spheres |
| Cchrono::ChBodyEasyConvexHull | Class for quick creation of rigid bodies with a convex hull shape |
| Cchrono::ChBodyEasyCylinder | Class for quick creation of rigid bodies with a cylinder shape |
| Cchrono::ChBodyEasyEllipsoid | Class for quick creation of rigid bodies with an ellipsoid shape |
| Cchrono::ChBodyEasySphere | Class for quick creation of rigid bodies with a spherical shape |
| Cchrono::fea::ChNodeFEAxyzrot | Class for a generic ED finite element node, with x,y,z displacement and a 3D rotation |
| Cchrono::ChMarker | Markers are auxiliary reference frames which belong to rigid bodies and move together with them |
| ►Cchrono::ChParticleBase | Base class for a single particle to be used in ChIndexedParticles containers |
| Cchrono::ChAparticle | Class for a single particle clone in the ChParticlesClones cluster |
| Cchrono::ChFseqNode | Node for the list of functions in a ChFunction_Sequence object |
| ►Cchrono::fsi::ChFsiGeneral | Class for FSI properties and functions |
| Cchrono::fsi::ChBce | Base class for processing boundary condition enforcing (BCE) particle forces in an FSI system |
| Cchrono::fsi::ChCollisionSystemFsi | Base class for processing proximity computation in an FSI system |
| Cchrono::fsi::ChFluidDynamics | Class to represent the fluid/granular dynamics system |
| ►Cchrono::fsi::ChFsiForce | Base class to calculate force between SPH particles |
| Cchrono::fsi::ChFsiForceExplicitSPH | Child class of ChFsiForce |
| Cchrono::fsi::ChFsiForceI2SPH | Derived class of ChFsiForce that implements the I2SPH method |
| Cchrono::fsi::ChFsiForceIISPH | Derived class of ChFsiForce that implements the IISPH method |
| Cchrono::fsi::ChFsiInterface | Base class for processing the interface between Chrono and FSI modules |
| Cchrono::fsi::ChSystemFsi_impl | Data related function implementations for FSI system |
| ►Cchrono::fsi::ChFsiLinearSolver | Base class for solving linear systems on GPUs |
| Cchrono::fsi::ChFsiLinearSolverBiCGStab | BiCG-Stab iterative linear solver |
| Cchrono::fsi::ChFsiLinearSolverGMRES | GMRES iterative linear solver |
| ►Cchrono::ChFunction | Interface base class for scalar functions of the type: y= f(x) |
| Cchrono::ChFunction_Const | Constant function: y = C |
| Cchrono::ChFunction_ConstAcc | Constant acceleration function: |
| Cchrono::ChFunction_Derive | Derivative of a function: y = df/dx |
| Cchrono::ChFunction_Fillet3 | Cubic fillet function (cubic poly with C0 C1 boundary conditions) |
| Cchrono::ChFunction_Integrate | Integral of a function: y = int{ f(x) dx |
| Cchrono::ChFunction_Lambda< LAMBDA > | |
| Cchrono::ChFunction_Matlab | Matlab function: y = matlab evaluation of function y=f(x) |
| Cchrono::ChFunction_Mirror | Mirror function: y = __/\__ Mirrors a function about a vertical axis |
| Cchrono::ChFunction_Mocap | Motion capture (sample) function: y = (linear interpolated array of samples) |
| Cchrono::ChFunction_Noise | Noise function: y = multi-octave noise with cubic interpolation |
| Cchrono::ChFunction_Operation | Operation between functions: |
| Cchrono::ChFunction_Oscilloscope | Oscilloscope function |
| Cchrono::ChFunction_Poly | POLYNOMIAL FUNCTION: y = a + bx + cx^2 + dx^3 + ... |
| Cchrono::ChFunction_Poly345 | Ramp function, as a 3-4-5 polynomial: |
| Cchrono::ChFunction_Ramp | Linear function (like a straight ramp): y = y0 + x * speed |
| Cchrono::ChFunction_Recorder | Recorder function: |
| Cchrono::ChFunction_Repeat | Repeat function: y = __/__/__/ |
| Cchrono::ChFunction_Sequence | Sequence function: y = sequence_of_functions(f1(y), f2(y), f3(y)) All other function types can be inserted into this |
| ►Cchrono::ChFunction_Setpoint | Function that returns Y from an externally-provided value, as a ZOH (zero order hold) block |
| Cchrono::ChFunction_SetpointCallback | Interface for functions that uses a callback to return a Y value, as a ZOH (zero order hold) block |
| Cchrono::ChFunction_Sigma | Sigma function: y = polynomial smooth ramp |
| Cchrono::ChFunction_Sine | Sine function y = sin (phase + w*x ) where w=2*PI*freq |
| ►Cchrono::ChFunctionPosition | Interface base class for scalar->vector functions of the type: |
| Cchrono::ChFunctionPosition_line | A motion function p=f(s) where p(t) is defined with a ChLine geometry object, ex |
| Cchrono::ChFunctionPosition_setpoint | A motion function p=f(s) where p(t) is an externally-provided sample, as a ZOH (zero order hold) of FOH (first order) |
| Cchrono::ChFunctionPosition_XYZfunctions | A motion function p=f(s) where p(t) is defined with three independent ChFunction objects, each for px, py, pz component |
| ►Cchrono::ChFunctionRotation | Interface base class for scalar->quaternion functions of the type: |
| Cchrono::ChFunctionRotation_ABCfunctions | A rotation function q=f(s) where q(s) is defined with three ChFunction objects, each per an an angle in an intrinsic triplets of angles (ex |
| Cchrono::ChFunctionRotation_axis | A rotation function q=f(s) where q(s) is defined with axis V and angle alpha, assuming fixed axis of rotation V and a angle of rotation alpha about that axis, expressed with a ChFunction object alpha=alpha(s) |
| Cchrono::ChFunctionRotation_setpoint | A rotation q=f(s) provided from a rotation sample, continuously updated by the user, behaving as a ZOH (zero order hold) of FOH (first order) |
| Cchrono::ChFunctionRotation_spline | A rotation function q=f(s) that interpolates n rotations using a "quaternion spline" of generic order |
| Cchrono::ChFunctionRotation_SQUAD | A rotation function q=f(s) that interpolates n rotations using a SQUAD spherical quadrangle interpolation between quaternions |
| Cchrono::ChFunctorArchiveIn | Functor to call the ArchiveIN function for unrelated classes that implemented them |
| ►Cchrono::ChFx | Abstract interface class for math functions of the type A=f(B) where A and B are vectors of real values (to the limit, also single scalar values) |
| Cchrono::ChFxCfunction | Class for A=f(B) math functions, where the function is defined by wrapping a C function of the 'old' type, i.e |
| Cchrono::ChFxCfunctionS | Class for A=f(B) math functions, where the function is defined by wrapping a C function of the 'old' type, i.e |
| Cchrono::fea::ChGaussIntegrationRule | Class for the management of the Gauss Quadrature in 1D, 2D or 3D space |
| Cchrono::fea::ChGaussPoint | Class for a Gauss point, that has a position (1D-3D) and a weight |
| Cchrono::ChGenotype | Class for individuals of the population; for the ChOptimizerGenetic optimization engine |
| ►Cchrono::geometry::ChGeometry | Base class for geometric objects used for collisions and visualization |
| Cchrono::geometry::ChCapsule | A capsule geometric object for collision and visualization |
| Cchrono::geometry::ChCone | A conical geometric object for collisions and visualization |
| Cchrono::geometry::ChCylinder | A cylindrical geometric object for collisions and visualization |
| Cchrono::geometry::ChEllipsoid | An ellipsoid geometric object for collisions and such |
| ►Cchrono::geometry::ChLine | Base class for all geometric objects representing lines in 3D space |
| Cchrono::geometry::ChLineArc | Geometric object representing an arc or a circle in 3D space |
| Cchrono::geometry::ChLineBezier | Geometric object representing a piecewise cubic Bezier curve in 3D |
| Cchrono::geometry::ChLineBspline | Geometric object representing a Bspline spline |
| Cchrono::geometry::ChLineCam | Geometric object describing the profile of a cam |
| Cchrono::geometry::ChLineNurbs | Geometric object representing a NURBS spline |
| Cchrono::geometry::ChLinePath | Geometric object representing an sequence of other ChLine objects, The ChLine objects are assumed to be properly concatenated and to have C0 continuity |
| Cchrono::geometry::ChLinePoly | Geometric object representing a polygonal line in 3D space, controlled by control points |
| Cchrono::geometry::ChLineSegment | Geometric object representing a segment in 3D space with two end points |
| Cchrono::geometry::ChRoundedCone | A rounded cone (sphere-swept cone) geometric object for collisions and visualization |
| Cchrono::geometry::ChRoundedCylinder | A rounded cylinder (sphere-swept cylinder) geometric object for collision and visualization |
| Cchrono::geometry::ChSphere | A spherical geometric object for collisions and visualization |
| ►Cchrono::geometry::ChSurface | Base class for all geometric objects representing bi-parametric surfaces in 3D space |
| Cchrono::geometry::ChSurfaceNurbs | Geometric object representing a NURBS surface |
| Cchrono::geometry::ChTriangle | A triangle geometric shape for collisions and visualization |
| ►Cchrono::geometry::ChTriangleMesh | Base class for triangle meshes |
| Cchrono::geometry::ChTriangleMeshConnected | A triangle mesh with connectivity info: vertices can be shared between faces |
| Cchrono::geometry::ChTriangleMeshSoup | A basic triangle mesh: just a list of triangles (no edge connectivity info) |
| ►Cchrono::geometry::ChVolume | Base class for all geometric objects representing tri-parametric surfaces in 3D space |
| Cchrono::geometry::ChBox | A box geometric object for collisions and visualization |
| Cchrono::geometry::ChRoundedBox | A rounded box (sphere-swept box) geometric object for collisions and visualization |
| Cchrono::ChGlMatrix34< Real > | Special MBD 3x4 matrix [Gl(q)], as in local angular speed conversion |
| Cchrono::postprocess::ChGnuPlot | Class for lotting data with GNUplot |
| Cchrono::sensor::ChGPSSensor | GPS class |
| Cchrono::gpu::ChGpuSimulationParameters | Structure with Chrono::Gpu simulation parameters |
| Cchrono::gpu::ChGpuVisualization | Run-time visualization support for Chrono::Gpu systems |
| Cchrono::ChGwMatrix34< Real > | Special MBD 3x4 matrix [Gw(q)], as in absolute angular speed conversion |
| Cchrono::sensor::ChGyroscopeSensor | Gyroscope class |
| Cchrono::cosimul::ChHostInfo | Class for storing information about a TCP host in socket communication, ex with an IP address |
| ►Cchrono::ChImplicitTimestepper | Base class for implicit solvers (double inheritance) |
| ►Cchrono::ChImplicitIterativeTimestepper | Base properties for implicit solvers |
| Cchrono::ChTimestepperEulerImplicit | Performs a step of Euler implicit for II order systems |
| Cchrono::ChTimestepperHHT | Implementation of the HHT implicit integrator for II order systems |
| Cchrono::ChTimestepperNewmark | Performs a step of Newmark constrained implicit for II order DAE systems |
| Cchrono::ChTimestepperTrapezoidal | Performs a step of trapezoidal implicit for II order systems |
| Cchrono::ChTimestepperTrapezoidalLinearized | Performs a step of trapezoidal implicit linearized for II order systems |
| Cchrono::ChTimestepperTrapezoidalLinearized2 | Performs a step of trapezoidal implicit linearized for II order systems |
| Cchrono::ChTimestepperEulerImplicitLinearized | Performs a step of Euler implicit for II order systems using the Anitescu/Stewart/Trinkle single-iteration method, that is a bit like an implicit Euler where one performs only the first Newton corrector iteration |
| Cchrono::ChTimestepperEulerImplicitProjected | Performs a step of Euler implicit for II order systems using a semi implicit Euler without constraint stabilization, followed by a projection |
| ►Cchrono::fea::ChInertiaCosserat | Base class for inertial properties (mass, moment of inertia) of beam sections of Cosserat type |
| ►Cchrono::fea::ChInertiaCosseratAdvanced | Inertia properties of a beam of Cosserat type, not necessarily of uniform density, from the following information that allows the center of mass to be offset respect to the beam centerline: |
| Cchrono::fea::ChInertiaCosseratMassref | Inertia properties of a beam of Cosserat type, not necessarily of uniform density, from the following information that allows the center of mass to be offset respect to the beam centerline: |
| Cchrono::fea::ChInertiaCosseratSimple | Inertia properties of a beam of Cosserat type, defined from an uniform density [kg/m^3], and the following geometric information: |
| Cchrono::ChInertiaUtils | Class with some static functions that can be used to make computations with inertia tensors |
| ►Cchrono::ChIntegrable | Interface class for all objects that support time integration |
| ►Cchrono::ChIntegrableIIorder | Special subcase: II-order differential system |
| ►Cchrono::ChSystem | Physical system |
| ►Cchrono::ChSystemMulticore | Base class for Chrono::Multicore systems |
| Cchrono::ChSystemMulticoreNSC | Multicore system using non-smooth contact (complementarity-based) method |
| ►Cchrono::ChSystemMulticoreSMC | Multicore system using smooth contact (penalty-based) method |
| Cchrono::ChSystemDistributed | This is the main user interface for Chrono::Distributed Add bodies and set all settings through the system |
| Cchrono::ChSystemNSC | Class for a physical system in which contact is modeled using a non-smooth (complementarity-based) method |
| Cchrono::ChSystemSMC | Class for a physical system in which contact is modeled using a smooth (penalty-based) method |
| Cchrono::ChIntegrable1D< T > | Base class for 1D integrand T=f(x) to be used in ChQuadrature |
| Cchrono::ChIntegrable1D< ChMatrixNM< double, 12, 12 > > | |
| Cchrono::ChIntegrable2D< T > | As ChIntegrable1D, but for 2D integrand T=f(x,y) to be used in ChQuadrature |
| Cchrono::ChIntegrable3D< T > | As ChIntegrable1D, but for 3D integrand T=f(x,y,z) to be used in ChQuadrature |
| Cchrono::ChIntegrable3D< ChElementShellANCF_3423::VectorN > | |
| Cchrono::ChIntegrable3D< ChMatrixNM< double, 24, 24 > > | |
| Cchrono::ChIntegrable3D< ChMatrixNM< double, 33, 33 > > | |
| Cchrono::ChIntegrable3D< ChVectorN< double, 11 > > | |
| Cchrono::ChIntegrable3D< ChVectorN< double, 33 > > | |
| Cchrono::ChIntegrable3D< ChVectorN< double, 330 > > | |
| Cchrono::ChIntegrable3D< ChVectorN< double, 54 > > | |
| Cchrono::ChIntegrable3D< ChVectorN< double, 696 > > | |
| Cchrono::ChIntegrable3D< ChVectorN< double, 8 > > | |
| Cchrono::ChIntegrable3D< ChVectorN< double, 906 > > | |
| ►Cchrono::irrlicht::ChIrrAppInterface | Class to add some GUI to Irrlicht + ChronoEngine applications |
| ►Cchrono::irrlicht::ChIrrApp | Class to add some GUI to Irrlicht+ChronoEngine applications |
| Cchrono::robosimian::RoboSimianIrrApp | Customized Chrono Irrlicht application for RoboSimian visualization |
| ►Cchrono::vehicle::ChVehicleIrrApp | Custom event receiver for chase-cam control |
| Cchrono::vehicle::ChTrackedVehicleIrrApp | Customized Chrono Irrlicht application for tracked vehicle visualization |
| Cchrono::vehicle::ChTrackTestRigIrrApp | Customized Chrono Irrlicht application for track test rig visualization |
| Cchrono::vehicle::ChWheeledVehicleIrrApp | Customized Chrono Irrlicht application for wheeled vehicle visualization |
| Cchrono::irrlicht::ChIrrAssetConverter | Class with static functions which allow creation of Irrlicht frequent 'scene nodes' like lights, camera, sky box etc |
| Cirr::scene::ChIrrCascadeMeshTools | Tools to convert an OpenCASCADE shapes into 'Irrlicht' triangle meshes |
| Cchrono::irrlicht::ChIrrNode | Class for Irrlicht visualization |
| Cchrono::irrlicht::ChIrrNodeProxyToAsset | Class for proxy to ChAsset, it is a node with mesh in Irrlicht system and a shared pointer to the ChAsset to whom it corresponds |
| Cchrono::utils::ChISO2631_1_Wd | Combined filter Wd |
| Cchrono::utils::ChISO2631_1_Wf | Combined filter Wf |
| Cchrono::utils::ChISO2631_1_Wk | Combined filter Wk |
| Cchrono::utils::ChISO2631_5_Wxy | ISO2631-5 weighting filter for shock like signal in horizontal direction |
| Cchrono::utils::ChISO2631_5_Wz | ISO2631-5 weighting filter for shock like signal in vertical direction |
| Cchrono::utils::ChISO2631_Shock_SeatCushionLogger | Easy to use class for evaluation of ISO 2361-5 shock load on sitting vehicle occupants |
| Cchrono::utils::ChISO2631_Vibration_SeatCushionLogger | Easy to use class for evaluation of ISO 2361-1 vibration load on sitting vehicle occupants Input: 3 seat accelerations x,y,z in [m/s^2] |
| ►Cchrono::ChIterativeSolver | Base class for iterative solvers |
| ►Cchrono::ChIterativeSolverLS | Base class for Chrono solvers based on Eigen iterative linear solvers |
| Cchrono::ChSolverBiCGSTAB | BiCGSTAB iterative solver |
| Cchrono::ChSolverGMRES | GMRES iterative solver |
| Cchrono::ChSolverMINRES | MINRES iterative solver |
| ►Cchrono::ChIterativeSolverVI | Base class for iterative solvers aimed at solving complementarity problems arising from QP optimization problems |
| ►Cchrono::ChIterativeSolverMulticore | Base class for all iterative solvers |
| Cchrono::ChIterativeSolverMulticoreNSC | Wrapper class for all complementarity solvers |
| Cchrono::ChIterativeSolverMulticoreSMC | Iterative solver for SMC (penalty-based) problems |
| Cchrono::ChSolverADMM | An iterative solver based on modified version of ADMM Alternating Direction Method of Multipliers |
| Cchrono::ChSolverAPGD | An iterative solver based on Nesterov's Projected Gradient Descent |
| Cchrono::ChSolverBB | An iterative solver based on modified Krylov iteration of spectral projected gradients with Barzilai-Borwein |
| Cchrono::ChSolverPJacobi | An iterative solver for VI based on projective fixed point method (projected Jacobi) |
| Cchrono::ChSolverPMINRES | An iterative solver based on modified Krylov iteration of MINRES type with gradient projections (similar to nonlinear CG with Polyak-Ribiere) |
| Cchrono::ChSolverPSOR | An iterative solver based on projective fixed point method, with overrelaxation and immediate variable update as in SOR methods |
| Cchrono::ChSolverPSSOR | An iterative solver based on symmetric projective fixed point method, with overrelaxation and immediate variable update as in SSOR methods |
| ►Cchrono::ChKblock | Base class for representing items which introduce block-sparse matrices, that is blocks that connect some 'variables' and build a matrix K in a sparse variational inequality VI(Z*x-d,K): |
| Cchrono::ChKblockGeneric | Class that represent nxn sparse blocks to put into K global matrix, that is blocks that connect N 'variables' and build a matrix K in a sparse variational inequality VI(Z*x-d,K): |
| Cchrono::ChLinkForce | Class for forces in link joints of type ChLinkLock |
| Cchrono::ChLinkLimit | Class for limits in ChLinkLock joints |
| ►Cchrono::ChLinkMask | Mask structure for N scalar constraint equations between two bodies |
| Cchrono::ChLinkMaskLF | Specialized ChLinkMask class, for constraint equations of the ChLinkLock link |
| Cchrono::ChList< dt > | Class for linked list |
| ►Cchrono::ChLoadable | Interface for objects that can be subject to loads (forces) Forces can be distributed on UV surfaces, or lines, etc.,so look also the more detailed children classes |
| ►Cchrono::ChLoadableU | Interface for objects that can be subject to line loads, distributed along U coordinate of the object |
| Cchrono::fea::ChElementBeamANCF_3243 | ANCF beam element with two nodes |
| Cchrono::fea::ChElementBeamANCF_3333 | ANCF beam element with three nodes |
| Cchrono::fea::ChElementBeamEuler | Simple beam element with two nodes and Euler-Bernoulli formulation |
| Cchrono::fea::ChElementBeamIGA | Isogeometric formulation (IGA) of a Cosserat rod, with large displacements, based on the Geometrically Exact Beam Theory |
| Cchrono::fea::ChElementBeamTaperedTimoshenko | Classical Timoshenko beam element with two nodes, and tapered sections |
| Cchrono::fea::ChElementCableANCF | Simple beam element with two nodes and ANCF gradient-deficient formulation |
| ►Cchrono::ChLoadableUV | Interface for objects that can be subject to area loads, distributed along UV coordinates of the object |
| Cchrono::fea::ChContactTriangleXYZ | Contact element of triangular type |
| Cchrono::fea::ChContactTriangleXYZROT | Contact element of triangular type - version for triangles where the nodes are of ChNodeFEAxyzrot type |
| Cchrono::fea::ChElementShellANCF_3423 | ANCF laminated shell element with four nodes |
| Cchrono::fea::ChElementShellANCF_3443 | ANCF shell element with four nodes |
| Cchrono::fea::ChElementShellANCF_3833 | ANCF shell element with four nodes |
| Cchrono::fea::ChElementShellBST | A Kirchhoff-Love thin shell element of triangular shape |
| Cchrono::fea::ChElementShellReissner4 | Laminated thick shell with geometrically exact kinematics, with 4 nodes |
| Cchrono::fea::ChHexahedronFace | Face of a hexahedron-shaped element |
| Cchrono::fea::ChTetrahedronFace | Face of a tetrahedron-shaped element |
| ►Cchrono::ChLoadableUVW | Interface for objects that can be subject to volume loads, distributed along UVW coordinates of the object |
| Cchrono::ChBody | Class for rigid bodies |
| ►Cchrono::ChNodeXYZ | Class for a single 'point' node, that has 3 DOF degrees of freedom and a mass |
| Cchrono::ChNodeSPH | Class for a single node in the SPH cluster |
| ►Cchrono::fea::ChNodeFEAxyz | Class for a generic 3D finite element node, with x,y,z displacement |
| ►Cchrono::fea::ChNodeFEAxyzD | Class for a generic 3D finite element node, with x,y,z displacement and a direction |
| ►Cchrono::fea::ChNodeFEAxyzDD | Class for a generic 3D finite element node, with x,y,z displacement, direction, and one curvature vector OR additional direction |
| Cchrono::fea::ChNodeFEAxyzDDD | Class for a generic 3D finite element node, with x,y,z displacement, and 3 position vector gradients For a Fully Parameterized ANCF element: The variable D represents the position vector gradient with respect to the 1st element coordinate line The variable DD represents the position vector gradient with respect to the 2nd element coordinate line The variable DDD represents the position vector gradient with respect to the 3rd element coordinate line |
| Cchrono::fea::ChNodeMeshless | Class for a single node in the meshless FEA cluster |
| Cchrono::fea::ChElementBeamANCF_3243 | ANCF beam element with two nodes |
| Cchrono::fea::ChElementBeamANCF_3333 | ANCF beam element with three nodes |
| Cchrono::fea::ChElementBeamEuler | Simple beam element with two nodes and Euler-Bernoulli formulation |
| Cchrono::fea::ChElementBeamIGA | Isogeometric formulation (IGA) of a Cosserat rod, with large displacements, based on the Geometrically Exact Beam Theory |
| Cchrono::fea::ChElementBeamTaperedTimoshenko | Classical Timoshenko beam element with two nodes, and tapered sections |
| Cchrono::fea::ChElementCableANCF | Simple beam element with two nodes and ANCF gradient-deficient formulation |
| Cchrono::fea::ChElementHexaANCF_3813 | Hexahedronal solid element with 8 nodes (with EAS) |
| Cchrono::fea::ChElementHexaANCF_3813_9 | Hexahedronal solid element with 8 nodes and a central curvature node |
| Cchrono::fea::ChElementHexaANCF_3843 | ANCF brick element with eight nodes |
| Cchrono::fea::ChElementHexaCorot_20 | Class for FEA elements of hexahedron type (isoparametric 3D bricks) with 20 nodes |
| Cchrono::fea::ChElementHexaCorot_8 | Class for FEA elements of hexahedron type (isoparametric 3D bricks) with 8 nodes |
| Cchrono::fea::ChElementShellANCF_3423 | ANCF laminated shell element with four nodes |
| Cchrono::fea::ChElementShellANCF_3443 | ANCF shell element with four nodes |
| Cchrono::fea::ChElementShellANCF_3833 | ANCF shell element with four nodes |
| Cchrono::fea::ChElementShellBST | A Kirchhoff-Love thin shell element of triangular shape |
| Cchrono::fea::ChElementShellReissner4 | Laminated thick shell with geometrically exact kinematics, with 4 nodes |
| Cchrono::fea::ChElementTetraCorot_10 | Tetrahedron FEA element with 10 nodes |
| Cchrono::fea::ChElementTetraCorot_4 | Tetrahedron FEA element with 4 nodes |
| Cchrono::fea::ChElementTetraCorot_4_P | Tetrahedron FEM element with 4 nodes for scalar fields (for Poisson-like problems) |
| Cchrono::fea::ChNodeFEAxyzrot | Class for a generic ED finite element node, with x,y,z displacement and a 3D rotation |
| Cchrono::ChShaft | Class for one-degree-of-freedom mechanical parts with associated inertia (mass, or J moment of inertial for rotating parts) |
| ►Cchrono::ChLoader | Class for loads applied to a single ChLoadable object |
| ►Cchrono::ChLoaderU | Class of loaders for ChLoadableU objects (which support line loads) |
| ►Cchrono::ChLoaderUatomic | Class of loaders for ChLoadableU objects (which support line loads) of atomic type, that is, with a concentrated load in a point Pu |
| Cchrono::fea::ChLoaderBeamWrench | Atomic wrench |
| ►Cchrono::ChLoaderUdistributed | Class of loaders for ChLoadableU objects (which support line loads), for loads of distributed type, so these loads will undergo Gauss quadrature to integrate them in the surface |
| Cchrono::fea::ChLoaderBeamWrenchDistributed | Distributed constant wrench |
| ►Cchrono::ChLoaderUV | Class of loaders for ChLoadableUV objects (which support surface loads) |
| ►Cchrono::ChLoaderUVatomic | Class of loaders for ChLoadableUV objects (which support surface loads) of atomic type, that is, with a concentrated load in a point Pu,Pv |
| Cchrono::ChLoaderForceOnSurface | A very simple surface loader: a constant force vector, applied to a point on a u,v surface |
| ►Cchrono::ChLoaderUVdistributed | Class of loaders for ChLoadableUV objects (which support surface loads), for loads of distributed type, so these loads will undergo Gauss quadrature to integrate them in the surface |
| Cchrono::ChLoaderPressure | A very usual type of surface loader: the constant pressure load, a 3D per-area force that is aligned to the surface normal |
| ►Cchrono::ChLoaderUVW | Class of loaders for ChLoadableUVW objects (which support volume loads) |
| ►Cchrono::ChLoaderUVWatomic | Class of loaders for ChLoadableUVW objects (which support volume loads) of atomic type, that is, with a concentrated load in a point Pu,Pv,Pz |
| Cchrono::ChLoaderXYZnode | FORCE AT XYZ NODE Loader for a constant force applied at a XYZ node |
| ►Cchrono::ChLoaderUVWdistributed | Class of loaders for ChLoadableUVW objects (which support volume loads), for loads of distributed type, so these loads will undergo Gauss quadrature to integrate them in the volume |
| Cchrono::ChLoaderGravity | A very usual type of volume loader: the constant gravitational load on Y |
| Cchrono::ChLoadJacobians | Utility class for storing jacobian matrices |
| Cchrono::sensor::ChMagnetometerSensor | Magnetometer class |
| Cchrono::ChMaterial | Visualization material properties |
| Cchrono::fea::ChMaterialBeamANCF | Definition of materials to be used for ANCF beams utilizing the Enhanced Continuum Mechanics based method |
| ►Cchrono::ChMaterialComposite | Base class for composite material for a contact pair |
| Cchrono::ChMaterialCompositeNSC | Composite NSC material data for a contact pair |
| Cchrono::ChMaterialCompositeSMC | Composite SMC material data for a contact pair |
| Cchrono::ChMaterialCompositionStrategy | Base class for material composition strategy |
| Cchrono::fea::ChMaterialHexaANCF | Definition of materials to be used for ANCF brick elements |
| Cchrono::fea::ChMaterialShellANCF | Definition of materials to be used for ANCF shells |
| Cchrono::fea::ChMaterialShellKirchhoff | Material for a single layer of a thin shell (Kirchoff-Love shell theory, i.e |
| ►Cchrono::fea::ChMaterialShellReissner | Material for a single layer of a 6-field Reissner-Mindlin shells (kinematically-exact shell theory as in Witkowski et al) |
| Cchrono::fea::ChMaterialShellReissnerIsothropic | For backward compatibility only! New approach: create a ChElasticityReissnerOrthotropic and create a ChMaterialShellReissner by passing the elasticity as a parameter |
| Cchrono::fea::ChMaterialShellReissnerOrthotropic | For backward compatibility only! New approach: create a ChElasticityReissnerOrthotropic and create a ChMaterialShellReissner by passing the elasticity as a parameter |
| ►Cchrono::ChMaterialSurface | Base class for specifying material properties for contact force generation |
| Cchrono::ChMaterialSurfaceNSC | Material data for a collision surface for use with non-smooth (complementarity) contact method |
| Cchrono::ChMaterialSurfaceSMC | Material data for a collision surface for use with smooth (penalty) contact method |
| Cchrono::ChMatrix33< Real > | Definition of a 3x3 fixed size matrix to represent 3D rotations and inertia tensors |
| Cchrono::ChMatrix33< double > | |
| Cchrono::fea::ChMatrixCorotation | Perform a corotation (warping) of a K matrix by pre- or post- multiplying it with a C matrix that has 3x3 rotation matrices R as diagonal blocks, so that C*K means: |
| Cchrono::fea::ChMeshExporter | Collection of mesh file writer utilities |
| Cchrono::fea::ChMeshFileLoader | Collection of mesh file loader utilities |
| Cchrono::fea::ChMeshSurface | Class which defines a surface for a mesh FEA elements |
| Cchrono::utils::ChMovingAverage | Moving average filter for smoothing a data array |
| Cchrono::ChMulticoreDataManager | Global data manager for Chrono::Multicore |
| Cchrono::ChMumpsEngine | Wrapper class for the MUMPS direct linear solver |
| Cchrono::ChNameValue< T > | This is a base class for name-value pairs |
| Cchrono::collision::ChNarrowphase | Class for performing narrowphase collision detection |
| Cchrono::ChNode< dt > | Node for linked list |
| ►Cchrono::ChNodeBase | Class for a node, that has some degrees of freedom and that contain a proxy to the solver |
| Cchrono::ChNodeXYZ | Class for a single 'point' node, that has 3 DOF degrees of freedom and a mass |
| ►Cchrono::fea::ChNodeFEAbase | Base class for a generic finite element node that can be stored in ChMesh containers |
| Cchrono::fea::ChNodeFEAcurv | Generic finite element node with 9 degrees of freedom representing curvature |
| Cchrono::fea::ChNodeFEAxyz | Class for a generic 3D finite element node, with x,y,z displacement |
| Cchrono::fea::ChNodeFEAxyzP | Class for a generic finite element node in 3D space, with scalar field P |
| Cchrono::fea::ChNodeFEAxyzrot | Class for a generic ED finite element node, with x,y,z displacement and a 3D rotation |
| ►Cchrono::sensor::ChNoiseModel | Noise model base class |
| Cchrono::sensor::ChNoiseNone | Noise model: no noise |
| Cchrono::sensor::ChNoiseNormalDrift | IMU Noise model: gaussian drifting noise with noncorrelated equal distributions |
| Cchrono::ChNonlinearSolver | Solver for systems of nonlinear equations |
| ►Cchrono::ChObj | Base class for items which can be named, deleted, copied. etc. as in the editor of a 3d modeler |
| Cchrono::ChControllerPID | Class for a basic PID controller |
| Cchrono::ChForce | Forces are objects which must be attached to rigid bodies in order to apply torque or force to such body |
| ►Cchrono::ChLoadBase | Base class for loads |
| ►Cchrono::ChLoad< ChLoaderBeamWrench > | |
| Cchrono::fea::ChLoadBeamWrench | Atomic wrench (ready to use load) Load for a wrench (force+torque) at a specific position of a beam |
| ►Cchrono::ChLoad< ChLoaderBeamWrenchDistributed > | |
| Cchrono::fea::ChLoadBeamWrenchDistributed | Distributed constant wrench (ready to use load) Load for a wrench (force+torque) at a specific position of a beam |
| ►Cchrono::ChLoad< ChLoaderXYZnode > | |
| Cchrono::ChLoadXYZnode | Force at XYZ node (ready to use load) |
| Cchrono::ChLoad< Tloader > | Class for a load acting on a single ChLoadable item, via ChLoader objects |
| Cchrono::ChLoadBodyMesh | Class for applying loads to a triangle mesh belonging to a ChBody, as a cluster of forces operating on the underlying rigid body |
| ►Cchrono::ChLoadCustom | Loads acting on a single ChLoadable item |
| Cchrono::ChLoadBodyForce | Load representing a concentrated force acting on a rigid body |
| Cchrono::ChLoadBodyTorque | Load representing a torque applied to a rigid body |
| ►Cchrono::ChLoadXYZnodeForce | Base class for loads representing a concentrated force acting on a ChNodeXYZ |
| Cchrono::ChLoadXYZnodeForceAbsolute | Load representing a concentrated force acting on a ChNodeXYZ, as a constant force, or it provides a function to modulate it with time |
| ►Cchrono::fea::ChLoadXYZROTnode | Base class for loads representing a concentrated wrench (force + torque) acting on a ChNodeFEAxyzrot |
| Cchrono::fea::ChLoadXYZROTnodeForceAbsolute | Load representing a concentrated force acting on a ChNodeXYZ, as a constant force, or it provides a function to modulate it with time |
| ►Cchrono::ChLoadCustomMultiple | Loads acting on multiple ChLoadable items |
| ►Cchrono::ChLoadBodyBody | Base class for wrench loads (a force + a torque) acting between two bodies |
| Cchrono::ChLoadBodyBodyBushingGeneric | Load for a visco-elastic translational/rotational bushing acting between two bodies |
| ►Cchrono::ChLoadBodyBodyBushingSpherical | Load for a visco-elastic bushing acting between two bodies |
| Cchrono::ChLoadBodyBodyBushingMate | Load for a visco-elastic translational/rotational bushing acting between two bodies |
| Cchrono::ChLoadBodyBodyBushingPlastic | Load for a visco-elasto-plastic bushing acting between two bodies |
| Cchrono::ChLoadBodyBodyTorque | Load representing a torque applied between two bodies |
| ►Cchrono::ChLoadXYZnodeBody | Base class for loads representing a concentrated force acting between a ChNodeXYZ and a ChBody Users should inherit from this and implement a custom ComputeForce(), this is enough to have the load working |
| Cchrono::ChLoadXYZnodeBodyBushing | Load representing a XYZ bushing between a ChNodeXYZ and a ChBody application point, with given with spring stiffness as a ChFunction of displacement, for each X,Y,Z direction along the auxiliary frame at the attachment point |
| Cchrono::ChLoadXYZnodeBodySpring | Load representing a spring between a ChNodeXYZ and a ChBody, where the anchoring to body can be set via SetApplicationFrameB() |
| ►Cchrono::ChLoadXYZnodeXYZnode | Base class for loads representing a concentrated force acting between two ChNodeXYZ |
| Cchrono::ChLoadXYZnodeXYZnodeBushing | Load representing a XYZ bushing between two ChNodeXYZ, with given with spring stiffness as a ChFunction of displacement, for each X,Y,Z direction |
| Cchrono::ChLoadXYZnodeXYZnodeSpring | Load representing a spring between two ChNodeXYZ, with given damping and spring constants, directed as the distance between the two |
| Cchrono::ChShaftsElasticGear | Class for defining a torsional spring-damper between two 1D parts; i.e., shafts that can be used to build 1D models of powertrains |
| ►Cchrono::ChShaftsLoad | Base class for defining loads between a couple of two one-degree-of-freedom parts; i.e., shafts that can be used to build 1D models of powertrains |
| Cchrono::ChShaftsTorsionSpringDamper | Class for defining a torsional spring-damper between two 1D parts; i.e., shafts that can be used to build 1D models of powertrains |
| ►Cchrono::fea::ChLoadXYZROTnodeBody | Base class for loads representing a concentrated wrench (force & torque) acting between a ChNodeFEAxyzrot and a ChBody The force & torque is applied between two local references attached to the two nodes, loc_application_A and loc_application_B, not necessarily centered in the respective nodes |
| Cchrono::fea::ChLoadXYZROTnodeBodyBushingGeneric | Load for a visco-elastic translational/rotational bushing acting between a ChNodeFEAxyzrot and a ChBody |
| ►Cchrono::fea::ChLoadXYZROTnodeBodyBushingSpherical | Load for a visco-elastic bushing acting between a ChNodeFEAxyzrot and a ChBody |
| Cchrono::fea::ChLoadXYZROTnodeBodyBushingMate | Load for a visco-elastic translational/rotational bushing acting between a ChNodeFEAxyzrot and a ChBody |
| Cchrono::fea::ChLoadXYZROTnodeBodyBushingPlastic | Load for a visco-elasto-plastic bushing acting between a ChNodeFEAxyzrot and a ChBody |
| ►Cchrono::fea::ChLoadXYZROTnodeXYZROTnode | Base class for loads representing a concentrated wrench (force & torque) acting between two ChNodeFEAxyzrot |
| Cchrono::fea::ChLoadXYZROTnodeXYZROTnodeBushingGeneric | Load for a visco-elastic translational/rotational bushing acting between two bodies |
| ►Cchrono::fea::ChLoadXYZROTnodeXYZROTnodeBushingSpherical | Load for a visco-elastic bushing acting between two bodies |
| Cchrono::fea::ChLoadXYZROTnodeXYZROTnodeBushingMate | Load for a visco-elastic translational/rotational bushing acting between two ChNodeFEAxyzrot nodes |
| Cchrono::fea::ChLoadXYZROTnodeXYZROTnodeBushingPlastic | Load for a visco-elasto-plastic bushing acting between two ChNodeFEAxyzrot |
| Cchrono::fea::ChLoadContactSurfaceMesh | Class for applying loads to a contact mesh as a cluster of forces operating on the nodes of the underlying finite elements |
| Cchrono::ChMarker | Markers are auxiliary reference frames which belong to rigid bodies and move together with them |
| ►Cchrono::ChPhysicsItem | Base class for items that can contain objects of ChVariables or ChConstraints, such as rigid bodies, mechanical joints, etc |
| ►Cchrono::Ch3DOFContainer | Base class for containers of elements with 3 degrees of freedom (fluid nodes, rigid particles) |
| Cchrono::ChFluidContainer | Container of fluid particles |
| Cchrono::ChParticleContainer | Container of rigid particles (3 DOF) |
| Cchrono::ChAssembly | Class for assemblies of items, for example ChBody, ChLink, ChMesh, etc |
| Cchrono::ChBody | Class for rigid bodies |
| ►Cchrono::ChContactContainer | Class representing a container of many contacts |
| ►Cchrono::ChContactContainerMulticore | Class representing a container of many contacts, implemented as a linked list of contact tuples |
| Cchrono::ChContactContainerMulticoreNSC | Specialization of the multicore contact container for NSC contacts |
| Cchrono::ChContactContainerMulticoreSMC | Specialization of the multicore contact container for SMC contacts |
| Cchrono::ChContactContainerNSC | Class representing a container of many non-smooth contacts |
| Cchrono::ChContactContainerSMC | Class representing a container of many smooth (penalty) contacts |
| Cchrono::ChConveyor | Class for conveyor belt |
| ►Cchrono::ChIndexedNodes | Interface class for clusters of points that can be accessed with an index |
| Cchrono::ChMatterSPH | Class for clusters of point nodes that can simulate a fluid or an elastic/plastic solid with the Smooth Particle Hydrodynamics (SPH) approach, that is with a 'meshless' FEA approach |
| Cchrono::fea::ChMatterMeshless | Class for clusters of nodes that can simulate a visco-elasto-plastic deformable solid using the approach in Mueller ("Point based.." 2004 paper), that is with a 'meshless' FEA approach |
| Cchrono::fea::ChMesh | Class which defines a mesh of finite elements of class ChElementBase, between nodes of class ChNodeFEAbase |
| ►Cchrono::ChIndexedParticles | Interface class for clusters of particles that can be accessed with an index |
| Cchrono::ChParticlesClones | Class for clusters of 'clone' particles, that is many rigid objects with the same shape and mass |
| ►Cchrono::ChLinkBase | Base class for all types of constraints that act like mechanical joints ('links') in 3D space |
| ►Cchrono::ChLink | Base class for joints between two ChBodyFrame objects |
| Cchrono::ChLinkDistance | Class for enforcing a fixed polar distance between two points on two ChBodyFrame objects |
| ►Cchrono::ChLinkMarkers | Class for links which connect two 'markers' |
| ►Cchrono::ChLinkLock | Base class for joints implemented using the "lock formulation" |
| Cchrono::ChLinkBrake | Link representing a brake between two rigid bodies, including the sticking effect |
| Cchrono::ChLinkBushing | ChLinkBushing class |
| Cchrono::ChLinkGear | Gear link between two rigid bodies |
| Cchrono::ChLinkLockAlign | Align joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockCylindrical | Cylindrical joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockFree | Free joint, with the 'ChLinkLock' formulation |
| ►Cchrono::ChLinkLockLock | 6-dof locked joint, with the link-lock formulation |
| Cchrono::ChLinkClearance | A class for the custom fast simulation of revolute joints with clearance |
| Cchrono::ChLinkLinActuator | Class for linear actuators between two markers, as the actuator were joined with two spherical bearing at the origin of the two markers |
| Cchrono::ChLinkPointSpline | ChLinkPointSpline class |
| Cchrono::ChLinkPulley | Class to create pulleys on two rigid bodies, connected by a belt |
| Cchrono::ChLinkTrajectory | ChLinkTrajectory class |
| Cchrono::ChLinkLockOldham | Oldham joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockParallel | Parallel joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockPerpend | Perpendicularity joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockPlanePlane | Plane-plane joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockPointLine | Point-line joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockPointPlane | Point-plane joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockPrismatic | Prismatic joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockRevolute | Revolute joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockRevolutePrismatic | RevolutePrismatic joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkLockSpherical | Spherical joint, with the 'ChLinkLock' formulation |
| Cchrono::ChLinkScrew | Screw joint between two rigid bodies |
| Cchrono::ChLinkRotSpringCB | Class for rotational spring-damper elements with the torque specified through a callback object |
| Cchrono::ChLinkSpring | Class for spring-damper systems, acting along the polar distance of two markers |
| Cchrono::ChLinkSpringCB | Class for spring-damper systems with the force specified through a functor object |
| ►Cchrono::ChLinkMate | Base class for all 'simple' constraints between two frames attached to two bodies |
| ►Cchrono::ChLinkMateGeneric | Generic mate constraint, where one can select which DOFs must be constrained between two frames attached to the two bodies |
| Cchrono::ChLinkMateCoaxial | Mate constraint of coaxial type |
| Cchrono::ChLinkMateFix | Mate constraint that completely fix one frame's rotation and translation respect to the other frame |
| Cchrono::ChLinkMateOrthogonal | Mate constraint of orthogonal type |
| Cchrono::ChLinkMateParallel | Mate constraint of parallel type |
| Cchrono::ChLinkMatePlane | Mate constraint of plane-to-plane type |
| Cchrono::ChLinkMateSpherical | Mate constraint of spherical type |
| Cchrono::ChLinkMateXdistance | Mate constraining distance of origin of frame B respect to X axis of frame A |
| Cchrono::ChLinkMotionImposed | A joint that enforces position and rotation between two frames on two bodies, using six rheonomic constraints |
| ►Cchrono::ChLinkMotor | Base class for all "motor" constraints between two frames on two bodies |
| ►Cchrono::ChLinkMotorLinear | Base class for all linear "motor" constraints between two frames on two bodies |
| Cchrono::ChLinkMotorLinearDriveline | This is an "interface" from 3D to a powertrain/powertrain that is modeled via 1D elements such as ChShaft, ChShaftsMotor, ChShaftsGearbox, ChShaftsClutch, etc |
| Cchrono::ChLinkMotorLinearForce | A linear motor that applies a force between two frames on two bodies |
| Cchrono::ChLinkMotorLinearPosition | A linear motor that enforces the position x(t) between two frames on two bodies, using a rheonomic constraint |
| Cchrono::ChLinkMotorLinearSpeed | A linear motor that enforces the speed v(t) between two frames on two bodies, using a rheonomic constraint |
| ►Cchrono::ChLinkMotorRotation | Base class for all rotational "motor" constraints between two frames on two bodies |
| Cchrono::ChLinkMotorRotationAngle | A motor that enforces the rotation angle r(t) between two frames on two bodies, using a rheonomic constraint |
| Cchrono::ChLinkMotorRotationDriveline | This is an "interface" from 3D to a powertrain/powertrain that is modeled via 1D elements such as ChShaft, ChShaftsMotor, ChShaftsGearbox, ChShaftsClutch, etc |
| Cchrono::ChLinkMotorRotationSpeed | A motor that enforces the angular speed w(t) between two frames on two bodies, using a rheonomic constraint |
| Cchrono::ChLinkMotorRotationTorque | A motor that applies a torque between two frames on two bodies |
| Cchrono::ChLinkRackpinion | Rack-pinion link between two body frames |
| Cchrono::ChLinkRevolute | Class for modeling a revolute joint between two two ChBodyFrame objects |
| Cchrono::ChLinkRevoluteSpherical | Class for modeling a composite revolute-spherical joint between two two ChBodyFrame objects |
| Cchrono::ChLinkRevoluteTranslational | Class for modeling a composite revolute-translational joint between two ChBodyFrame objects |
| Cchrono::ChLinkTSDA | Class for translational spring-damper-actuator (TSDA) with the force optionally specified through a functor object (default, linear TSDA) |
| Cchrono::ChLinkUniversal | Class for modeling a universal joint between two two ChBodyFrame objects |
| Cchrono::fea::ChLinkBeamIGAslider | Class for allowin an IGA beam to slide inside a 'outlet' represented by the x axis of a coordinate system floating with a ChBodyFrame |
| Cchrono::fea::ChLinkDirFrame | Class for creating a constraint between the direction of a FEA node of ChNodeFEAxyzD class, and a ChBodyFrame (frame) |
| Cchrono::fea::ChLinkPointFrame | Class for creating a constraint between an FEA node of ChNodeFEAxyz type and a ChBodyFrame (frame) object |
| Cchrono::fea::ChLinkPointFrameGeneric | Class for creating a constraint between an FEA node of ChNodeFEAxyz type and a ChBodyFrame (frame) object |
| Cchrono::fea::ChLinkPointPoint | Class for creating a constraint between two xyz FEA nodes (points) |
| Cchrono::fea::ChLinkPointTriface | Class for creating a constraint between a xyz FEA node (point) and a triangular face given by three xyz FEA nodes, with linear shape function (ex |
| Cchrono::fea::ChLinkPointTrifaceRot | Class for creating a constraint between a xyz FEA node (point) and a triangular face given by three xyzrot FEA nodes, with linear shape function (ex |
| ►Cchrono::ChLoadContainer | A container of ChLoad objects |
| Cchrono::vehicle::ChTrackCustomContact | Callback interface for user-defined custom contact between road wheels and track shoes |
| Cchrono::vehicle::SCMDeformableSoil | Underlying implementation of the Soil Contact Model |
| ►Cchrono::ChProximityContainer | Class representing the interface for containers of proximity pairs, that is pairs of collision models that have been obtained from the broadphase collision |
| Cchrono::ChProximityContainerMeshless | Class for container of many proximity pairs for a meshless deformable continuum (necessary for inter-particle material forces), as CPU typical linked list of ChProximityMeshless objects |
| Cchrono::ChProximityContainerSPH | Class for container of many proximity pairs for SPH (Smooth Particle Hydrodynamics and similar meshless force computations), as CPU typical linked list of ChProximitySPH objects |
| Cchrono::ChShaft | Class for one-degree-of-freedom mechanical parts with associated inertia (mass, or J moment of inertial for rotating parts) |
| Cchrono::ChShaftsBody | Class for creating a constraint between a 3D ChBody object and a 1D ChShaft object |
| Cchrono::ChShaftsBodyTranslation | Class for creating a constraint between a 3D ChBody object and a 1D ChShaft object that represents a 1D translational DOF (differently from the ChShaftsBody constraint that connects to a rotational DOF) A translation axis must be specified (to tell along which direction the 1D shaft inertia rotation affects the body) |
| ►Cchrono::ChShaftsCouple | Base class for defining constraints between a couple of two one-degree-of-freedom parts; i.e., shafts that can be used to build 1D models of powertrains |
| Cchrono::ChShaftsClutch | Class for defining a clutch or a brake (1D model) between two one-degree-of-freedom parts; i.e., shafts that can be used to build 1D models of powertrains |
| Cchrono::ChShaftsGear | Class for defining a 'transmission ratio' (a 1D gear) between two one-degree-of-freedom parts; i.e., shafts that can be used to build 1D models of powertrains |
| ►Cchrono::ChShaftsMotorBase | Base class for all "motors" between two 1D elements of ChShaft class |
| Cchrono::ChShaftsMotor | Class for a multipurpose motor (a 1D model of 'imposed torque' or 'imposed velocity' or 'imposed rotation') between two one-degree-of-freedom parts, that is, shafts that can be used to build 1D models of power trains |
| Cchrono::ChShaftsMotorAngle | A motor that enforces the rotation angle r(t) between two ChShaft shafts, using a rheonomic constraint |
| Cchrono::ChShaftsMotorSpeed | A motor that enforces the angular speed w(t) between two ChShaft shafts, using a rheonomic constraint |
| Cchrono::ChShaftsMotorTorque | A motor that applies a torque between two ChShaft shafts, a bit like the simplier ChShaftsTorque, with some differences, ex |
| ►Cchrono::ChShaftsTorqueBase | Base class for all stuff defining a torque between two one-degree-of-freedom parts, for example torsional dampers, torsional springs, electric engines, etc |
| Cchrono::ChShaftsThermalEngine | Class for defining a thermal engine between two one-degree-of-freedom parts; i.e., shafts that can be used to build 1D models of power trains |
| Cchrono::ChShaftsTorque | Class for defining a user-defined torque between two one-degree-of-freedom parts; i.e., shafts that can be used to build 1D models of powertrains |
| Cchrono::ChShaftsTorsionSpring | Class for defining a torsional spring-damper between two 1D parts; i.e., shafts that can be used to build 1D models of powertrains |
| Cchrono::ChShaftsGearbox | Class for defining a gearbox |
| Cchrono::ChShaftsGearboxAngled | Class for defining a gearbox with 1D input and 1D output, but with different directions in 3D space |
| Cchrono::ChShaftsPlanetary | Class for defining a planetary gear between three one-degree-of-freedom parts; i.e., shafts that can be used to build 1D models of powertrains; this is more efficient than simulating power trains modeled full 3D ChBody objects) |
| Cchrono::ChShaftsTorqueConverter | Class for defining a torque converter between two one-degree-of-freedom parts; i.e., shafts that can be used to build 1D models of powertrains |
| Cchrono::ChOMP | Dummy no-op functions in case that no parallel multithreading via OpenMP is available |
| Cchrono::CHOMPmutex | Dummy no-op mutex in case that no parallel multithreading via OpenMP is available |
| Cchrono::CHOMPscopedLock | Exception-safe wrapper to a mutex: it automatically locks the mutex as soon as the wrapper is created, and releases the mutex when the wrapper is deleted (you simply put the wrapper in a code section delimited by {} parentheses, so it is deleted by the compiler when exiting the scope of the section or in case of premature exit because of an exception throw) |
| ►Cchrono::opengl::ChOpenGLBase | Base class for all OpenGL related classes |
| Cchrono::opengl::ChOpenGLCamera | OpenGL camera class |
| Cchrono::opengl::ChOpenGLContacts | Renders contact points as a point cloud |
| Cchrono::opengl::ChOpenGLHUD | Class that renders the text and other UI elements |
| Cchrono::opengl::ChOpenGLOBJ | Class for rendering an object |
| ►Cchrono::opengl::ChOpenGLObject | Base class for all drawable objects |
| Cchrono::opengl::ChOpenGLBars | Renders rectangular bars |
| Cchrono::opengl::ChOpenGLCloud | Generic renderable point cloud |
| Cchrono::opengl::ChOpenGLMesh | Generic renderable triangle mesh |
| Cchrono::opengl::ChOpenGLText | Generic renderable text class that uses an atlas stored in the FontData.h file |
| Cchrono::opengl::ChOpenGLWires | Renders a wireframe view for triangles |
| Cchrono::opengl::ChOpenGLOBJLoader | Uses the tiny_obj_loader library to load an OBJ file in the proper format |
| Cchrono::opengl::ChOpenGLShader | Sample shader class that loads and compiles the vertex and fragment shaders |
| Cchrono::opengl::ChOpenGLViewer | OpenGL viewer, this class draws the system to the screen and handles input |
| Cchrono::opengl::ChOpenGLEventCB | Interface of an object which can receive events |
| Cchrono::opengl::ChOpenGLGraphs | Class to render simple plots for the UI |
| Cchrono::opengl::ChOpenGLVertexAttributesPADSN | Support for ADS lighting with glow |
| Cchrono::opengl::ChOpenGLVertexAttributesPADSNT | Support for ADS lighting with glow and texture coordinates |
| Cchrono::opengl::ChOpenGLWindow | Manager for the OpenGL context and window |
| ►Cchrono::ChOptimizer | Base class for multi-variable optimization |
| Cchrono::ChOptimizerGenetic | Class for global optimization with the genetic method (evolutive simulation) |
| Cchrono::ChOptimizerGradient | Class for local optimization with the cheap method of gradient and bisection |
| Cchrono::ChOptimizerHybrid | Class for genetic optimization followed by a refinement with the method of gradient, one after the other |
| Cchrono::ChOptimizerLocal | Class for local optimization with the pseudo-Newton method |
| Cchrono::sensor::ChOptixEngine | Optix Engine that is responsible for managing all render-based sensors |
| Cchrono::sensor::ChOptixGeometry | Optix Geometry class that is responsible for managing all geometric information in the optix scene This handles the acceleration structure and transforms |
| Cchrono::sensor::ChOptixPipeline | Class to hold all the Shader Binding Table parameters adnd manage the ray tracing pipeline, materials, ray gen programs |
| Cchrono::ChPardisoProjectEngine | Wrapper class for the PardisoProject direct linear solver |
| Cchrono::utils::ChParserAdams | ADAMS input file parser |
| Cchrono::utils::ChParserOpenSim | OpenSim input file parser |
| ►Cchrono::vehicle::ChPart | Base class for a vehicle subsystem |
| ►Cchrono::vehicle::ChAntirollBar | Base class for an anti-roll bar subsystem |
| ►Cchrono::vehicle::ChAntirollBarRSD | Template for an anti-roll subsystem using an RSD |
| Cchrono::vehicle::AntirollBarRSD | RSD antirollbar model constructed with data from file (JSON format) |
| Cchrono::vehicle::feda::FEDA_AntirollBarRSD | Anti-roll bar subsystem for a FEDA vehicle |
| Cchrono::vehicle::fmtv::FMTV_AntirollBarRSD | Anti-roll bar subsystem for an FMTV vehicle |
| Cchrono::vehicle::generic::Generic_AntirollBarRSD | Anti-roll bar subsystem for a generic vehicle |
| ►Cchrono::vehicle::ChBrake | Base class for a brake subsystem |
| ►Cchrono::vehicle::ChBrakeShafts | Brake for wheeled vehicles modeled using a clutch between two shafts |
| Cchrono::vehicle::BrakeShafts | Wheeled vehicle shafts-based brake model constructed with data from file (JSON format) |
| Cchrono::vehicle::citybus::CityBus_BrakeShafts | Shafts-based CityBus brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::feda::FEDA_BrakeShafts | Shafts-based FED-alpha brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::fmtv::FMTV_BrakeShafts | Shafts-based FMTV brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::gator::Gator_BrakeShafts | Shafts-based Gator brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::hmmwv::HMMWV_BrakeShafts | Shafts-based HMMWV brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::man::MAN_5t_BrakeShafts | Shafts-based MAN brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::mrole::mrole_BrakeShafts | Shafts-based mrole brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::sedan::Sedan_BrakeShafts | Shafts-based Sedan brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::uaz::UAZBUS_BrakeShaftsFront | Shafts-based UAZ front brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::uaz::UAZBUS_BrakeShaftsRear | Shafts-based UAZ rear brake subsystem (uses a clutch between two shafts) |
| ►Cchrono::vehicle::ChBrakeSimple | Template for a simple brake subsystem |
| Cchrono::vehicle::BrakeSimple | Vehicle simple brake model constructed with data from file (JSON format) |
| Cchrono::vehicle::citybus::CityBus_BrakeSimple | Simple CityBus brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::feda::FEDA_BrakeSimple | Simple FEDA brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::fmtv::FMTV_BrakeSimple | FMTV simple brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::gator::Gator_BrakeSimple | Simple Gator brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::generic::Generic_BrakeSimple | Simple brake subsystem for the generic vehicle (torque applied directly to the spindle joint) |
| Cchrono::vehicle::hmmwv::HMMWV_BrakeSimple | Simple HMMWV brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::kraz::Kraz_tractor_Brake | Simple Kraz tractor brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::kraz::Kraz_trailer_Brake | Simple Kraz trailer brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::man::MAN_5t_BrakeSimple | Simple MAN brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::mrole::mrole_BrakeSimple | Simple mrole brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::rccar::RCCar_BrakeSimple | Simple RCCar brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::sedan::Sedan_BrakeSimple | Simple Sedan brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::uaz::UAZBUS_BrakeSimpleFront | Simple UAZBUS front brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::uaz::UAZBUS_BrakeSimpleRear | Simple UAZBUS rear brake subsystem (torque applied directly to the spindle joint) |
| ►Cchrono::vehicle::ChChassis | Base class for the chassis vehicle subsystem |
| ►Cchrono::vehicle::ChChassisRear | Base class for a rear chassis vehicle subsystem |
| ►Cchrono::vehicle::ChRigidChassisRear | Template for a rigid-body rear chassis vehicle subsystem |
| Cchrono::vehicle::fmtv::LMTV_ChassisRear | LMTV rear chassis subsystem |
| Cchrono::vehicle::fmtv::MTV_ChassisRear | MTV cargo truck (5 tons) rear chassis subsystems |
| Cchrono::vehicle::kraz::Kraz_trailer_Chassis | Kraz trailer chassis subsystem |
| Cchrono::vehicle::RigidChassisRear | Vehicle rigid rear chassis model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChRigidChassis | Template for a rigid-body main chassis vehicle subsystem |
| Cchrono::vehicle::citybus::CityBus_Chassis | CityBus chassis subsystem |
| Cchrono::vehicle::feda::FEDA_Chassis | FEDA chassis subsystem |
| Cchrono::vehicle::fmtv::FMTV_ChassisFront | FMTV front chassis subsystem (common for MTV and LMTV trucks) |
| Cchrono::vehicle::gator::Gator_Chassis | Gator chassis subsystem |
| Cchrono::vehicle::generic::Generic_Chassis | Chassis subsystem for a generic vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_Chassis | HMMWV chassis subsystem |
| Cchrono::vehicle::kraz::Kraz_tractor_Chassis | Kraz tractor chassis subsystem |
| Cchrono::vehicle::m113::M113_Chassis | M113 chassis subsystem |
| Cchrono::vehicle::man::MAN_10t_Chassis | MAN 10t chassis subsystem |
| Cchrono::vehicle::man::MAN_5t_Chassis | MAN 5t chassis subsystem |
| Cchrono::vehicle::man::MAN_7t_Chassis | MAN 7t chassis subsystem |
| Cchrono::vehicle::marder::Marder_Chassis | Marder chassis subsystem |
| Cchrono::vehicle::mrole::mrole_Chassis | Mrole chassis subsystem |
| Cchrono::vehicle::rccar::RCCar_Chassis | RCCar chassis subsystem |
| Cchrono::vehicle::RigidChassis | Vehicle rigid chassis model constructed with data from file (JSON format) |
| Cchrono::vehicle::sedan::Sedan_Chassis | Sedan chassis subsystem |
| Cchrono::vehicle::uaz::UAZBUS_Chassis | UAZBUS chassis subsystem |
| ►Cchrono::vehicle::ChChassisConnector | Base class for a chassis connector subsystem |
| ►Cchrono::vehicle::ChChassisConnectorArticulated | Template for an articulation chassis connector |
| Cchrono::vehicle::ChassisConnectorArticulated | Articulated chassis connector model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChChassisConnectorHitch | Template for a hitch chassis connector. This is a passive connector, modeled with a spherical joint |
| Cchrono::vehicle::ChassisConnectorHitch | Hitch chassis connector model constructed with data from file (JSON format) |
| Cchrono::vehicle::kraz::Kraz_trailer_Connector | Kraz tractor-trailer hitch connector subsystem |
| ►Cchrono::vehicle::ChChassisConnectorTorsion | Template for a torsion chassis connector |
| Cchrono::vehicle::ChassisConnectorTorsion | Torsion chassis connector model constructed with data from file (JSON format) |
| Cchrono::vehicle::fmtv::LMTV_ChassisConnector | LMTV torsion chassis connector |
| Cchrono::vehicle::fmtv::MTV_ChassisConnector | MTV torsion chassis connector |
| ►Cchrono::vehicle::ChDriveline | Base class for a vehicle driveline subsystem |
| ►Cchrono::vehicle::ChDrivelineTV | Base class for a tracked vehicle driveline |
| ►Cchrono::vehicle::ChSimpleTrackDriveline | Simple driveline model for a tracked vehicle |
| Cchrono::vehicle::m113::M113_SimpleDriveline | Simple driveline model for the M113 vehicle (purely kinematic) |
| Cchrono::vehicle::marder::Marder_SimpleDriveline | Simple driveline model for the Marder vehicle (purely kinematic) |
| Cchrono::vehicle::SimpleTrackDriveline | Simple tracked vehicle driveline model template using data from file (JSON format) |
| ►Cchrono::vehicle::ChTrackDrivelineBDS | Track driveline model template based on ChShaft objects |
| Cchrono::vehicle::m113::M113_DrivelineBDS | Shafts-based driveline model for the M113 vehicle |
| Cchrono::vehicle::TrackDrivelineBDS | BDS tracked vehicle driveline model template using data from file (JSON format) |
| ►Cchrono::vehicle::ChDrivelineWV | Base class for a wheeled vehicle driveline subsystem |
| ►Cchrono::vehicle::ChShaftsDriveline2WD | 2WD driveline model template based on ChShaft objects |
| Cchrono::vehicle::citybus::CityBus_Driveline2WD | Shafts-based 2-WD driveline for the CityBus vehicle |
| Cchrono::vehicle::gator::Gator_Driveline2WD | Shafts-based 2-WD driveline for the Gator vehicle |
| Cchrono::vehicle::generic::Generic_Driveline2WD | Shafts-based 2-WD driveline model for a generic vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_Driveline2WD | Shafts-based 2-WD driveline for the HMMWV vehicle |
| Cchrono::vehicle::mrole::mrole_Driveline2WD | Shafts-based 2-WD driveline for the mrole vehicle |
| Cchrono::vehicle::sedan::Sedan_Driveline2WD | Shafts-based 2-WD driveline for the Sedan vehicle |
| Cchrono::vehicle::ShaftsDriveline2WD | 2WD driveline model template based on ChShaft objects using data from file (JSON format) |
| Cchrono::vehicle::uaz::UAZBUS_Driveline2WD | Shafts-based 2-WD driveline for the UAZBUS vehicle |
| ►Cchrono::vehicle::ChShaftsDriveline4WD | 4WD driveline model template based on ChShaft objects |
| Cchrono::vehicle::feda::FEDA_Driveline4WD | Shafts-based 4-WD driveline for the FEDA vehicle |
| Cchrono::vehicle::fmtv::FMTV_Driveline4WD | Shafts-based 4-WD driveline for the FMTV vehicles |
| Cchrono::vehicle::hmmwv::HMMWV_Driveline4WD | Shafts-based 4-WD driveline for the HMMWV vehicle |
| Cchrono::vehicle::kraz::Kraz_tractor_Driveline | Shafts-based 4-WD driveline for the Kraz tractor |
| Cchrono::vehicle::man::MAN_5t_Driveline4WD | Shafts-based 4-WD driveline for the MAN 5t vehicle |
| Cchrono::vehicle::mrole::mrole_Driveline4WD | Shafts-based 4-WD driveline for the mrole vehicle |
| Cchrono::vehicle::rccar::RCCar_Driveline4WD | Shafts-based 4-WD driveline for the RCCar vehicle |
| Cchrono::vehicle::ShaftsDriveline4WD | 4WD driveline model template based on ChShaft objects using data from file (JSON format) |
| Cchrono::vehicle::uaz::UAZBUS_Driveline4WD | Shafts-based 4-WD driveline for the UAZBUS vehicle |
| ►Cchrono::vehicle::ChShaftsDriveline6WD | 4WD driveline model template based on ChShaft objects |
| Cchrono::vehicle::mrole::mrole_Driveline6WD | Shafts-based 6-WD driveline for the mrole vehicle |
| ►Cchrono::vehicle::ChShaftsDriveline8WD | 4WD driveline model template based on ChShaft objects |
| Cchrono::vehicle::mrole::mrole_Driveline8WD | Shafts-based 8-WD driveline for the mrole vehicle |
| ►Cchrono::vehicle::ChSimpleDriveline | Simple driveline model |
| Cchrono::vehicle::fmtv::FMTV_SimpleDriveline | Simple FMTV driveline subsystem (purely kinematic) |
| Cchrono::vehicle::hmmwv::HMMWV_SimpleDriveline | Simple HMMWV driveline subsystem (purely kinematic) |
| Cchrono::vehicle::man::MAN_5t_SimpleDriveline | Simple MAN 5t driveline subsystem (purely kinematic) |
| Cchrono::vehicle::mrole::mrole_SimpleDriveline | Simple mrole driveline subsystem (purely kinematic) |
| Cchrono::vehicle::SimpleDriveline | Simple driveline model template using data from file (JSON format) |
| ►Cchrono::vehicle::ChSimpleDrivelineXWD | Simple driveline model |
| Cchrono::vehicle::man::MAN_5t_SimpleDrivelineXWD | Simple MAN 5t driveline subsystem (purely kinematic) |
| Cchrono::vehicle::mrole::mrole_SimpleDrivelineXWD | Simple MAN 5t driveline subsystem (purely kinematic) |
| Cchrono::vehicle::SimpleDrivelineXWD | Simple driveline model template using data from file (JSON format) |
| Cchrono::vehicle::gator::Gator_SimpleDriveline | Simple Gator driveline subsystem (purely kinematic) |
| Cchrono::vehicle::generic::Generic_SimpleDriveline | Simple driveline model for the generic vehicle (purely kinematic) |
| ►Cchrono::vehicle::ChIdler | Base class for an idler subsystem |
| ►Cchrono::vehicle::ChDoubleIdler | Base class for a double idler (template definition) |
| Cchrono::vehicle::DoubleIdler | Double idler model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::m113::M113_Idler | Idler and tensioner model for the M113 vehicle (base class) |
| Cchrono::vehicle::m113::M113_IdlerLeft | Idler and tensioner model for the M113 vehicle (left side) |
| Cchrono::vehicle::m113::M113_IdlerRight | Idler and tensioner model for the M113 vehicle (right side) |
| ►Cchrono::vehicle::marder::Marder_Idler | Idler and tensioner model for the Marder vehicle (base class) |
| Cchrono::vehicle::marder::Marder_IdlerLeft | Idler and tensioner model for the M113 vehicle (left side) |
| Cchrono::vehicle::marder::Marder_IdlerRight | Idler and tensioner model for the M113 vehicle (right side) |
| ►Cchrono::vehicle::ChSingleIdler | Base class for a single idler (template definition) |
| Cchrono::vehicle::SingleIdler | Single idler model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChPowertrain | Base class for a powertrain system |
| ►Cchrono::vehicle::ChShaftsPowertrain | Template for a powertrain model using shaft elements |
| Cchrono::vehicle::feda::FEDA_Powertrain | Shafts-based powertrain model for the FEDA vehicle |
| Cchrono::vehicle::fmtv::FMTV_Powertrain | Shafts-based powertrain model for the FMTV vehicles |
| Cchrono::vehicle::hmmwv::HMMWV_Powertrain | Shafts-based powertrain model for the HMMWV vehicle |
| Cchrono::vehicle::m113::M113_ShaftsPowertrain | Shafts-based powertrain model for the M113 vehicle |
| Cchrono::vehicle::mrole::mrole_Powertrain | Shafts-based powertrain model for the mrole vehicle |
| Cchrono::vehicle::ShaftsPowertrain | Shafts-based powertrain subsystem (specified through JSON file) |
| ►Cchrono::vehicle::ChSimpleCVTPowertrain | Template for simplified powertrain model |
| Cchrono::vehicle::fmtv::FMTV_SimpleCVTPowertrain | Simple powertrain subsystem (purely kinematic) for the FMTV vehicles |
| Cchrono::vehicle::hmmwv::HMMWV_SimpleCVTPowertrain | Simple HMMWV powertrain subsystem (purely kinematic) |
| Cchrono::vehicle::m113::M113_SimpleCVTPowertrain | Simple CVT powertrain model for the M113 vehicle (purely kinematic) |
| Cchrono::vehicle::man::MAN_5t_SimpleCVTPowertrain | Simple MAN 5t powertrain subsystem (purely kinematic) |
| Cchrono::vehicle::man::MAN_7t_SimpleCVTPowertrain | Simple MAN 5t powertrain subsystem (purely kinematic) |
| Cchrono::vehicle::marder::Marder_SimpleCVTPowertrain | Simple CVT powertrain model for the M113 vehicle (purely kinematic) |
| Cchrono::vehicle::mrole::mrole_SimpleCVTPowertrain | Simple mrole powertrain subsystem (purely kinematic) |
| Cchrono::vehicle::SimpleCVTPowertrain | Simple CVT-like powertrain subsystem (specified through JSON file) |
| ►Cchrono::vehicle::ChSimpleMapPowertrain | Template for simple powertrain model based on speed-torque engine maps |
| Cchrono::vehicle::citybus::CityBus_SimpleMapPowertrain | Simple CityBus powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::feda::FEDA_SimpleMapPowertrain | Simple FEDA powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::fmtv::FMTV_SimpleMapPowertrain | Simple FMTV powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::gator::Gator_SimpleMapPowertrain | Simple Gator powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::hmmwv::HMMWV_SimpleMapPowertrain | Simple HMMWV powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::kraz::Kraz_tractor_Powertrain | Simple Kraz tractor powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::m113::M113_SimpleMapPowertrain | Simple M113 powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::man::MAN_5t_SimpleMapPowertrain | Simple MAN 5t powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::man::MAN_7t_SimpleMapPowertrain | Simple MAN 7t powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::mrole::mrole_SimpleMapPowertrain | Simple mrole powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::rccar::RCCar_SimpleMapPowertrain | Simple RCCar powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::sedan::Sedan_SimpleMapPowertrain | Simple Sedan powertrain subsystem (based on engine speed-torque maps) |
| Cchrono::vehicle::SimpleMapPowertrain | Simple speed-torque engine map powertrain subsystem (specified through JSON file) |
| Cchrono::vehicle::uaz::UAZBUS_SimpleMapPowertrain | Simple UAZBUS powertrain subsystem (based on engine speed-torque maps) |
| ►Cchrono::vehicle::ChSimplePowertrain | Template for simplified powertrain model |
| Cchrono::vehicle::fmtv::FMTV_SimplePowertrain | Simple FMTV powertrain subsystem (purely kinematic) |
| Cchrono::vehicle::generic::Generic_SimplePowertrain | Simple powertrain model for the generic vehicle (purely kinematic) |
| Cchrono::vehicle::hmmwv::HMMWV_SimplePowertrain | Simple HMMWV powertrain subsystem (purely kinematic) |
| Cchrono::vehicle::marder::Marder_SimplePowertrain | Simple powertrain model for the Marder vehicle (purely kinematic) |
| Cchrono::vehicle::mrole::mrole_SimplePowertrain | Simple mrole powertrain subsystem (purely kinematic) |
| Cchrono::vehicle::SimplePowertrain | Simple powertrain subsystem (specified through JSON file) |
| Cchrono::vehicle::gator::Gator_SimplePowertrain | Simple Gator powertrain subsystem (DC motor linear torque-speed characteristic) |
| Cchrono::vehicle::generic::Generic_SimpleMapPowertrain | Custom powertrain model for a generic vehicle |
| ►Cchrono::vehicle::ChRoadWheel | Base class for a road wheel subsystem |
| ►Cchrono::vehicle::ChDoubleRoadWheel | Base class for a double road wheel (template definition) |
| Cchrono::vehicle::DoubleRoadWheel | Double road-wheel model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::m113::M113_RoadWheel | Road-wheel model for the M113 vehicle (base class) |
| Cchrono::vehicle::m113::M113_RoadWheelLeft | Road-wheel model for the M113 vehicle (left side) |
| Cchrono::vehicle::m113::M113_RoadWheelRight | Road-wheel model for the M113 vehicle (right side) |
| ►Cchrono::vehicle::marder::Marder_RoadWheel | Road-wheel model for the Marder vehicle (base class) |
| Cchrono::vehicle::marder::Marder_RoadWheelLeft | Road-wheel model for the M113 vehicle (left side) |
| Cchrono::vehicle::marder::Marder_RoadWheelRight | Road-wheel model for the M113 vehicle (right side) |
| ►Cchrono::vehicle::ChSingleRoadWheel | Base class for a single road wheel (template definition) |
| Cchrono::vehicle::SingleRoadWheel | Single road-wheel model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChRoadWheelAssembly | Base class for tracked vehicle suspension (road-wheel assembly) subsystem |
| ►Cchrono::vehicle::ChLinearDamperRWAssembly | Base class for a torsion-bar suspension system using linear dampers (template definition) |
| Cchrono::vehicle::LinearDamperRWAssembly | Torsion-bar suspension system using linear dampers constructed with data from file (JSON format) |
| Cchrono::vehicle::m113::M113_Suspension | Linear-damper M113 suspension (road-wheel assembly) |
| Cchrono::vehicle::marder::Marder_Suspension | Linear-damper Marder suspension (road-wheel assembly) |
| ►Cchrono::vehicle::ChRotationalDamperRWAssembly | Base class for a torsion-bar suspension system using a rotational damper (template definition) |
| Cchrono::vehicle::RotationalDamperRWAssembly | Torsion-bar suspension system using linear dampers constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChRoller | Base class for a roller wheel subsystem |
| ►Cchrono::vehicle::ChDoubleRoller | Base class for a double roller (template definition) |
| Cchrono::vehicle::DoubleRoller | Double roller model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::marder::Marder_SupportRoller | Support roller model for the Marder vehicle (base class) |
| Cchrono::vehicle::marder::Marder_SupportRollerLeft | Road-wheel model for the M113 vehicle (left side) |
| Cchrono::vehicle::marder::Marder_SupportRollerRight | Road-wheel model for the M113 vehicle (right side) |
| ►Cchrono::vehicle::ChSprocket | Base class for a tracked vehicle sprocket |
| ►Cchrono::vehicle::ChSprocketBand | Base class for a sprocket template with gear profile composed of circular arcs and a flat seat |
| ►Cchrono::vehicle::m113::M113_SprocketBand | M113 sprocket subsystem for continuous band track (base class) |
| Cchrono::vehicle::m113::M113_SprocketBandLeft | M113 sprocket subsystem for continuous band track (left side) |
| Cchrono::vehicle::m113::M113_SprocketBandRight | M113 sprocket subsystem for continuous band track (right side) |
| Cchrono::vehicle::SprocketBand | Tracked vehicle continuous-band sprocket model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChSprocketDoublePin | Base class for a sprocket template with gear profile composed of circular arcs and a flat seat |
| ►Cchrono::vehicle::m113::M113_SprocketDoublePin | M113 sprocket subsystem, suitable for interaction with double-pin track shoes (base class) |
| Cchrono::vehicle::m113::M113_SprocketDoublePinLeft | M113 sprocket subsystem, suitable for interaction with double-pin track shoes (left side) |
| Cchrono::vehicle::m113::M113_SprocketDoublePinRight | M113 sprocket subsystem, suitable for interaction with double-pin track shoes (right side) |
| Cchrono::vehicle::SprocketDoublePin | Tracked vehicle double-pin sprocket model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChSprocketSinglePin | Base class for a sprocket template with gear profile composed of circular arcs |
| ►Cchrono::vehicle::m113::M113_SprocketSinglePin | M113 sprocket subsystem, suitable for interaction with single-pin track shoes (base class) |
| Cchrono::vehicle::m113::M113_SprocketSinglePinLeft | M113 sprocket subsystem, suitable for interaction with single-pin track shoes (left side) |
| Cchrono::vehicle::m113::M113_SprocketSinglePinRight | M113 sprocket subsystem, suitable for interaction with single-pin track shoes (right side) |
| ►Cchrono::vehicle::marder::Marder_SprocketSinglePin | Marder sprocket subsystem, suitable for interaction with single-pin track shoes (base class) |
| Cchrono::vehicle::marder::Marder_SprocketSinglePinLeft | M113 sprocket subsystem, suitable for interaction with single-pin track shoes (left side) |
| Cchrono::vehicle::marder::Marder_SprocketSinglePinRight | M113 sprocket subsystem, suitable for interaction with single-pin track shoes (right side) |
| Cchrono::vehicle::SprocketSinglePin | Tracked vehicle single-pin sprocket model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChSteering | Base class for a steering subsystem |
| ►Cchrono::vehicle::ChPitmanArm | Base class for a Pitman Arm steering subsystem |
| Cchrono::vehicle::feda::FEDA_PitmanArm | Pitman-arm steering subsystem for the FEDA vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_PitmanArm | Pitman-arm steering subsystem for the HMMWV vehicle |
| Cchrono::vehicle::mrole::mrole_PitmanArm | Pitman-arm steering subsystem for the mrole vehicle |
| Cchrono::vehicle::PitmanArm | Pitman arm steering model constructed with data from file (JSON format) |
| Cchrono::vehicle::rccar::RCCar_PitmanArm | Pitman-arm steering subsystem for the RCCar vehicle |
| ►Cchrono::vehicle::ChPitmanArmShafts | Base class for a Pitman Arm steering subsystem with compliant steering column |
| Cchrono::vehicle::hmmwv::HMMWV_PitmanArmShafts | Pitman-arm with compliant column steering subsystem for the HMMWV vehicle |
| Cchrono::vehicle::mrole::mrole_PitmanArmShafts | Pitman-arm with compliant column steering subsystem for the mrole vehicle |
| ►Cchrono::vehicle::ChRackPinion | Base class for a Rack-Pinion steering subsystem |
| Cchrono::vehicle::citybus::CityBus_RackPinion | Rack-pinion steering subsystem for the CityBus vehicle |
| Cchrono::vehicle::gator::Gator_RackPinion | Rack-pinion steering subsystem for the Gator vehicle |
| Cchrono::vehicle::generic::Generic_RackPinion | Rack-pinion steering model for a generic vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_RackPinion | Rack-pinion steering subsystem for the HMMWV vehicle |
| Cchrono::vehicle::mrole::mrole_RackPinion1 | Rack-pinion steering subsystem for the mrole vehicle, first axle |
| Cchrono::vehicle::mrole::mrole_RackPinion2 | Rack-pinion steering subsystem for the mrole vehicle, second axle |
| Cchrono::vehicle::RackPinion | Rack-pinion steering model constructed with data from file (JSON format) |
| Cchrono::vehicle::sedan::Sedan_RackPinion | Rack-pinion steering subsystem for the Sedan vehicle |
| ►Cchrono::vehicle::ChRotaryArm | Base class for a Toe Bar steering subsystem |
| Cchrono::vehicle::fmtv::FMTV_RotaryArm | RotaryArm steering subsystem for the FMTV vehicles |
| Cchrono::vehicle::kraz::Kraz_tractor_Steering | RotaryArm steering subsystem for the Kraz tractor |
| Cchrono::vehicle::man::MAN_10t_RotaryArm2 | RotaryArm steering subsystem for the uaz vehicle |
| Cchrono::vehicle::man::MAN_5t_RotaryArm | RotaryArm steering subsystem for the uaz vehicle |
| Cchrono::vehicle::RotaryArm | RotaryArm-pinion steering model constructed with data from file (JSON format) |
| Cchrono::vehicle::uaz::UAZBUS_RotaryArm | RotaryArm steering subsystem for the uaz vehicle |
| ►Cchrono::vehicle::ChSubchassis | Base class for a sub-chassis system for wheeled vehicles |
| ►Cchrono::vehicle::ChBalancer | Template for a balancer subchassis system |
| Cchrono::vehicle::Balancer | Balancer subchassis system constructed with data from file |
| Cchrono::vehicle::fmtv::MTV_Balancer | MTV balancer subsystem (installed on rear chassis) |
| ►Cchrono::vehicle::ChSuspension | Base class for a suspension subsystem |
| ►Cchrono::vehicle::ChDoubleWishbone | Base class for a double-A arm suspension modeled with bodies and constraints |
| Cchrono::vehicle::DoubleWishbone | Double-A arm suspension constructed with data from file |
| Cchrono::vehicle::feda::FEDA_DoubleWishboneFront | Full double wishbone front suspension for the FEDA vehicle |
| Cchrono::vehicle::feda::FEDA_DoubleWishboneRear | Full double wishbone rear suspension for the FEDA vehicle |
| Cchrono::vehicle::generic::Generic_DoubleWishbone | Double wishbone suspension model for a generic vehicle (can be used in front or rear) |
| Cchrono::vehicle::generic::Generic_DoubleWishboneFront | Double wishbone suspension model for a generic vehicle (front) |
| Cchrono::vehicle::generic::Generic_DoubleWishboneRear | Double wishbone suspension model for a generic vehicle (rear) |
| Cchrono::vehicle::hmmwv::HMMWV_DoubleWishboneFront | Full double wishbone front suspension for the HMMWV vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_DoubleWishboneRear | Full double wishbone rear suspension for the HMMWV vehicle |
| Cchrono::vehicle::mrole::mrole_DoubleWishboneFront | Full double wishbone front suspension for the mrole vehicle |
| Cchrono::vehicle::mrole::mrole_DoubleWishboneRear | Full double wishbone rear suspension for the mrole vehicle |
| Cchrono::vehicle::rccar::RCCar_DoubleWishboneFront | Full double wishbone front suspension for the RCCar vehicle |
| Cchrono::vehicle::rccar::RCCar_DoubleWishboneRear | Full double wishbone rear suspension for the RCCar vehicle |
| Cchrono::vehicle::sedan::Sedan_DoubleWishbone | Double wishbone suspension model for a sedan vehicle (can be used in front or rear) |
| ►Cchrono::vehicle::ChDoubleWishboneReduced | Base class for a double-A arm suspension modeled with distance constraints |
| Cchrono::vehicle::DoubleWishboneReduced | Reduced double-A arm suspension constructed with data from file |
| Cchrono::vehicle::hmmwv::HMMWV_DoubleWishboneReducedFront | Reduced double wishbone front suspension for the HMMWV vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_DoubleWishboneReducedRear | Reduced double wishbone rear suspension for the HMMWV vehicle |
| Cchrono::vehicle::mrole::mrole_DoubleWishboneReducedFront | Reduced double wishbone front suspension for the mrole vehicle |
| Cchrono::vehicle::mrole::mrole_DoubleWishboneReducedRear | Reduced double wishbone rear suspension for the mrole vehicle |
| ►Cchrono::vehicle::ChHendricksonPRIMAXX | Base class for a Hendrickson PRIMAXX EX suspension |
| Cchrono::vehicle::generic::Generic_HendricksonPRIMAXX | Hendrickson PRIMAXX suspension for a generic vehicle |
| Cchrono::vehicle::HendricksonPRIMAXX | Hendrickson PRIMAXX suspension constructed with data from file |
| ►Cchrono::vehicle::ChLeafspringAxle | Base class for a leaf-spring solid axle suspension |
| Cchrono::vehicle::fmtv::LMTV_LeafspringAxle | Leafspring axle subsystem for the LMTV vehicle |
| Cchrono::vehicle::fmtv::MTV_LeafspringAxle1 | 1st rear Leafspring axle subsystem for the MTV vehicle |
| Cchrono::vehicle::fmtv::MTV_LeafspringAxle2 | 2nd rear Leafspring axle subsystem for the MTV vehicle |
| Cchrono::vehicle::kraz::Kraz_tractor_RearSuspension | Leafspring rear axle subsystem for the Kraz tractor |
| Cchrono::vehicle::kraz::Kraz_trailer_Suspension | Leafspring axle subsystem for the Kraz trailer |
| Cchrono::vehicle::LeafspringAxle | Leaf-spring solid axle suspension constructed with data from file |
| Cchrono::vehicle::uaz::UAZBUS_LeafspringAxle | Leafspring axle subsystem for the uaz vehicle |
| ►Cchrono::vehicle::ChMacPhersonStrut | Base class for a MacPherson strut modeled with bodies and constraints |
| Cchrono::vehicle::generic::Generic_MacPhersonStrut | MacPherson strut suspension for a generic vehicle |
| Cchrono::vehicle::MacPhersonStrut | MacPherson strut suspension constructed with data from file |
| ►Cchrono::vehicle::ChMultiLink | Base class for a multi-link suspension modeled with bodies and constraints |
| Cchrono::vehicle::generic::Generic_MultiLink | Multi-link suspension for a generic vehicle |
| Cchrono::vehicle::MultiLink | Multi-link suspension constructed with data from file |
| Cchrono::vehicle::sedan::Sedan_MultiLink | Multi-link suspension for a sedan vehicle |
| ►Cchrono::vehicle::ChRigidPinnedAxle | Base class for a rigid suspension with a pinned axle |
| Cchrono::vehicle::generic::Generic_RigidPinnedAxle | Rigid pinned axle suspension for a generic vehicle (spindles attached to a rigid axle) |
| Cchrono::vehicle::RigidPinnedAxle | Rigid suspension with pinned axle constructed with data from file |
| ►Cchrono::vehicle::ChRigidSuspension | Base class for a rigid suspension, i.e |
| Cchrono::vehicle::gator::Gator_RigidSuspension | Rigid suspension for the Gator vehicle (spindles directly attached to chassis) |
| Cchrono::vehicle::generic::Generic_RigidSuspension | Rigid suspension for a generic vehicle (spindles directly attached to chassis) |
| Cchrono::vehicle::RigidSuspension | Rigid suspension constructed with data from file |
| ►Cchrono::vehicle::ChSAELeafspringAxle | Base class for a leaf-spring solid axle suspension |
| Cchrono::vehicle::SAELeafspringAxle | Leaf-spring solid axle suspension constructed with data from file |
| Cchrono::vehicle::uaz::UAZBUS_SAELeafspringAxle | Leafspring axle subsystem for the uaz vehicle |
| ►Cchrono::vehicle::ChSemiTrailingArm | Base class for a semi-trailing arm suspension (non-steerable) |
| Cchrono::vehicle::SemiTrailingArm | Semi-trailing arm suspension constructed with data from file |
| ►Cchrono::vehicle::ChSingleWishbone | Base class for a double-A arm suspension modeled with bodies and constraints |
| Cchrono::vehicle::gator::Gator_SingleWishbone | Single wishbone suspension model for the Gator vehicle (front) |
| Cchrono::vehicle::SingleWishbone | Single A-arm suspension constructed with data from file |
| ►Cchrono::vehicle::ChSolidAxle | Base class for a solid axle suspension modeled with bodies and constraints |
| Cchrono::vehicle::citybus::CityBus_SolidAxleFront | Solid-axle suspension subsystem for the city bus vehicle |
| Cchrono::vehicle::citybus::CityBus_SolidAxleRear | Solid-axle rear suspension subsystem for the city bus vehicle |
| Cchrono::vehicle::generic::Generic_SolidAxle | Solid-axle suspension subsystem for the generic vehicle |
| Cchrono::vehicle::SolidAxle | Solid axle suspension constructed with data from file |
| ►Cchrono::vehicle::ChSolidBellcrankThreeLinkAxle | Base class for a coil-spring or air-spring solid axle suspension, typically combined with the rotary arm steering |
| Cchrono::vehicle::SolidBellcrankThreeLinkAxle | Solid axle suspension constructed with data from file |
| ►Cchrono::vehicle::ChSolidThreeLinkAxle | Base class for a coil-spring or air-spring solid axle suspension |
| Cchrono::vehicle::SolidThreeLinkAxle | Leaf-spring solid axle suspension constructed with data from file |
| ►Cchrono::vehicle::ChThreeLinkIRS | Base class for a 3-link independent rear suspension (non-steerable) |
| Cchrono::vehicle::ThreeLinkIRS | Three-link Independent Rear Suspension constructed with data from file |
| ►Cchrono::vehicle::ChToeBarLeafspringAxle | Base class for a steerable leaf-spring solid axle suspension |
| Cchrono::vehicle::fmtv::FMTV_ToebarLeafspringAxle | Toebar leafspring front axle subsystem for the FMTV vehicles |
| Cchrono::vehicle::kraz::Kraz_tractor_FrontSuspension | Leafspring front axle subsystem for the Kraz tractor |
| Cchrono::vehicle::ToeBarLeafspringAxle | Steerable leaf-spring solid axle suspension constructed with data from file |
| Cchrono::vehicle::uaz::UAZBUS_ToeBarLeafspringAxle | Leafspring axle subsystem for the uaz vehicle |
| ►Cchrono::vehicle::ChTire | Base class for a tire system |
| ►Cchrono::vehicle::ChDeformableTire | Base class for a deformable tire model |
| ►Cchrono::vehicle::ChANCFTire | ANCF tire template |
| Cchrono::vehicle::ANCFTire | ANCF tire constructed with data from file (JSON format) |
| Cchrono::vehicle::hmmwv::HMMWV_ANCFTire | Deformable tire model for the HMMWV vehicle (using ANCF shell FEA elements) |
| ►Cchrono::vehicle::ChFEATire | Co-rotational FEA tire template |
| Cchrono::vehicle::FEATire | Co-rotational FEA tire constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChReissnerTire | Tire template for tires based on Reissner shells |
| Cchrono::vehicle::hmmwv::HMMWV_ReissnerTire | Deformable tire model for the HMMWV vehicle (using Reissner shell FEA elements) |
| Cchrono::vehicle::ReissnerTire | Tire with Reissner shells, constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChFialaTire | Fiala based tire model |
| Cchrono::vehicle::FialaTire | Fiala tire constructed with data from file (JSON format) |
| Cchrono::vehicle::generic::Generic_FialaTire | Fiala tire model for a generic vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_FialaTire | Fiala tire model for the HMMWV vehicle |
| ►Cchrono::vehicle::ChLugreTire | Tire model based on LuGre friction model |
| Cchrono::vehicle::hmmwv::HMMWV_LugreTire | Lugre tire model for the HMMWV vehicle |
| Cchrono::vehicle::LugreTire | LuGre tire constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChPac02Tire | Pacjeka 02 tire model |
| Cchrono::vehicle::citybus::CityBus_Pac02Tire | PAC89 tire model for the CityBus vehicle |
| Cchrono::vehicle::feda::FEDA_Pac02Tire | PAC02 tire model for the FEDA vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_Pac02Tire | PAC89 tire model for the HMMWV vehicle |
| Cchrono::vehicle::Pac02Tire | PAC89 tire model from JSON file |
| Cchrono::vehicle::sedan::Sedan_Pac02Tire | PAC89 tire model for the Sedan vehicle |
| Cchrono::vehicle::uaz::UAZBUS_Pac02Tire | PAC02 tire model for the UAZBUS vehicle |
| ►Cchrono::vehicle::ChPac89Tire | Pacjeka 89 tire model |
| Cchrono::vehicle::hmmwv::HMMWV_Pac89Tire | PAC89 tire model for the HMMWV vehicle |
| Cchrono::vehicle::Pac89Tire | PAC89 tire model from JSON file |
| ►Cchrono::vehicle::ChPacejkaTire | Concrete tire class that implements the Pacejka tire model |
| Cchrono::vehicle::hmmwv::HMMWV_PacejkaTire | Pacejka 2002 tire model for the HMMWV vehicle |
| Cchrono::vehicle::PacejkaTire | Pacejka tire constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChRigidTire | Rigid tire model |
| Cchrono::vehicle::citybus::CityBus_RigidTire | Rigid tire model for the CityBus vehicle |
| Cchrono::vehicle::feda::FEDA_RigidTire | Rigid tire model for the FEDA vehicle |
| Cchrono::vehicle::fmtv::FMTV_RigidTire | Rigid tire model for the FMTV vehicles |
| Cchrono::vehicle::gator::Gator_RigidTire_Front | Rigid tire model for the Gator vehicle (front) |
| Cchrono::vehicle::gator::Gator_RigidTire_Rear | Rigid tire model for the Gator vehicle (rear) |
| Cchrono::vehicle::generic::Generic_RigidMeshTire | Rigid tire model (mesh contact) for the generic vehicle |
| Cchrono::vehicle::generic::Generic_RigidTire | Rigid tire model for the generic vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_RigidTire | Rigid tire model for the HMMWV vehicle |
| Cchrono::vehicle::mrole::mrole_RigidTire | Rigid tire model for the mrole vehicle |
| Cchrono::vehicle::rccar::RCCar_RigidTire | Rigid tire model for the RCCar vehicle |
| Cchrono::vehicle::RigidTire | Rigid tire constructed with data from file (JSON format) |
| Cchrono::vehicle::sedan::Sedan_RigidTire | Rigid tire model for the Sedan vehicle |
| Cchrono::vehicle::uaz::UAZBUS_RigidTire | Rigid tire model for the UAZBUS vehicle |
| ►Cchrono::vehicle::ChTMeasyTire | TMeasy tire model |
| Cchrono::vehicle::citybus::CityBus_TMeasyTire | TMeasy tire model for the Citybus vehicle |
| Cchrono::vehicle::fmtv::FMTV_TMeasyTire | TMeasy tire model for the FMTV vehicles |
| Cchrono::vehicle::gator::Gator_TMeasyTire_Front | TMeasy tire model for the Gator (front) |
| Cchrono::vehicle::gator::Gator_TMeasyTire_Rear | TMeasy tire model for the Gator (rear) |
| Cchrono::vehicle::hmmwv::HMMWV_TMeasyTire | TMeasy tire model for the HMMWV |
| Cchrono::vehicle::kraz::Kraz_tractor_Tire | TMeasy tire model for the Kraz tractor |
| Cchrono::vehicle::kraz::Kraz_trailer_Tire | TMeasy tire model for the Kraz trailer |
| Cchrono::vehicle::man::MAN_5t_TMeasyTire | TMeasy tire model for the MAN 5t truck vehicle |
| Cchrono::vehicle::mrole::mrole_TMeasyTire | TMeasy tire model for the mrole, for ON ROAD operation |
| Cchrono::vehicle::mrole::mrole_TMeasyTireSand | TMeasy tire model for the mrole, for OFFROAD operation on deformable sand |
| Cchrono::vehicle::mrole::mrole_TMeasyTireSoil | TMeasy tire model for the mrole, for OFFROAD operation on deformable soils |
| Cchrono::vehicle::rccar::RCCar_TMeasyTire | TMeasy tire model for the RCCAR |
| Cchrono::vehicle::sedan::Sedan_TMeasyTire | TMeasy tire model for the Sedan vehicle |
| Cchrono::vehicle::TMeasyTire | TMeasy tire constructed with data from file (JSON format) |
| Cchrono::vehicle::uaz::UAZBUS_TMeasyTireFront | TMeasy tire model for the UAZBUS (front) |
| Cchrono::vehicle::uaz::UAZBUS_TMeasyTireRear | TMeasy tire model for the UAZBUS (front) |
| ►Cchrono::vehicle::ChTrackAssembly | Definition of a track assembly |
| ►Cchrono::vehicle::ChTrackAssemblyBand | Definition of a continuous band track assembly |
| ►Cchrono::vehicle::ChTrackAssemblyBandANCF | Definition of a continuous band track assembly using an ANCFshell-based web A track assembly consists of a sprocket, an idler (with tensioner mechanism), a set of suspensions (road-wheel assemblies), and a collection of track shoes |
| Cchrono::vehicle::m113::M113_TrackAssemblyBandANCF | M113 continuous band track assembly subsystem using rigid-link track shoes |
| Cchrono::vehicle::TrackAssemblyBandANCF | Band-ANCF track assembly model constructed from a JSON specification file |
| ►Cchrono::vehicle::ChTrackAssemblyBandBushing | Definition of a continuous band track assembly using a bushing-based web A track assembly consists of a sprocket, an idler (with tensioner mechanism), a set of suspensions (road-wheel assemblies), and a collection of track shoes |
| Cchrono::vehicle::m113::M113_TrackAssemblyBandBushing | M113 continuous band track assembly subsystem using rigid-link track shoes |
| Cchrono::vehicle::TrackAssemblyBandBushing | Band-bushing track assembly model constructed from a JSON specification file |
| ►Cchrono::vehicle::ChTrackAssemblySegmented | Base class for segmented track assemblies |
| ►Cchrono::vehicle::ChTrackAssemblyDoublePin | Definition of a double-pin track assembly |
| Cchrono::vehicle::m113::M113_TrackAssemblyDoublePin | M113 track assembly using double-pin track shoes |
| Cchrono::vehicle::TrackAssemblyDoublePin | Double-pin track assembly model constructed from a JSON specification file |
| ►Cchrono::vehicle::ChTrackAssemblySinglePin | Definition of a single-pin track assembly |
| Cchrono::vehicle::m113::M113_TrackAssemblySinglePin | M113 track assembly using single-pin track shoes |
| Cchrono::vehicle::marder::Marder_TrackAssemblySinglePin | Marder track assembly using single-pin track shoes |
| Cchrono::vehicle::TrackAssemblySinglePin | Single-pin track assembly model constructed from a JSON specification file |
| ►Cchrono::vehicle::ChTrackBrake | Base class for a tracked vehicle brake subsystem |
| ►Cchrono::vehicle::ChTrackBrakeShafts | Brake for tracked vehicles modeled using a clutch between two shafts |
| Cchrono::vehicle::m113::M113_BrakeShafts | Shafts-based M113 brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::marder::Marder_BrakeShafts | Shafts-based Marder brake subsystem (uses a clutch between two shafts) |
| Cchrono::vehicle::TrackBrakeShafts | Tracked vehicle shafts-based brake model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChTrackBrakeSimple | Simple brake created with constant torque opposing sprocket rotation |
| Cchrono::vehicle::m113::M113_BrakeSimple | Simple M113 brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::marder::Marder_BrakeSimple | Simple M113 brake subsystem (torque applied directly to the spindle joint) |
| Cchrono::vehicle::TrackBrakeSimple | Tracked vehicle simple brake model constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChTrackShoe | Base class for a track shoe |
| ►Cchrono::vehicle::ChTrackShoeBand | Base class for continuous band track shoes using rigid treads |
| ►Cchrono::vehicle::ChTrackShoeBandANCF | Base class for a continuous band track shoe using an ANCFshell-based web |
| Cchrono::vehicle::m113::M113_TrackShoeBandANCF | Continuous band rigid-link track shoe subsystem for the M113 vehicle |
| Cchrono::vehicle::TrackShoeBandANCF | Band-ANCF track shoe with central guide constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChTrackShoeBandBushing | Base class for a continuous band track shoe using a bushing-based web |
| Cchrono::vehicle::m113::M113_TrackShoeBandBushing | Continuous band rigid-link track shoe subsystem for the M113 vehicle |
| Cchrono::vehicle::TrackShoeBandBushing | Band-bushing track shoe with central guide constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChTrackShoeSegmented | Base class for segmented track shoes |
| ►Cchrono::vehicle::ChTrackShoeDoublePin | Base class for a double-pin track shoe (template definition) |
| Cchrono::vehicle::m113::M113_TrackShoeDoublePin | Double-pin track shoe subsystem for the M113 vehicle |
| Cchrono::vehicle::TrackShoeDoublePin | Double-pin track shoe with central guide constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChTrackShoeSinglePin | Base class for a single-pin track shoe (template definition) |
| Cchrono::vehicle::m113::M113_TrackShoeSinglePin | Single-pin track shoe subsystem for the M113 vehicle |
| Cchrono::vehicle::marder::Marder_TrackShoeSinglePin | Single-pin track shoe subsystem for the Marder vehicle |
| Cchrono::vehicle::TrackShoeSinglePin | Single-pin track shoe with central guide constructed with data from file (JSON format) |
| ►Cchrono::vehicle::ChWheel | Base class for a vehicle wheel subsystem |
| Cchrono::vehicle::citybus::CityBus_Wheel | CityBus wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::feda::FEDA_Wheel | FEDA wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::fmtv::FMTV_Wheel | FMTV wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::gator::Gator_Wheel | Gator wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::generic::Generic_Wheel | Wheel subsystem for the generic vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_Wheel | HMMWV wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::kraz::Kraz_tractor_Wheel | Kraz tractor wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::kraz::Kraz_trailer_Wheel | Kraz trailer wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::man::MAN_5t_Wheel | MAN wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::mrole::mrole_Wheel | Mrole wheel (can be used on any axle, left or right) |
| ►Cchrono::vehicle::rccar::RCCar_Wheel | RCCar wheel base class |
| Cchrono::vehicle::rccar::RCCar_WheelLeft | RCCar left wheel (front or rear) |
| Cchrono::vehicle::rccar::RCCar_WheelRight | RCCar right wheel (front or rear) |
| Cchrono::vehicle::sedan::Sedan_Wheel | Sedan wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::uaz::UAZBUS_Wheel | UAZBUS wheel (can be used on any axle, left or right) |
| Cchrono::vehicle::Wheel | Vehicle wheel constructed with data from file (JSON format) |
| Cchrono::particlefactory::ChParticleEmitter | Class for emitters of particles, with random positions, rotations, and random shapes |
| ►Cchrono::particlefactory::ChParticleEventTrigger | BASE class for event triggers for the ChParticleProcessor You can directly use the ready-to-use triggers for common triggering (particle collides with some object, particle inside a box, etc.), or inherit your own class with custom triggering |
| Cchrono::particlefactory::ChParticleEventFlowInRectangle | Trigger an event each time a particle flows into a rectangle |
| Cchrono::particlefactory::ChParticleEventTriggerBox | This can be used to trigger events when particles are inside a box volume |
| Cchrono::particlefactory::ChParticleEventTriggerNever | Simplest case: never trigger |
| ►Cchrono::particlefactory::ChParticleProcessEvent | BASE class for all event processors of single particles You can directly use the ready-to-use processor for basic behaviors (remove particle, count particle, etc.), or inherit your own class with custom event processing |
| Cchrono::particlefactory::ChParticleProcessEventCount | Processed particle will be counted |
| Cchrono::particlefactory::ChParticleProcessEventDoNothing | Simplest case: no event processing Just an example |
| Cchrono::particlefactory::ChParticleProcessEventMassCount | Processed particle will increment a mass counter |
| Cchrono::particlefactory::ChParticleProcessEventMassDistribution | Processed particle will increment a NxM matrix mass counter, so that a statistical distribution of flow over a uv surface can be obtained |
| Cchrono::particlefactory::ChParticleProcessEventRemove | Processed particle will be removed |
| ►Cchrono::particlefactory::ChParticleProcessor | Class that can be used to process particles |
| Cchrono::particlefactory::ChParticleRemoverBox | Utility class: shortcut for creating a ChParticleProcessor that already contains a ChParticleEventTriggerBox and a ChParticleProcessEventRemove |
| ►Cchrono::fea::ChPlasticityCosserat | Base class for plasticity of beam sections of Cosserat type |
| Cchrono::fea::ChPlasticityCosseratLumped | Lumped plasticity of Cosserat-type beams |
| Cchrono::fea::ChPlasticityKirchhoff | Base interface for plasticity of thin shells (Kirchoff-Love shell theory, without shear effects) to be used in a ChMaterialShellKirchhoff |
| Cchrono::fea::ChPlasticityReissner | Base interface for plasticity of 6-field Reissner-Mindlin shells (kinematically-exact shell theory as in Witkowski et al.) to be used in a ChMaterialShellReissner |
| Cchrono::fea::ChPolarDecomposition< Real > | Perform a polar decomposition of a 3x3 P matrix in order to retrieve the orthogonal Q and the symmetric S form, as P=Q*S |
| ►Cchrono::postprocess::ChPostProcessBase | Base class for post processing implementations |
| Cchrono::postprocess::ChPovRay | Class for post processing implementation that generates scripts for POVray |
| Cchrono::utils::ChProfileIterator | An iterator to navigate through the tree |
| Cchrono::utils::ChProfileManager | The Manager for the Profile system |
| Cchrono::utils::ChProfileNode | A node in the Profile Hierarchy Tree |
| ►Cchrono::ChProjectConstraints | Functor class for performing projection on the hyper-cone |
| Cchrono::ChProjectNone | Functor class for performing a single cone projection |
| Cchrono::ChProximityMeshless | Class for a proximity pair information in a meshless deformable continumm, made with a cluster of particles - that is, an 'edge' topological connectivity in in a meshless FEA approach, similar to the Smoothed Particle Hydrodynamics |
| Cchrono::ChProximitySPH | Class for a proximity pair information in a SPH cluster of particles - that is, an 'edge' topological connectivity in in a meshless FEA approach, like the Smoothed Particle Hydrodynamics |
| Cchrono::ChPythonEngine | Class for a Python parser |
| Cchrono::ChQuadrature | Class to perform Gauss-Legendre quadrature, in 1D, 2D, 3D |
| Cchrono::ChQuadratureTables | Class to store polynomial roots and weights for the Gauss-Legendre quadrature |
| Cchrono::ChQuadratureTablesTetrahedron | Class to store polynomial roots and weights for quadrature over a tetrahedron |
| Cchrono::ChQuadratureTablesTriangle | Class to store polynomial roots and weights for quadrature over a triangle |
| Cchrono::ChQuaternion< Real > | Class defining quaternion objects, that is four-dimensional numbers, also known as Euler parameters |
| Cchrono::ChQuaternion< double > | |
| ►Cchrono::particlefactory::ChRandomParticleAlignment | BASE class for generators of random particle alignment |
| Cchrono::particlefactory::ChRandomParticleAlignmentUniform | Class for generator of random particle alignment |
| ►Cchrono::particlefactory::ChRandomParticlePosition | BASE class for generators of random particle positions |
| Cchrono::particlefactory::ChRandomParticlePositionOnGeometry | Class for generator of random particle positions scattered over a parametric surface |
| Cchrono::particlefactory::ChRandomParticlePositionRectangleOutlet | Class for generator of random particle positions scattered over a rectangle outlet in 3D space |
| ►Cchrono::particlefactory::ChRandomParticleVelocity | BASE class for generators of random particle velocities |
| Cchrono::particlefactory::ChRandomParticleVelocityAnyDirection | Generator of random particle velocities with any direction |
| Cchrono::particlefactory::ChRandomParticleVelocityConstantDirection | Generator of random particle velocities with constant direction |
| ►Cchrono::particlefactory::ChRandomShapeCreator | BASE class for generators of random ChBody shapes |
| Cchrono::particlefactory::ChRandomShapeCreatorBoxes | Class for generating boxes with variable sizes and density |
| Cchrono::particlefactory::ChRandomShapeCreatorConvexHulls | Class for generating convex hulls with variable chordal size and aspect ratios |
| Cchrono::particlefactory::ChRandomShapeCreatorCylinders | Class for generating cylinders with variable diameter and length |
| Cchrono::particlefactory::ChRandomShapeCreatorFromFamilies | Class for generating spheres from different families, each with given probability |
| Cchrono::particlefactory::ChRandomShapeCreatorShavings | Class for generating worm-like particles, optionally helically twisted |
| Cchrono::particlefactory::ChRandomShapeCreatorSpheres | Class for generating spheres with variable radius and density |
| Cchrono::collision::ChCollisionSystem::ChRayhitResult | Recover results from RayHit() raycasting |
| Cchrono::collision::ChRayTest | Class for performing ray intersection tests |
| Cchrono::geometry::ChTriangleMeshConnected::ChRefineEdgeCriterion | Class to be used optionally in RefineMeshEdges() |
| Cchrono::fsi::ChronoBodiesDataH | Struct to store Chrono rigid bodies information on the host |
| Cchrono::fsi::ChronoMeshDataH | Struct to store Chrono mesh information on the host |
| Cchrono::fsi::ChronoShellsDataH | Struct to store Chrono shell elements information on the host |
| Cchrono::utils::ChRunningAverage | Moving average filter for smoothing running data |
| Cchrono::sensor::ChScene | Scene class used for camera renderings. Includes environment colors, lights, etc |
| ►Cchrono::sensor::ChSensor | Base class for a chrono sensor. A specific sensor can inherit from here |
| ►Cchrono::sensor::ChOptixSensor | Optix sensor class - the base class for all sensors that interface with OptiX to generate and render their data |
| Cchrono::sensor::ChCameraSensor | Camera class |
| Cchrono::sensor::ChLidarSensor | Lidar class. This corresponds to a scanning lidar |
| Cchrono::sensor::ChRadarSensor | Radar Class/ This corresponds to a fmcw radar |
| Cchrono::sensor::ChSegmentationCamera | Camera class |
| Cchrono::sensor::Sensor | Sensor class for constructing sensors from a JSON specification file |
| Cchrono::sensor::ChSensorManager | Class for managing sensors. This is the Sensor system class |
| Cchrono::ChSharedMassBody | Used by ChVariablesBodySharedMass objects to reference a single mass property |
| Cchrono::fea::ChShellKirchhoffInternalData | Base class for internal variables of Kirchhoff thin shells materials |
| Cchrono::fea::ChShellReissnerInternalData | Base class for internal variables of Reissner shells materials |
| ►Cchrono::ChShurProduct | Functor class for calculating the Shur product of the matrix of unilateral constraints |
| Cchrono::ChShurProductBilateral | Functor class for performing the Shur product of the matrix of bilateral constraints |
| ►Cchrono::cosimul::ChSocket | Base class for sockets |
| Cchrono::cosimul::ChSocketTCP | This is a specialized type of socket: the TCP socket |
| Cchrono::cosimul::ChSocketFramework | A single object of this class must be instantiated before using all classes related to sockets, because it initializes some platform-specific settings |
| ►Cchrono::ChSolver | Base class for all Chrono solvers (for linear problems or complementarity problems) |
| ►Cchrono::ChSolverLS | Base class for solvers aimed at solving linear systems |
| ►Cchrono::ChDirectSolverLS | Base class for sparse direct linear solvers |
| Cchrono::ChSolverMumps | Interface to the MUMPS parallel sparse direct solver |
| Cchrono::ChSolverPardisoMKL | Interface to the Intel MKL Pardiso parallel sparse direct solver |
| Cchrono::ChSolverPardisoProject | Interface to the Pardiso Project sparse direct solver |
| Cchrono::ChSolverSparseLU | Sparse LU direct solver |
| Cchrono::ChSolverSparseQR | Sparse QR direct solver |
| Cchrono::ChIterativeSolverLS | Base class for Chrono solvers based on Eigen iterative linear solvers |
| ►Cchrono::ChSolverVI | Base class for solvers aimed at solving complementarity problems arising from QP optimization problems |
| Cchrono::ChIterativeSolverVI | Base class for iterative solvers aimed at solving complementarity problems arising from QP optimization problems |
| ►Cchrono::ChSolverMulticore | Base class for all Chrono::Multicore solvers |
| Cchrono::ChSolverMulticoreAPGD | Accelerated Projected Gradient Descent (APGD) solver |
| Cchrono::ChSolverMulticoreAPGDREF | Accelerated Projected Gradient Descent (APGD) solver. Reference implementation |
| Cchrono::ChSolverMulticoreBB | Barzilai-Borwein solver |
| Cchrono::ChSolverMulticoreCG | Conjugate gradient solver |
| Cchrono::ChSolverMulticoreGS | Gauss Seidel solver |
| Cchrono::ChSolverMulticoreJacobi | Jacobi solver |
| Cchrono::ChSolverMulticoreMinRes | MINRES solver |
| Cchrono::ChSolverMulticoreSPGQP | Spectral Projected Gradient solver |
| Cchrono::gpu::ChSolverStateData | ChSolverStateData contains information that pertains the solver, at a certain point in time |
| Cchrono::ChSparsityPatternLearner | Utility class for extracting sparsity patter from a sparse matrix |
| Cchrono::vehicle::ChSpeedController | Data collection from the speed controller can be started (restarted) and suspended (stopped) as many times as desired |
| Cchrono::ChStarMatrix33< Real > | Special MBD 3x3 "star" matrix, , representing vector cross products |
| Cchrono::ChStarMatrix44< Real > | Special MBD 4x4 "star" matrix, representing quaternion cross product |
| Cchrono::ChState | Class for state of time-integrable objects |
| Cchrono::ChStateDelta | Class for incremental form of state of time-integrable objects |
| ►Cchrono::ChStaticAnalysis | Base class for static analysis |
| Cchrono::ChStaticLinearAnalysis | Linear static analysis |
| Cchrono::ChStaticNonLinearAnalysis | Nonlinear static analysis |
| Cchrono::ChStaticNonLinearRheonomicAnalysis | Nonlinear static analysis for a mechanism that is rotating/moving in steady state |
| ►Cchrono::vehicle::ChSteeringController | Base class for all steering path-following PID controllers |
| Cchrono::synchrono::ChMultiplePathSteeringController | Concrete path-following steering PID controller with multiple path support |
| Cchrono::vehicle::ChPathSteeringController | Path-following steering PID controller |
| Cchrono::vehicle::ChPathSteeringControllerSR | Path-following steering P-like controller with variable path prediction |
| Cchrono::vehicle::ChPathSteeringControllerStanley | This is called the "Stanley" Controller named after an autonomous vehicle called Stanley |
| Cchrono::vehicle::ChPathSteeringControllerXT | Path-following steering 3(2) channel PDT1/PT1 controller |
| ►Cchrono::ChStream | This is a base class for input/output (streaming) |
| ►Cchrono::ChStreamIn | This is a base class for all INPUT streams |
| ►Cchrono::ChStreamInAscii | This is a base class for all ASCII INPUT streams, in the sense that number are formatted into readable strings, etc |
| Cchrono::ChStreamInAsciiFile | This is a specialized class for ASCII input on system's file, |
| Cchrono::ChStreamInAsciiVector | This is a specialized class for ASCII input from wrapped std::vector<char>, |
| Cchrono::ChStreamInBinary | This is a base class for all BINARY INPUT streams, in a way such that the stream is platform independent (see the 'little endian' stuff in 'floating point to persistent data' topics..) Defines some << operators from basic types, converting all them into calls to the Output() function |
| ►Cchrono::ChStreamOut | This is a base class for all OUTPUT streams |
| ►Cchrono::ChStreamOutAscii | This is a base class for all ASCII OUTPUT streams, in the sense that number are formatted into readable strings, etc |
| ►Cchrono::ChLog | Base class for output of errors, messages, warnings, etc |
| Cchrono::ChLogConsole | Specialized class for logging errors in std::cout |
| ►Cchrono::ChStreamOutAsciiFile | This is a specialized class for ASCII output on system's file, |
| Cchrono::ChFile_ps | Class for postScript(TM) output |
| Cchrono::ChStreamOutAsciiVector | This is a specialized class for ASCII output to wrapped std::vector<char>, |
| Cchrono::ChStreamOutBinary | This is a base class for all BINARY OUTPUT streams, in a way such that the stream is platform independent (see the 'little endian' stuff in 'floating point to persistent data' topics..) Defines some << operators from basic types, converting all them into calls to the Output() function |
| ►Cchrono::ChStreamFile | This is a base class for typical output on system's file, on a disk, using the typical C++ 'fstream' handler |
| Cchrono::ChStreamInAsciiFile | This is a specialized class for ASCII input on system's file, |
| Cchrono::ChStreamInBinaryFile | This is a specialized class for BINARY input on system's file, |
| Cchrono::ChStreamOutAsciiFile | This is a specialized class for ASCII output on system's file, |
| Cchrono::ChStreamOutBinaryFile | This is a specialized class for BINARY output on system's file, |
| ►Cchrono::ChStreamIstreamWrapper | This is a wrapper for already-opened std::istream input streams |
| Cchrono::ChStreamInBinaryStream | This is a specialized class for BINARY input from wrapped std::istream, |
| ►Cchrono::ChStreamOstreamWrapper | This is a wrapper for already-opened std::ostream output streams (like std::cout or similar) |
| Cchrono::ChLogConsole | Specialized class for logging errors in std::cout |
| Cchrono::ChStreamOutBinaryStream | This is a specialized class for BINARY output to wrapped std::ostream, |
| ►Cchrono::ChStreamVectorWrapper | This is a wrapper for a std::vector<char> (buffer of chars) |
| Cchrono::ChStreamInAsciiVector | This is a specialized class for ASCII input from wrapped std::vector<char>, |
| Cchrono::ChStreamInBinaryVector | This is a specialized class for BINARY input from wrapped std::vector<char>, |
| Cchrono::ChStreamOutAsciiVector | This is a specialized class for ASCII output to wrapped std::vector<char>, |
| Cchrono::ChStreamOutBinaryVector | This is a specialized class for BINARY output to wrapped std::vector<char>, |
| ►Cchrono::ChSystemDescriptor | Base class for collecting objects inherited from ChConstraint, ChVariables and optionally ChKblock |
| Cchrono::ChSystemDescriptorMulticore | System descriptor for Chrono::Multicore |
| Cchrono::fsi::ChSystemFsi | Physical system for fluid-solid interaction problems |
| ►Cchrono::gpu::ChSystemGpu | Interface to a Chrono::Gpu system |
| Cchrono::gpu::ChSystemGpuMesh | Interface to a Chrono::Gpu mesh system |
| Cchrono::sensor::ChTachometerSensor | Tachometer class. This class queries the chrono system for the angular velocity of the parent body |
| ►Cchrono::vehicle::ChTerrain | Base class for a terrain system |
| Cchrono::vehicle::CRGTerrain | Concrete class for a (rigid) road loaded from an OpenCRG file |
| Cchrono::vehicle::FEADeformableTerrain | FEA Deformable terrain model |
| Cchrono::vehicle::FlatTerrain | Concrete class for a flat horizontal terrain |
| Cchrono::vehicle::GranularTerrain | Granular terrain model |
| Cchrono::vehicle::ObsModTerrain | Concrete class for a flat horizontal terrain |
| Cchrono::vehicle::RandomSurfaceTerrain | Terrain object representing an uneven area with controlled roughness |
| Cchrono::vehicle::RigidTerrain | Rigid terrain model |
| Cchrono::vehicle::SCMDeformableTerrain | Deformable terrain model |
| Cchrono::ChTimer< seconds_type > | Class for high-resolution timing |
| ►Cchrono::ChTimer< double > | |
| Cchrono::ChRealtimeStepTimer | Class for a timer which attempts to enforce soft real-time |
| Cchrono::ChTimerMulticore | Utility class for managing a collection of timer objects |
| ►Cchrono::ChTimestepper | Base class for timesteppers, i.e., time integrators that can advance a system state |
| ►Cchrono::ChTimestepperIIorder | Base class for 2nd order timesteppers, i.e., a time integrator for a ChIntegrableIIorder |
| Cchrono::ChTimestepperEulerExplIIorder | Euler explicit timestepper customized for II order |
| Cchrono::ChTimestepperEulerImplicit | Performs a step of Euler implicit for II order systems |
| Cchrono::ChTimestepperEulerImplicitLinearized | Performs a step of Euler implicit for II order systems using the Anitescu/Stewart/Trinkle single-iteration method, that is a bit like an implicit Euler where one performs only the first Newton corrector iteration |
| Cchrono::ChTimestepperEulerImplicitProjected | Performs a step of Euler implicit for II order systems using a semi implicit Euler without constraint stabilization, followed by a projection |
| Cchrono::ChTimestepperEulerSemiImplicit | Euler semi-implicit timestepper |
| Cchrono::ChTimestepperHHT | Implementation of the HHT implicit integrator for II order systems |
| Cchrono::ChTimestepperLeapfrog | Performs a step of a Leapfrog explicit integrator |
| Cchrono::ChTimestepperNewmark | Performs a step of Newmark constrained implicit for II order DAE systems |
| Cchrono::ChTimestepperTrapezoidal | Performs a step of trapezoidal implicit for II order systems |
| Cchrono::ChTimestepperTrapezoidalLinearized | Performs a step of trapezoidal implicit linearized for II order systems |
| Cchrono::ChTimestepperTrapezoidalLinearized2 | Performs a step of trapezoidal implicit linearized for II order systems |
| ►Cchrono::ChTimestepperIorder | Base class for 1st order timesteppers, that is a time integrator for a ChIntegrable |
| Cchrono::ChTimestepperEulerExpl | Euler explicit timestepper |
| Cchrono::ChTimestepperHeun | Performs a step of a Heun explicit integrator. It is like a 2nd Runge Kutta |
| Cchrono::ChTimestepperRungeKuttaExpl | Performs a step of a 4th order explicit Runge-Kutta integration scheme |
| Cchrono::vehicle::ChTireTestRig | Definition of a single-tire test rig |
| Cchrono::ChTransform< Real > | ChTransform: a class for fast coordinate transformations in 3D space |
| Cchrono::fea::ChTriangleOfXYZnodes | Utility class for using the ChLinkPointTriface constraint |
| Cchrono::fea::ChTriangleOfXYZROTnodes | Utility class for using the ChLinkPointTriface constraint |
| Cchrono::fsi::ChUtilsDevice | This utility class encapsulates a operators on device vectors which might be needed in host files |
| Cchrono::fsi::ChUtilsTypeConvert | Class for converting Chrono data structure to/from FSI data structure |
| Cchrono::utils::ChValidation | This class provides functionality for validation of simulation results |
| Cchrono::ChValue | Class that handle C++ values of generic type using type erasure and functors |
| ►Cchrono::ChVariables | Base class for representing objects that introduce 'variables' (also referred as 'v') and their associated mass submatrices for a sparse representation of the problem |
| ►Cchrono::ChVariablesBody | Specialized class for representing a 6-DOF item for a system, that is a 3D rigid body, with mass matrix and associate variables (a 6 element vector, ex.speed) This is an abstract class, specialized for example in ChVariablesBodyOwnMass and ChVariablesBodySharedMass |
| Cchrono::ChVariablesBodyOwnMass | Specialized class for representing a 6-DOF item for a system, that is a 3D rigid body, with mass matrix and associate variables (a 6 element vector, ex.speed) Differently from the 'naive' implementation ChVariablesGeneric, here a full 6x6 mass matrix is not built, since only the 3x3 inertia matrix and the mass value are enough |
| Cchrono::ChVariablesBodySharedMass | Specialized class for representing a 6-DOF item for a system, that is a 3D rigid body, with mass matrix and associate variables (a 6 element vector, ex.speed) Differently from the 'naive' implementation ChVariablesGeneric, here a full 6x6 mass matrix is not built, since only the 3x3 inertia matrix and the mass value are enough |
| Cchrono::ChVariablesGeneric | Specialized class for representing a N-DOF item for a system, that is an item with mass matrix and associate variables |
| Cchrono::ChVariablesGenericDiagonalMass | Specialized class for representing a N-DOF item for a system, that is an item with a diagonal mass matrix and associated variables |
| Cchrono::ChVariablesNode | Specialized class for representing a 3-DOF item for a system, that is a 3D point node, with mass matrix and associate variables (a 3 element vector, ex.speed) |
| Cchrono::ChVariablesShaft | Specialized class for representing a 1-DOF item for a system, that is a shaft, with inertia and associated variable (rotational speed) |
| Cchrono::ChVariableTupleCarrier_1vars< N1 > | This is a set of 'helper' classes that make easier to manage the templated structure of the tuple constraints |
| ►Cchrono::ChVariableTupleCarrier_1vars< 3 > | |
| Cchrono::fea::ChNodeFEAxyz | Class for a generic 3D finite element node, with x,y,z displacement |
| ►Cchrono::ChVariableTupleCarrier_1vars< 6 > | |
| Cchrono::fea::ChNodeFEAxyzrot | Class for a generic ED finite element node, with x,y,z displacement and a 3D rotation |
| Cchrono::ChVariableTupleCarrier_1vars< T1 > | |
| Cchrono::ChVector< Real > | Definition of general purpose 3d vector variables, such as points in 3D |
| Cchrono::ChVector2< Real > | Definition of a general purpose 2d vector |
| Cchrono::ChVector< double > | |
| Cchrono::ChVector< float > | |
| Cchrono::ChVector< T > | |
| ►Cchrono::vehicle::ChVehicle | Base class for chrono vehicle systems |
| ►Cchrono::vehicle::ChSuspensionTestRig | Base class for a suspension test rig |
| Cchrono::vehicle::ChSuspensionTestRigPlatform | Definition of a suspension test rig using platforms to actuate the tires |
| Cchrono::vehicle::ChSuspensionTestRigPushrod | Definition of a suspension test rig with direct actuation on the spindle bodies |
| ►Cchrono::vehicle::ChTrackedVehicle | Base class for chrono tracked vehicle systems |
| Cchrono::vehicle::m113::M113_Vehicle | Definition of an M113 tracked vehicle with segmented tracks |
| Cchrono::vehicle::marder::Marder_Vehicle | Definition of an Marder tracked vehicle with segmented tracks |
| Cchrono::vehicle::TrackedVehicle | Tracked vehicle model constructed from a JSON specification file |
| Cchrono::vehicle::ChTrackTestRig | Definition of a suspension test rig |
| ►Cchrono::vehicle::ChWheeledVehicle | Base class for chrono wheeled vehicle systems |
| Cchrono::vehicle::citybus::CityBus_Vehicle | Bus model with two axles and double tires on rear axle |
| Cchrono::vehicle::feda::FEDA_Vehicle | FEDA vehicle system |
| Cchrono::vehicle::fmtv::LMTV_Vehicle | LMTV vehicle system |
| Cchrono::vehicle::fmtv::MTV_Vehicle | MTV vehicle system (5t truck) |
| Cchrono::vehicle::gator::Gator_Vehicle | Gator vehicle system |
| Cchrono::vehicle::generic::Generic_Vehicle | Definition of a Generic wheeled vehicle |
| ►Cchrono::vehicle::hmmwv::HMMWV_Vehicle | Base class for a HMMWV vehicle |
| Cchrono::vehicle::hmmwv::HMMWV_VehicleFull | HMMWV vehicle system using full double wishbone suspension (control arms modeled using rigid bodies) and Pitman arm steering mechanism |
| Cchrono::vehicle::hmmwv::HMMWV_VehicleReduced | HMMWV vehicle system using reduced double wishbone suspension (control arms modeled using distance constraints) and rack-pinion steering mechanism |
| Cchrono::vehicle::kraz::Kraz_tractor | Kraz tractor system |
| ►Cchrono::vehicle::mrole::mrole_Vehicle | Base class for a mrole vehicle |
| Cchrono::vehicle::mrole::mrole_VehicleFull | Mrole vehicle system using full double wishbone suspension (control arms modeled using rigid bodies) and Pitman arm steering mechanism |
| Cchrono::vehicle::mrole::mrole_VehicleReduced | Mrole vehicle system using reduced double wishbone suspension (control arms modeled using distance constraints) and rack-pinion steering mechanism |
| Cchrono::vehicle::rccar::RCCar_Vehicle | RCCar vehicle system |
| Cchrono::vehicle::sedan::Sedan_Vehicle | Sedan vehicle system |
| Cchrono::vehicle::uaz::UAZBUS_SAEVehicle | UAZ vehicle system |
| Cchrono::vehicle::uaz::UAZBUS_Vehicle | UAZ vehicle system |
| Cchrono::vehicle::WheeledVehicle | Wheeled vehicle model constructed from a JSON specification file |
| Cchrono::vehicle::ChVehicleBushingData | Stiffness and damping data for a vehicle bushing specification |
| ►Cchrono::vehicle::ChVehicleCosimBaseNode | Base class for a co-simulation node |
| ►Cchrono::vehicle::ChVehicleCosimMBSNode | Base class for all MBS nodes |
| Cchrono::vehicle::ChVehicleCosimCuriosityNode | Curiosity rover co-simulation node |
| Cchrono::vehicle::ChVehicleCosimRigNode | Mechanism for a single-wheel testing rig |
| Cchrono::vehicle::ChVehicleCosimVehicleNode | Wheeled vehicle co-simulation node |
| Cchrono::vehicle::ChVehicleCosimViperNode | Viper rover co-simulation node |
| Cchrono::vehicle::ChVehicleCosimOtherNode | Definition of an additional MPI node not directly involved in co-simulation |
| ►Cchrono::vehicle::ChVehicleCosimTerrainNode | Base class for a terrain node |
| ►Cchrono::vehicle::ChVehicleCosimTerrainNodeChrono | Base class for terrain nodes that use one of the Chrono terrain formulations |
| Cchrono::vehicle::ChVehicleCosimTerrainNodeGranularGPU | Definition of the GPU granular terrain node (using Chrono::Gpu) |
| Cchrono::vehicle::ChVehicleCosimTerrainNodeGranularMPI | Definition of the MPI granular terrain node (using Chrono::Distributed) |
| Cchrono::vehicle::ChVehicleCosimTerrainNodeGranularOMP | Definition of the OpenMP granular terrain node (using Chrono::Multicore) |
| Cchrono::vehicle::ChVehicleCosimTerrainNodeGranularSPH | Definition of the SPH continuum representation of granular terrain node (using Chrono::FSI) |
| Cchrono::vehicle::ChVehicleCosimTerrainNodeRigid | Definition of the rigid terrain node (using Chrono::Multicore) |
| Cchrono::vehicle::ChVehicleCosimTerrainNodeSCM | Definition of the SCM deformable terrain node |
| ►Cchrono::vehicle::ChVehicleCosimTireNode | Base class for all tire nodes |
| Cchrono::vehicle::ChVehicleCosimTireNodeBypass | Definition of the bypass tire node |
| Cchrono::vehicle::ChVehicleCosimTireNodeFlexible | Definition of the flexible tire node |
| Cchrono::vehicle::ChVehicleCosimTireNodeRigid | Definition of the rigid tire node |
| ►Cchrono::vehicle::ChVehicleCosimDBPRig | Base class for a drawbar-pull rig mechanism |
| Cchrono::vehicle::ChVehicleCosimDBPRigImposedAngVel | Drawbar-pull rig mechanism with imposed angular velocity |
| Cchrono::vehicle::ChVehicleCosimDBPRigImposedSlip | Drawbar-pull rig mechanism with imposed slip |
| Cchrono::vehicle::ChVehicleGeometry | Utility class defining geometry (visualization and collision) and contact materials for a rigid vehicle body |
| Cchrono::vehicle::ChVehicleJoint | Wrapper class for a joint in a vehicle system which can be either a kinematic joint or a bushing |
| ►Cchrono::vehicle::ChVehicleOutput | Base class for a vehicle output database |
| Cchrono::vehicle::ChVehicleOutputASCII | ASCII text vehicle output database |
| Cchrono::vehicle::ChVehicleOutputHDF5 | HDF5 vehicle output database |
| ►Cchrono::ChVoightTensor< Real > | Base class for stress and strain tensors, in compact Voight notation that is with 6 components in a column |
| Cchrono::ChStrainTensor< Real > | Class for strain tensors, in compact Voight notation that is with 6 components in a column |
| Cchrono::ChStressTensor< Real > | Class for stress tensors, in compact Voight notation that is with 6 components in a column |
| ►Cchrono::vehicle::ChWheeledTrailer | Base class for chrono wheeled trailer systems |
| Cchrono::vehicle::kraz::Kraz_trailer | Kraz trailer system |
| Cchrono::vehicle::WheeledTrailer | Wheeled trailer model constructed from a JSON specification file |
| Cchrono::vehicle::ChWorldFrame | Definition of the world frame for Chrono::Vehicle simulations |
| Cchrono::vehicle::citybus::CityBus | Definition of the city bus assembly |
| Cchrono_types::class_has_custom_new_operator< T > | Check if a class has a custom new operator |
| Cchrono::collision_measures | Collision_measures |
| Cchrono::collision_settings | Chrono::Multicore collision_settings |
| Cchrono::utils::CompositeInertia | Utility class for calculating inertia properties of a composite body |
| CContextParameters | Parameters associated with the entire optix scene |
| ►Cchrono::collision::ConvexBase | Base class for convex contact shapes |
| Cchrono::collision::ConvexShape | Convex contact shape |
| Cchrono::collision::ConvexShapeCustom | Custom contact shape |
| Cchrono::collision::ConvexShapeSphere | Sphere contact shape |
| Cchrono::collision::ConvexShapeTetrahedron | Tetrahedron contact shape |
| Cchrono::collision::ConvexShapeTriangle | Triangle contact shape |
| Cchrono::vehicle::ChVehicleGeometry::ConvexHullsShape | Convex hulls shape for collision |
| Cchrono::copter::Copter< nop > | Base class for any copter, template parameter nop is the number of propellers |
| ►Cchrono::copter::Copter< 6 > | |
| Cchrono::copter::Little_Hexy | Little hexy (hexacopter) model |
| Cchrono::utils::CProfileSample | ProfileSampleClass is a simple way to profile a function's scope Use the BT_PROFILE macro at the start of scope to time |
| Cchrono::utils::Generator::CreateObjectsCallback | Class to be used as a callback interface for user-defined filtering of initial positions |
| Cchrono::irrlicht::CScreenQuad | CScreenQuad |
| Cchrono::irrlicht::CShaderPreprocessor | CShaderPreprocessor |
| Cchrono::curiosity::Curiosity | Curiosity rover class |
| ►Cchrono::curiosity::CuriosityDriver | Base class definition for a Curiosity driver |
| Cchrono::curiosity::CuriosityDCMotorControl | Concrete Curiosity driver class for a simple DC motor control |
| Cchrono::curiosity::CuriositySpeedDriver | Concrete Curiosity speed driver |
| ►Cchrono::curiosity::CuriosityPart | Base class definition for all Curiosity Rover parts |
| Cchrono::curiosity::CuriosityBogie | Curiosity rover suspension bogie |
| Cchrono::curiosity::CuriosityChassis | Curiosity rover Chassis |
| Cchrono::curiosity::CuriosityDifferentialBar | Curiosity rover differential bar |
| Cchrono::curiosity::CuriosityDifferentialLink | Curiosity rover differential link |
| Cchrono::curiosity::CuriosityRocker | Curiosity rover suspension rocker |
| Cchrono::curiosity::CuriosityUpright | Curiosity rover steering upright |
| Cchrono::curiosity::CuriosityWheel | Curiosity rover Wheel |
| ►Cchrono::ChSystem::CustomCollisionCallback | Class to be used as a callback interface for user defined actions performed at each collision detection step |
| Cchrono::ChBoundary | Utility class for specifying a collision boundary composed of multiple semi-planes |
| Cchrono::vehicle::ChVehicleGeometry::CylinderShape | Cylinder shape for visualization and/or collision |
| Cchrono::fea::DampingCoefficients | This damping model supports you to assign different Rayleigh damping coefficients for different dimensions, which would be helpful for those anisotropic material, such as wind turbine blade |
| Cchrono::irrlicht::DepthShaderCB | DepthShaderCB |
| Cchrono::sensor::ChFilterVisualize::DestroyglfwWin | Helper to allow GLFWwindow to be in a unique_ptr |
| Cchrono::irrlicht::EffectHandler | Main effect handling class, use this to apply shadows and effects |
| Cchrono::vehicle::ChDataDriver::Entry | Definition of driver inputs at a given time |
| Cchrono::vehicle::ChChassis::ExternalForce | Base class for a user-defined custom force acting on the chassis body |
| Cchrono::vehicle::feda::FEDA | Definition of the FED-alpha assembly |
| Cchrono::ChLinkSpringCB::ForceFunctor | Class to be used as a callback interface for calculating the general spring-damper force |
| ►Cchrono::ChLinkTSDA::ForceFunctor | Class to be used as a callback interface for calculating the general spring-damper force |
| Cchrono::vehicle::DegressiveDamperForce | Utility class for specifying a degressive translational damper force |
| Cchrono::vehicle::fmtv::MTV_ShockForceRear | MTV rear shock functor class - implements a nonlinear damper |
| Cchrono::vehicle::fmtv::MTV_SpringForceRear | MTV rear spring functor class - implements a nonlinear spring |
| Cchrono::vehicle::LinearDamperForce | Utility class for specifying a linear translational damper force |
| Cchrono::vehicle::LinearSpringBistopForce | Utility class for specifying a linear translational spring force with bump and rebound stop |
| Cchrono::vehicle::LinearSpringDamperActuatorForce | Utility class for specifying a linear translational spring-damper force with pre-tension |
| Cchrono::vehicle::LinearSpringDamperForce | Utility class for specifying a linear translational spring-damper force |
| Cchrono::vehicle::LinearSpringForce | Utility class for specifying a linear translational spring force |
| Cchrono::vehicle::MapDamperForce | Utility class for specifying a map translational damper force |
| Cchrono::vehicle::MapSpringBistopForce | Utility class for specifying a map translational spring force with bump and rebound stop |
| Cchrono::vehicle::MapSpringDamperActuatorForce | Utility class for specifying a map translational spring-damper force with pre-tension |
| Cchrono::vehicle::MapSpringForce | Utility class for specifying a map translational spring force |
| Cchrono::utils::ChParserOpenSim::Report::ForceInfo | Information about a custom load created from OpenSim |
| Cchrono::vehicle::ChTerrain::FrictionFunctor | Class to be used as a functor interface for location-dependent coefficient of friction |
| Cchrono::fsi::FsiBodiesDataD | Struct to store the information of rigid bodies on the device |
| Cchrono::fsi::FsiBodiesDataH | Struct to store the information of rigid bodies on the host |
| Cchrono::fsi::FsiGeneralData | Struct to store fluid/granular system information that need to be passed to Chrono |
| Cchrono::fsi::FsiMeshDataD | Struct to store the information of mesh on the device |
| Cchrono::fsi::FsiMeshDataH | Struct to store the information of mesh on the host |
| Cchrono::fsi::FsiShellsDataD | Struct to store the information of shell elements on the device |
| Cchrono::fsi::FsiShellsDataH | Struct to store the information of shell elements on the host |
| Cchrono::vehicle::gator::Gator | Definition of the Gator assembly |
| Cchrono::utils::Generator | Provides functionality for generating sets of bodies with positions drawn from a specified sampler and various mixture properties |
| Cchrono::synchrono::GPScoord | Wrapper class around ChVector stores GPS points as (lat, long, alt) in degrees |
| Cchrono::sensor::GPSData | GPS data in generic format |
| Cchrono::fsi::GpuTimer | A template time recorder for cuda events |
| Cchrono::gpu::ChSystemGpu_impl::GranParams | Structure with simulation parameters for sphere-based granular dynamics |
| Cchrono::sensor::GyroData | Gyroscope data |
| ►Cchrono::vehicle::hmmwv::HMMWV | Definition of the HMMWV assembly |
| Cchrono::vehicle::hmmwv::HMMWV_Full | Definition of a HMMWV vehicle assembly (vehicle, powertrain, and tires), using full double wishbone suspensions (i.e., suspensions that include rigid bodies for the upper and lower control arms) and a Pitman arm steering mechanism |
| Cchrono::vehicle::hmmwv::HMMWV_Reduced | Definition of a HMMWV vehicle assembly (vehicle, powertrain, and tires), using reduced double wishbone suspensions (i.e., suspensions that replace the upper and lower control arms with distance constraints) and a rack-pinion steering mechanism |
| Cchrono::host_container | Structure of arrays containing simulation data |
| Cchrono::synchrono::Intersection | Contains some number of approaches - see ApproachMessage |
| Cchrono::synchrono::IntersectionLane | Lane for the purpose of SPAT messages (i.e. something that can have its light color change) |
| Cchrono::ChStaticNonLinearRheonomicAnalysis::IterationCallback | Class to be used as a callback interface for updating the system at each iteration, for example for incrementing the load or for updating the speeds and accelerations of the parts |
| Cchrono::utils::ChParserAdams::Report::JointInfo | Information about a joint read in from ADAMS |
| Cchrono::utils::ChParserOpenSim::Report::JointInfo | Information about a joint read in from OpenSim |
| Cchrono::vehicle::kraz::Kraz | Definition of the Kraz 64431 semi-trailer truck assembly |
| Cchrono::synchrono::SynEnvironmentAgent::LaneData | It defines the traffic light color and schedule for one lane |
| Cchrono::fea::ChElementShellBST::Layer | Definition of a layer |
| Cchrono::fea::ChElementShellANCF_3833::Layer | Definition of a layer |
| Cchrono::fea::ChElementShellANCF_3423::Layer | Definition of a layer |
| Cchrono::fea::ChElementShellReissner4::Layer | Definition of a layer |
| Cchrono::fea::ChElementShellANCF_3443::Layer | Definition of a layer |
| CLidarParameters | Parameters used to define a lidar |
| Cchrono::robosimian::Link | RoboSimian link |
| Cchrono::vehicle::fmtv::LMTV | Definition of the LMTV assembly |
| Cchrono::LocalShapeNode | Linked-list node for tracking free shapes |
| Cchrono::sensor::Logger | Inference Logger for TensorRT |
| Cchrono::vehicle::m113::M113 | Definition of the m113 assembly |
| Cchrono::sensor::MagnetData | Magnetometer data |
| Cchrono::vehicle::man::MAN_10t | Wrapper class for modeling an entire MAN 10t vehicle assembly (including the vehicle itself, the powertrain, and the tires) |
| Cchrono::vehicle::man::MAN_5t | Wrapper class for modeling an entire MAN 5t vehicle assembly (including the vehicle itself, the powertrain, and the tires) |
| Cchrono::vehicle::man::MAN_7t | Wrapper class for modeling an entire MAN 7t vehicle assembly (including the vehicle itself, the powertrain, and the tires) |
| Cchrono::vehicle::marder::Marder | Definition of the marder assembly |
| CMaterialParameters | All parameters for specifying a material in optix |
| CMaterialRecordParameters | Parameters associated with a single object in the scnee |
| Cchrono::measures_container | Aggregate of collision and solver measures |
| Cchrono::vehicle::ChVehicleCosimBaseNode::MeshContact | Mesh contact information |
| Cchrono::vehicle::ChVehicleCosimBaseNode::MeshData | Mesh data |
| Cchrono::gpu::ChSystemGpuMesh_impl::MeshFrame< T > | Position and rotation matrix defining the frame of a triangle mesh |
| Cchrono::gpu::ChSystemGpuMesh_impl::MeshFrame< double > | |
| Cchrono::gpu::ChSystemGpuMesh_impl::MeshFrame< float > | |
| CMeshParameters | All the data to specific a triangle mesh |
| Cchrono::gpu::ChSystemGpuMesh_impl::MeshParams | Extra parameters needed for triangle-sphere contact |
| Cchrono::vehicle::ChVehicleCosimBaseNode::MeshState | Mesh state |
| CMissParameters | The parameters for a camera miss record |
| Cchrono::utils::MixtureIngredient | Encapsulation of an ingredient of one of the supported types in a mixture |
| Cchrono::MPM_Settings | Settings for the Material Point Method |
| ►Cchrono::vehicle::mrole::mrole | Definition of the mrole assembly |
| Cchrono::vehicle::mrole::mrole_Full | Definition of a mrole vehicle assembly (vehicle, powertrain, and tires), using full double wishbone suspensions (i.e., suspensions that include rigid bodies for the upper and lower control arms) and a Pitman arm steering mechanism |
| Cchrono::vehicle::mrole::mrole_Reduced | Definition of a mrole vehicle assembly (vehicle, powertrain, and tires), using reduced double wishbone suspensions (i.e., suspensions that replace the upper and lower control arms with distance constraints) and a rack-pinion steering mechanism |
| Cchrono::vehicle::fmtv::MTV | Definition of the MTV assembly |
| Cchrono::collision::ChCollisionSystem::NarrowphaseCallback | Class to be used as a callback interface for user-defined actions to be performed at each collision pair found during the narrow-phase collision step |
| Cchrono::fsi::NumberOfObjects | Number of rigid and flexible solid bodies, fluid SPH particles, solid SPH particles, boundary SPH particles |
| Cchrono::ChLinkTSDA::ODE | Class to be used as a callback interface for specifying the ODE, y' = f(t,y); y(0) = y0 |
| Cchrono::ChLinkSpringCB::ODE | Class to be used as a callback interface for specifying the ODE, y' = f(t,y); y(0) = y0 |
| Cchrono::vehicle::RigidTerrain::Patch | Definition of a patch in a rigid terrain model |
| Cchrono::utils::PDGrid< Point > | Simple 3D grid utility class for use by the Poisson Disk sampler |
| Cchrono::utils::PDGrid< chrono::ChVector< T > > | |
| CPerRayData_camera | Data associated with a single camera ray |
| CPerRayData_lidar | Data associated with a single lidar ray |
| CPerRayData_radar | Data associated with a single radar ray |
| CPerRayData_semantic | Data associated with a single segmentation camera ray |
| CPerRayData_shadow | Data associated with a single shadow ray |
| ►Cchrono::robosimian::RS_Driver::PhaseChangeCallback | Class to be used as callback interface for user-defined actions at phase changes |
| Cchrono::robosimian::RS_DriverCallback | Robot driver callback to keep track of average speed and distance between phase changes |
| Cchrono::sensor::PixelDI | Depth and intensity data in generic format |
| Cchrono::sensor::PixelFloat4 | A pixel as defined by RGBA float4 format |
| Cchrono::sensor::PixelHalf4 | A pixel as defined by RGBA float4 format |
| Cchrono::sensor::PixelRGBA8 | A pixel as defined by RGBA 8bpp format |
| Cchrono::sensor::PixelSemantic | A pixel as defined for semantic segmentation |
| Cchrono::sensor::PixelXYZI | Point cloud and intensity data in generic format |
| Cchrono::gpu::Plane_BC_params_t< T3 > | Infinite Plane defined by point in plane and normal |
| Cchrono::gpu::Plate_BC_params_t< T3 > | Customized finite Plate defined by center of the plate, normal and y dim |
| CPointLight | Packed parameters of a point light |
| Cchrono::fea::PolarDecomposition | Polar decomposition of a general 3x3 matrix |
| Cchrono::sensor::ProgramString | Holds string values for ptx file and ray generation program |
| Cchrono::fsi::ProximityDataD | Struct to store neighbor search information on the device |
| Cchrono::vehicle::ChVehicleCosimTerrainNodeChrono::ProxyBody | Association between a proxy body and a mesh index |
| Cchrono::quaternion | Chrono multicore quaternion class |
| CRadarParameters | Parameters used to define a radar |
| CRaygenParameters | Parameters for specifying raygen programs |
| Cchrono::collision::ChRayTest::RayHitInfo | Information on ray intersection test result |
| Cchrono::vehicle::rccar::RCCar | Definition of the RCCar assembly |
| Cchrono::real2 | Chrono::Multicore pair (2-dimensional vector) |
| Cchrono::real3 | Chrono::Multicore triplet (3-dimensional vector) |
| Cchrono::real4 | Chrono multicore qudruple (4-dimensional array) |
| Cchrono::utils::ChParserAdams::Report | Report containing information about objects parsed from file |
| Cchrono::utils::ChParserOpenSim::Report | Report containing information about objects parsed from file |
| ►Cchrono::ChContactContainer::ReportContactCallback | Class to be used as a callback interface for some user defined action to be taken for each contact (already added to the container, maybe with already computed forces) |
| Cchrono::vehicle::ChTrackContactManager | Class for monitoring contacts of tracked vehicle subsystems |
| Cchrono::ChProximityContainer::ReportProximityCallback | Class to be used as a callback interface for some user defined action to be taken for each proximity pair (already added to the container) |
| Cchrono::vehicle::ChVehicleCosimTerrainNodeChrono::RigidObstacle | Specification of a rigid obstacle |
| Cchrono::robosimian::RoboSimian | RoboSimian robot model |
| Cchrono::robosimian::RS_Driver | Driver for the RoboSimian robot |
| Cchrono::robosimian::RS_Limb | RoboSimian limb |
| ►Cchrono::robosimian::RS_Part | RoboSimian part |
| Cchrono::robosimian::RS_Chassis | RoboSimian chassis (torso) |
| Cchrono::robosimian::RS_Sled | RoboSimian sled (attached to chassis) |
| Cchrono::robosimian::RS_WheelDD | RoboSimian direct-drive wheel |
| Cchrono::irrlicht::RTSCamera | Class to create an interactive videocamera in Irrlicht, that is similar to the Maya camera but hasn't the problems that the Maya camera has in Irrlicht 1.5 |
| Cchrono::vehicle::SAEToeBarLeafspringAxle | Steerable leaf-spring solid axle suspension constructed with data from file |
| ►Cchrono::utils::Sampler< T > | Base class for different types of point samplers |
| Cchrono::utils::GridSampler< T > | Sampler for 3D volumes using a regular (equidistant) grid |
| Cchrono::utils::HCPSampler< T > | Sampler for 3D volumes using a Hexagonally Close Packed structure |
| Cchrono::utils::PDSampler< T > | Sampler for 3D domains (box, sphere, or cylinder) using Poisson Disk Sampling |
| Cchrono::vehicle::SCMContactableData | Parameters for soil-contactable interaction |
| Cchrono::synchrono::SCMParameters | Groups SCM parameters into a struct, defines some useful defaults See SCMDeformableTerrain::SetSoilParameters and SoilParametersCallback for more details on these |
| Cchrono::irrlicht::ScreenQuadCB | ScreenQuadCB |
| Cchrono::vehicle::sedan::Sedan | Definition of the sedan assembly |
| CSemanticCameraParameters | Parameters need to define a camera that generates semantic segmentation data |
| ►Cchrono::sensor::SensorBuffer | The base buffer class that contains sensor data (contains meta data of the buffer and pointer to raw data) |
| Cchrono::sensor::SensorBufferT< B > | Base class of 2D buffers |
| Cchrono::sensor::SensorConfig | Creates an empty optix transform::node |
| Cchrono::settings_container | Aggregate of all settings for Chrono::Multicore |
| Cchrono::irrlicht::ShadowShaderCB | ShadowShaderCB |
| Cchrono::Shape | Structure of data for sending a collision shape to a rank |
| Cchrono::collision::shape_container | Structure of arrays containing rigid collision shape information |
| Cchrono::fsi::SimParams | Structure with FSI simulation parameters |
| Cchrono::vehicle::SCMDeformableTerrain::SoilParametersCallback | Class to be used as a callback interface for location-dependent soil parameters |
| Cchrono::solver_measures | Solver measures |
| Cchrono::solver_settings | Chrono::Multicore solver_settings |
| Cchrono::gpu::Sphere_BC_params_t< T, T3 > | Sphere |
| Cchrono::gpu::ChSystemGpu_impl::SphereData | Structure of pointers to kinematic quantities of the ChSystemGpu_impl |
| Cchrono::vehicle::ChVehicleGeometry::SphereShape | Sphere shape for visualization and/or collision |
| Cchrono::fsi::SphMarkerDataD | Struct to store the information of SPH particles on the device |
| Cchrono::fsi::SphMarkerDataH | Struct to store the information of SPH particles on the host |
| Cchrono::collision::state_container | Structure of arrays containing state data |
| ►Cchrono::synchrono::SynAgent | Base class for SynChrono agents |
| Cchrono::synchrono::SynCopterAgent | Agent wrapper of a copter model, sends out SynCopterMessage-s to synchronize its state |
| Cchrono::synchrono::SynEnvironmentAgent | Derived agent class. Acts as a traffic light and distributes MAP and/or SPAT data |
| Cchrono::synchrono::SynSCMTerrainAgent | Class that wraps and synchronizes deformable terrain between Chrono Systems |
| Cchrono::synchrono::SynTrackedVehicleAgent | Agent wrapper of a tracked vehicle, in particular holds a pointer to a ChTrackedVehicle and sends out SynTrackedVehicleMessage-s to synchronize its state |
| Cchrono::synchrono::SynWheeledVehicleAgent | Agent wrapper of a wheeled vehicle, in particular holds a pointer to a ChWheeledVehicle and sends out SynWheeledVehicleMessage-s to synchronize its state |
| Cchrono::synchrono::SynAgentFactory | Generates SynTerrain's from JSON files Used to improve generality in Agent classes |
| Cchrono::synchrono::SynChronoManager | Base class responsible for handling agents and synchronizing states between nodes |
| ►Cchrono::synchrono::SynCommunicator | Base class communicator used to establish and facilitate communication between nodes |
| Cchrono::synchrono::SynDDSCommunicator | Derived communicator used to establish and facilitate communication between nodes |
| Cchrono::synchrono::SynMPICommunicator | Derived communicator used to establish and facilitate communication between nodes |
| Cchrono::synchrono::SynDDSDataReaderListener | Data reader listener that can both count publishers on a topic and can be used as an asynchronous listener |
| Cchrono::synchrono::SynDDSDataWriterListener | Data writer listener that counts number of subscribers listening to a specific topic |
| CSynDDSMessage | This class represents the structure SynDDSMessage defined by the user in the IDL file |
| CSynDDSMessagePubSubType | This class represents the TopicDataType of the type SynDDSMessage defined by the user in the IDL file |
| Cchrono::synchrono::SynDDSParticipantListener | Participant listener that will count the number of participants and store their names to be used later |
| Cchrono::synchrono::SynDDSPublisher | DDS publisher wrapper. Sends information on a topic |
| Cchrono::synchrono::SynDDSSubscriber | DDS subscriber wrapper. Listens for information on a topic |
| Cchrono::synchrono::SynDDSThreadSafeCounter | Thread safe counter used to count various elements Use case would be to block until a certain number of elements |
| Cchrono::synchrono::SynDDSTopic | Describes information that's being distributed over an abstract "wire" Includes data type and meta information (i.e |
| Cchrono::synchrono::SynFlatBuffersManager | Helper class that wraps the flatbuffers::FlatBufferBuilder |
| Cchrono::synchrono::SynGPSTools | Holds a SynTerrain along with the GPS coordinate mapped to the origin of the ChVector space |
| ►Cchrono::synchrono::SynMessage | SynMessage is the base class for all messages Basically wraps the FlatBuffer methods to better handle the SynChrono message passing system Will be inherited from to create new message types |
| Cchrono::synchrono::SynApproachMessage | Approach message |
| Cchrono::synchrono::SynCopterDescriptionMessage | Description class that holds description information for a SynCopter |
| Cchrono::synchrono::SynCopterStateMessage | State class that holds state information for a SynCopter |
| Cchrono::synchrono::SynEnvironmentMessage | The environment agent state class This should be inherited and stored with additional state information relevant to the environment agent Should hold frequently passed data, such as synchronization information For infrequently passed data, please see SynAgentDescriptionMessage |
| Cchrono::synchrono::SynMAPMessage | Store the Map information in the simulation |
| Cchrono::synchrono::SynSCMMessage | SCM Message |
| Cchrono::synchrono::SynSimulationMessage | This class contains diagnostic and simulation configuration based information that is typically passed between CommunicationManagers in the initialization phase |
| Cchrono::synchrono::SynSPATMessage | SPAT Message |
| Cchrono::synchrono::SynTrackedVehicleDescriptionMessage | Description class that holds description information for a SynTrackedVehicle |
| Cchrono::synchrono::SynTrackedVehicleStateMessage | State class that holds state information for a SynTrackedVehicleAgent |
| Cchrono::synchrono::SynWheeledVehicleDescriptionMessage | Description class that holds description information for a SynWheeledVehicle |
| Cchrono::synchrono::SynWheeledVehicleStateMessage | State class that holds state information for a SynWheeledVehicle |
| Cchrono::synchrono::SynMessageFactory | Called by CommunicationManager to transform an incoming SynFlatBuffers::Message into a SynMessage |
| Cchrono::synchrono::SynPose | Wrapper for several constructs that are common to many flatbuffer messages (Vectors, Quaternions, frames) |
| Cchrono::vehicle::TerrainForce | Structure to communicate a set of generalized terrain contact forces (tire or track shoe) |
| Cchrono::TimerData | Wrapper class for a timer object |
| ►Cchrono::ChLinkRotSpringCB::TorqueFunctor | Class to be used as a callback interface for calculating the general spring-damper torque |
| Cchrono::vehicle::ChTrackAssemblySegmented::TrackBendingFunctor | Default torque functor for implementing track bending stiffness |
| Cchrono::vehicle::LinearDamperTorque | Utility class for specifying a linear rotational damper torque |
| Cchrono::vehicle::LinearSpringDamperActuatorTorque | Utility class for specifying a linear rotational spring-damper torque with pre-tension |
| Cchrono::vehicle::LinearSpringDamperTorque | Utility class for specifying a linear rotational spring-damper torque |
| Cchrono::vehicle::LinearSpringTorque | Utility class for specifying a linear rotational spring torque |
| Cchrono::vehicle::MapDamperTorque | Utility class for specifying a map rotational damper torque |
| Cchrono::vehicle::MapSpringTorque | Utility class for specifying a map rotational spring torque |
| Cchrono::sensor::Transform | Transform struct for packing a translation, rotation, and scale |
| Cchrono::gpu::ChSystemGpuMesh_impl::TriangleSoup | Structure used to hold pointers for mesh arrays |
| Cchrono::ChSystemDistributed::TriData | Structure of vertex data for a triangle in the bodies existing local frame |
| Cchrono::vehicle::ChVehicleGeometry::TrimeshShape | Tri-mesh shape for collision |
| Cchrono::sensor::TRTDestroyer | Destructor for tensorRT pointers |
| Cchrono::turtlebot::TurtleBot | Turtlebot Robot class This class assemble and initialize a complete turtlebot robot This class also handles general control commands of the robot |
| ►Cchrono::turtlebot::Turtlebot_Part | Base class definition of the Turtlebot Robot Part |
| Cchrono::turtlebot::Turtlebot_ActiveWheel | Turtlebot Active Drive Wheel class definition |
| Cchrono::turtlebot::Turtlebot_BottomPlate | Turtlebot Bottom Plate class definition |
| Cchrono::turtlebot::Turtlebot_Chassis | Turtlebot Chassis class definition |
| Cchrono::turtlebot::Turtlebot_MiddlePlate | Turtlebot Middle Plate class definition |
| Cchrono::turtlebot::Turtlebot_PassiveWheel | Turtlebot Passive Driven Wheel class definition |
| Cchrono::turtlebot::Turtlebot_Rod_Long | Long Supporting Rod class definition |
| Cchrono::turtlebot::Turtlebot_Rod_Short | Short Supporting Rod class definition |
| Cchrono::turtlebot::Turtlebot_TopPlate | Turtlebot Top Plate class definition |
| Cchrono::vehicle::uaz::UAZBUS | Definition of the UAZ assembly |
| Cchrono::vehicle::uaz::UAZBUS_SAE | Definition of the UAZ assembly |
| Cchrono::vehicle::uaz::UAZBUS_SAEToeBarLeafspringAxle | Leafspring axle subsystem for the uaz vehicle |
| Cirr::core::vector3dfCH | Utility class to easily convert a Chrono vector into an Irrlicht vector3df |
| Cchrono::viper::Viper | Viper rover class |
| ►Cchrono::viper::ViperDriver | Base class definition for a Viper driver |
| Cchrono::viper::ViperDCMotorControl | Concrete Viper driver class for a simple DC motor control |
| Cchrono::viper::ViperSpeedDriver | Concrete Viper speed driver |
| ►Cchrono::viper::ViperPart | Base class definition for all Viper parts |
| Cchrono::viper::ViperChassis | Viper rover Chassis |
| Cchrono::viper::ViperLowerArm | The bottom arm of the Viper rover suspension |
| Cchrono::viper::ViperUpperArm | The upper arm of the Viper rover suspension |
| Cchrono::viper::ViperUpright | Steering rod of the Viper rover |
| Cchrono::viper::ViperWheel | Viper rover Wheel |
| Cchrono::vehicle::WheelState | Structure to communicate a full wheel body state |
| Cchrono::gpu::Z_Cone_BC_params_t< T, T3 > | Z-aligned cone pointed downward |
| Cchrono::gpu::Z_Cylinder_BC_params_t< T, T3 > | Infinite Z-aligned cylinder |
