MULTIBODY SIMULATION SOFTWARE - API documentation

chrono Namespace Reference

This is the namespace for most functions of the Chrono library. More...


Classes

class  ChClassRegisterCommon
class  ChClassRegisterABSTRACT
class  ChClassRegister
class  ChCoordsys
class  ChException
class  ChFileutils
class  ChFrame
class  ChFrameMoving
struct  HashFunction_Generic
struct  HashFunction_String1
struct  HashFunction_String2
struct  HashFunction_String3
class  ChHashTable
class  ChNode
class  ChList
class  ChLog
class  ChLogConsole
class  ChMatrix
class  ChMatrixDynamic
class  ChMatrixNM
class  ChMatrix33
class  ChQuaternion
class  ChRealtimeStepTimer
class  ChRunTimeType
class  ChShared
class  ChSmartPtr
class  ChSharedPtr
class  ChMelement
class  ChSparseMatrix
class  ChStream
class  ChStreamOut
class  ChStreamIn
class  ChStreamOutAscii
class  ChStreamInAscii
class  ChBinaryArchive
class  ChStreamOutBinary
class  ChStreamInBinary
class  ChStreamFile
class  ChStreamFileWrapper
class  ChStreamOutBinaryFile
class  ChStreamOutAsciiFile
class  ChStreamInBinaryFile
class  ChStreamInAsciiFile
class  ChTimer
class  ChTrasform
class  ChVector
class  ChLcpConstraint
class  ChLcpConstraintTwo
class  ChLcpConstraintTwoBodies
class  ChLcpConstraintTwoContact
class  ChLcpConstraintTwoContactN
class  ChLcpConstraintTwoFriction
class  ChLcpConstraintTwoFrictionApprox
class  ChLcpConstraintTwoFrictionT
class  ChLcpConstraintTwoGeneric
class  ChLcpConstraintTwoGPUcontN
class  ChLcpConstraintTwoGPUcontT
class  ChLcpConstraintTwoRollingN
class  ChLcpConstraintTwoRollingT
class  ChLcpDirectSolver
class  ChLcpIterativeCuda
class  ChLcpIterativeJacobi
class  ChLcpIterativeSolver
class  ChLcpIterativeSOR
class  ChLcpIterativeSymmSOR
class  ChLcpSimplexSolver
class  ChLcpSolver
class  ChLcpSystemDescriptor
class  ChLcpVariables
class  ChLcpVariablesBody
class  ChLcpVariablesBodyOwnMass
class  ChSharedMassBody
class  ChLcpVariablesBodySharedMass
class  ChLcpVariablesGeneric
class  ChMatlabEngine
class  ChBody
class  ChConstraint
class  ChConstraint_Chf
class  ChConstraint_Chf_ImposeVal
class  ChConstraint_Chf_Continuity
class  ChConstraint_Chf_HorDistance
class  ChConstraint_Chf_VertDistance
class  ChContact
class  ChContactContainer
class  ChAddContactCallback
class  ChReportContactCallback
class  ChContactContainerBase
class  ChContactContainerGPUsimple
class  ChContactGPUsimple
class  ChContactRolling
class  ChControllerPID
class  ChControls
class  ChEvents
class  ChExternalObject
class  ChFelem_BrickLinear
class  ChFelem_TetraLinear
class  ChFnode
class  ChFelem
class  ChPageVect
class  ChFile_ps_color
class  ChFile_ps_axis_setting
class  ChFile_ps_graph_setting
class  ChFile_ps
class  ChForce
class  ChThesItem
class  ChTag
class  ChVar
class  ChEvStacks
class  ChFunction
class  ChFunction_Ramp
class  ChFunction_Sine
class  ChFunction_Sigma
class  ChFunction_Mocap
class  ChFunction_Poly
class  ChFunction_ConstAcc
class  ChFunction_Poly345
class  ChFunction_Fillet3
class  ChFunction_Recorder
class  ChFunction_Oscilloscope
class  ChFseqNode
class  ChFunction_Sequence
class  ChFunction_Matlab
class  ChFunction_Jscript
class  ChFunction_Noise
class  ChFunction_Derive
class  ChFunction_Integrate
class  ChFunction_Mirror
class  ChFunction_Repeat
class  ChGlobals
class  ChHistory
class  ChImpact
class  ChIntegrator
class  ChLinkLimit
class  ChLink
class  ChLinkBrake
class  ChLinkClearance
class  ChLinkContact
class  ChLinkDistance
class  ChLinkEngine
class  ChLinkFastContact
class  ChLinkForce
class  ChLinkGear
class  ChLinkGeometric
class  ChLinkGPUcontact
class  ChLinkLinActuator
class  ChLinkLock
class  ChLinkLockRevolute
class  ChLinkLockLock
class  ChLinkLockSpherical
class  ChLinkLockCylindrical
class  ChLinkLockPrismatic
class  ChLinkLockPointPlane
class  ChLinkLockPointLine
class  ChLinkLockPlanePlane
class  ChLinkLockOldham
class  ChLinkLockFree
class  ChLinkLockHook
class  ChLinkLockAlign
class  ChLinkLockParallel
class  ChLinkLockPerpend
class  ChLinkMarkers
class  ChLinkMask
class  ChLinkMaskLF
class  ChLinkMasked
class  ChLinkNumdiff
class  ChLinkPneumaticActuator
class  ChLinkPointSpline
class  ChLinkPulley
class  ChLinkScrew
class  ChLinkSpring
class  ChLinkTrajectory
class  ChLinkWheel
class  ChMarker
class  ChMaterialCouple
class  ChFMesh
class  ChMocap
class  ChNonlinearSolver
class  ChObj
class  CHoptVar
class  ChAparticle
class  ChParticles
class  ChPhysicsItem
class  ChProbe
class  ChQuadrature
class  ChRef
class  ChRefFunction
class  ChRefFunctionHandle
class  ChOptimizer
class  ChOptimizerLocal
class  ChGenotype
class  ChOptimizerGenetic
class  ChOptimizerGradient
class  ChOptimizerHybrid
class  ChStack
class  ChSystem

Namespaces

namespace  collision
namespace  geometry
namespace  pneumatics

Typedefs

typedef ChSmartPtr
< btCollisionShape > 		smartptrshapes
typedef ChCoordsys
< double > 		Coordsys
typedef ChCoordsys
< float > 		CoordsysF
typedef ChQuaternion
< double > 		Quaternion
typedef ChQuaternion
< float > 		QuaternionF
typedef ChVector
< double > 		Vector
typedef ChVector< float > VectorF
typedef void(* ChThreadFunc )(void *userPtr, void *lsMemory)
typedef void *(* ChMemorySetupFunc )()
typedef unsigned int uint32_t
typedef ChThreadsPOSIX ChThreadsPlatformImplementation
typedef unsigned int uint32_t
typedef ChThreadsWIN32 ChThreadsPlatformImplementation
typedef ChSharedPtr
< ChForce > 		ChSharedForcePtr
typedef ChSharedPtr
< ChMarker > 		ChSharedMarkerPtr
typedef ChSharedPtr
< ChMarker > 		ChSharedMarkerPtr
typedef ChSharedPtr
< ChBody > 		ChSharedBodyPtr
typedef ChSharedPtr
< ChParticles > 		ChSharedParticlesPtr
typedef ChSharedPtr
< ChLink > 		ChSharedLinkPtr
typedef ChSharedPtr
< ChProbe > 		ChSharedProbePtr
typedef ChSharedPtr
< ChControls > 		ChSharedControlsPtr

Enumerations

enum  eChConstraintMode { CONSTRAINT_FREE = 0, CONSTRAINT_LOCK = 1, CONSTRAINT_UNILATERAL = 2, CONSTRAINT_FRIC = 3 }
enum  {
  OP_NONE = 0, OP_MUL, OP_DIV, OP_ADD,
  OP_SUB, OP_POW
}
enum  {
  CHOP_ADD = 0, CHOP_SUB, CHOP_MUL, CHOP_DIV,
  CHOP_POW, CHOP_MAX, CHOP_MIN, CHOP_MODULO,
  CHOP_FABS, CHOP_FUNCT
}
enum  {
  PARID_NULL = 0, PARID_PLUS, PARID_MINUS, PARID_MUL,
  PARID_DIV, PARID_FX, PARID_MINOR, PARID_MAJOR,
  PARID_ISEQUAL, PARID_STORE, PARID_COMMA, PARID_BICOMMA,
  PARID_WHILE, PARID_NOT, PARID_NOTEQUAL, PARID_POINTER
}
enum  eChGeneticSelection { SELEC_ROULETTE = 0, SELEC_ROULETTEBEST, SELEC_NORMGEOMETRIC, SELEC_TOURNAMENT }
enum  eChGeneticCrossover {
  CROSSOVER_ARITMETIC = 0, CROSSOVER_BLEND, CROSSOVER_BLEND_RANDOM, CROSSOVER_HEURISTIC,
  CROSSOVER_DISABLED
}
enum  eChGeneticChange { CRO_CHANGE_NULL = 0, CRO_CHANGE_DATE, CRO_CHANGE_SLOWLY }
enum  eChGeneticMutation { MUTATION_UNIFORM = 0, MUTATION_BOUNDARY }
enum  eChGeneticEliteMode { ELITE_FALSE = 0, ELITE_TRUE }
enum  eChGeneticReplaceMode { REPLA_PARENTS = 0, REPLA_WORST }

Functions

template<class T>
void create (std::string cls_name, T **ppObj)
Coordsys Force2Dcsys (Coordsys *cs)
ChLog & GetLog ()
void SetLog (ChLog &new_logobject)
void SetLogDefault ()
double CHatan2 (double mcos, double msin)
void CHsetRandomSeed (long newseed)
double CHrandom ()
void ChPeriodicPar (double &u, int closed)
double CHnoise (double x, double amp, double freq, int octaves, double amp_ratio)
int CHmax (int a, int b)
double CHmax (double a, double b)
int CHmin (int a, int b)
double CHmin (double a, double b)
void Chrono_to_Marray (ChMatrix33<> &mma, double marr[3][3])
void Chrono_from_Marray (ChMatrix33<> &mma, double marr[3][3])
double Qlenght (Quaternion q)
Quaternion Qscale (Quaternion q, double fact)
Quaternion Qadd (Quaternion qa, Quaternion qb)
Quaternion Qsub (Quaternion qa, Quaternion qb)
Quaternion Qnorm (Quaternion q)
Quaternion Qconjugate (Quaternion q)
Quaternion Qcross (Quaternion qa, Quaternion qb)
Quaternion Q_from_AngAxis (double angle, Vector axis)
Quaternion Q_from_AngZ (double angleZ)
Quaternion Q_from_AngX (double angleX)
Quaternion Q_from_AngY (double angleY)
Quaternion Q_from_NasaAngles (Vector mang)
Vector Q_to_NasaAngles (Quaternion q1)
void Q_to_AngAxis (Quaternion *quat, double *a_angle, Vector *a_axis)
Quaternion Qdt_from_Wabs (Vector w, Quaternion q)
Quaternion Qdt_from_Wrel (Vector w, Quaternion q)
Quaternion Qdtdt_from_Aabs (Vector a, Quaternion q, Quaternion q_dt)
Quaternion Qdtdt_from_Arel (Vector a, Quaternion q, Quaternion q_dt)
Quaternion Qdt_from_AngAxis (Quaternion quat, double angle_dt, Vector axis)
Quaternion Qdtdt_from_AngAxis (double angle_dtdt, Vector axis, Quaternion q, Quaternion q_dt)
int Qequal (Quaternion *qa, Quaternion *qb)
int Qnotnull (Quaternion *qa)
Quaternion ImmQ_complete (Vector *qimm)
Quaternion ImmQ_dt_complete (Quaternion *mq, Vector *qimm_dt)
Quaternion ImmQ_dtdt_complete (Quaternion *mq, Quaternion *mqdt, Vector *qimm_dtdt)
Quaternion Angle_to_Quat (int angset, Vector *mangles)
Vector Quat_to_Angle (int angset, Quaternion *mquat)
Quaternion AngleDT_to_QuatDT (int angset, Vector *mangles, Quaternion *q)
Quaternion AngleDTDT_to_QuatDTDT (int angset, Vector *mangles, Quaternion *q)
Vector Angle_to_Angle (int setfrom, int setto, Vector *mangles)
Vector VaxisXfromQuat (Quaternion quat)
template<typename T>
bool operator== (const ChSmartPtr< T > &left, const ChSmartPtr< T > &right)
template<typename T>
bool operator< (const ChSmartPtr< T > &left, const ChSmartPtr< T > &right)
template<typename T>
bool operator== (const ChSharedPtr< T > &left, const ChSharedPtr< T > &right)
template<typename T>
bool operator< (const ChSharedPtr< T > &left, const ChSharedPtr< T > &right)
template<class T>
void StreamSwapBytes (T *ptData)
template<class Real>
ChVector< Real > operator * (const double v, const ChVector< Real > V)
template<class RealA, class RealB>
RealA Vdot (const ChVector< RealA > va, const ChVector< RealB > vb)
template<class RealA>
void Vset (ChVector< RealA > *v, RealA mx, RealA my, RealA mz)
template<class RealA, class RealB>
ChVector< RealA > Vadd (ChVector< RealA > va, ChVector< RealB > vb)
template<class RealA, class RealB>
ChVector< RealA > Vsub (ChVector< RealA > va, ChVector< RealB > vb)
template<class RealA, class RealB>
ChVector< RealA > Vcross (ChVector< RealA > va, ChVector< RealB > vb)
template<class RealA, class RealB>
ChVector< RealA > Vmul (ChVector< RealA > va, RealB fact)
template<class RealA>
RealA Vlenght (ChVector< RealA > va)
template<class RealA>
ChVector< RealA > Vnorm (ChVector< RealA > va)
template<class RealA, class RealB>
bool Vequal (ChVector< RealA > *va, ChVector< RealB > *vb)
template<class RealA>
bool Vnotnull (ChVector< RealA > *va)
template<class RealA>
double VangleYZplane (ChVector< RealA > *va)
template<class RealA>
double VangleYZplaneNorm (ChVector< RealA > *va)
template<class RealA>
double VangleRX (ChVector< RealA > *va)
template<class RealA>
ChVector< RealA > VfromPolar (double norm_angle, double pol_angle)
template<class RealA>
void XdirToDxDyDz (ChVector< RealA > *mVxdir, ChVector< RealA > *mVsingular, ChVector< RealA > *Vx, ChVector< RealA > *Vy, ChVector< RealA > *Vz)
float __host_int_as_float (int a)
void * SolverMemoryFunc ()
void SolverThreadFunc (void *userPtr, void *lsMemory)
ChGlobals * DLL_CreateGlobals ()
void DLL_DeleteGlobals ()
int coll_model_from_r3d (ChCollisionModel *chmodel, ChBody *mbody, int lod, Vector *mt, ChMatrix33<> *mr)
int ChLineLineIntersect (Vector p1, Vector p2, Vector p3, Vector p4, Vector *pa, Vector *pb, double *mua, double *mub)
double ChPointLineDistance (Vector p, Vector dA, Vector dB, double &mu, int &is_insegment)
double ChPointTriangleDistance (Vector B, Vector A1, Vector A2, Vector A3, double &mu, double &mv, int &is_into, Vector &Bprojected)
int ChDegenerateTriangle (Vector Dx, Vector Dy)
ChPageVect pv_set (double x, double y)
ChPageVect pv_set (Vector mv)
int Get_Var_by_Token (char *string, char *string_end, ChVar &myret, void *database)
int Set_Var_by_Token (char *string, char *string_end, ChVar &myret, void *database)
int Get_Var_by_Name (char *string, ChVar &myret, void *database)
int Set_Var_by_Name (char *string, ChVar &myret, void *database)
int Get_Float_by_Name (char *string, double &myfloat, void *database)
int Set_Float_by_Name (char *string, double &myfloat, void *database)
int token_match (char *string, char *endstring, char *compare)
int token_atom_lenght (char *string, char *string_end)
int goto_next_atom (char *&string, char *&endstring)
int match_parenthesis (char *string, char *endstring)
int match_brace (char *string, char *endstring)
int is_a_number (char *string, char *endstring)
ChVar Ch_EvalVar (char *string, char *endstring, void *database)
ChVar Ch_EvalVar (char *string, void *database)
int Ch_Eval (char *string, void *database, int &result)
int Ch_Eval (char *string, void *database, double &result)
int TranslateWithThesaurus (char *string, char *string_end, ChThesItem *thes, void *obj, int classid, ChTag &ret_tag)
int ch_iterative_TFQMR (ChMatrix<> &x, ChMatrix<> &b, void(*SolveAX)(ChMatrix<> &inX, ChMatrix<> &outB, void *userdata), void(*M1_solve)(ChMatrix<> &eIn, ChMatrix<> &eOut, void *userdata), void(*M2_solve)(ChMatrix<> &eIn, ChMatrix<> &eOut, void *userdata), double min_kappa, int max_iterations, int &iter, int &error_code, void *userdata)
void __easy_prodeval (ChMatrix<> &inX, ChMatrix<> &outB, void *userdata)
int ch_iterative_TFQMR_easy (ChMatrix<> &A, ChMatrix<> &x, ChMatrix<> &b, double mkappa, int iterations)
template<class Real>
void Transform_Cq_to_Cqw_row (ChMatrix<> *mCq, int qrow, ChMatrix< Real > *mCqw, int qwrow, ChBody *mbody)
template<class T, class Iterator>
T * ChContainerSearchFromName (char *m_name, Iterator from, Iterator to)
template<class T, class Iterator>
T * ChContainerSearchFromID (int myID, Iterator from, Iterator to)
void null_entry_solv_opt (double x[], double g[])
double CalcFO (double x[], void *idData)
void showVarFun ()
double solvopt (unsigned int n, double x[], double fun(double x[], void *idData), void grad(double x[], double g[]), double options[], void *idData, void(*showDisplay)(), int showEvery, int *breakCicle, int &err_code)

Variables

ChClassRegisterABSTRACT
< ChLcpConstraintTwo > 		a_registration_ChLcpConstraintTwo
ChClassRegister
< ChLcpConstraintTwoBodies > 		a_registration_ChLcpConstraintTwoBodies
ChClassRegister
< ChLcpConstraintTwoContact > 		a_registration_ChLcpConstraintTwoContact
ChClassRegister
< ChLcpConstraintTwoContactN > 		a_registration_ChLcpConstraintTwoContactN
ChClassRegister
< ChLcpConstraintTwoFriction > 		a_registration_ChLcpConstraintTwoFriction
ChClassRegister
< ChLcpConstraintTwoFrictionApprox > 		a_registration_ChLcpConstraintTwoFrictionApprox
ChClassRegister
< ChLcpConstraintTwoFrictionT > 		a_registration_ChLcpConstraintTwoFrictionT
ChClassRegister
< ChLcpConstraintTwoGeneric > 		a_registration_ChLcpConstraintTwoGeneric
ChClassRegister
< ChLcpConstraintTwoGPUcontN > 		a_registration_ChLcpConstraintTwoGPUcontN
ChClassRegister
< ChLcpConstraintTwoGPUcontT > 		a_registration_ChLcpConstraintTwoGPUcontT
ChClassRegister
< ChLcpConstraintTwoRollingN > 		a_registration_ChLcpConstraintTwoRollingN
ChClassRegister
< ChLcpConstraintTwoRollingT > 		a_registration_ChLcpConstraintTwoRollingT
ChClassRegisterABSTRACT
< ChLcpVariablesBody > 		a_registration_ChLcpVariablesBody
ChClassRegister
< ChLcpVariablesBodyOwnMass > 		a_registration_ChLcpVariablesBodyOwnMass
ChClassRegister
< ChLcpVariablesBodySharedMass > 		a_registration_ChLcpVariablesBodySharedMass
ChClassRegister
< ChLcpVariablesGeneric > 		a_registration_ChLcpVariablesGeneric
ChClassRegister< ChBody > a_registration_ChBody
const int BODY_DOF = 6
const int BODY_QDOF = 7
const int BODY_ROT = 3
ChClassRegister
< ChContactContainer > 		a_registration_ChContactContainer
ChClassRegisterABSTRACT
< ChContactContainerBase > 		a_registration_ChContactContainerBase
ChClassRegister
< ChContactContainerGPUsimple > 		a_registration_ChContactContainerGPUsimple
ChClassRegister
< ChControls > 		a_registration_ChControls
const ChFile_ps_color PS_COLOR_WHITE (1, 1, 1)
const ChFile_ps_color PS_COLOR_BLACK (0, 0, 0)
ChClassRegister
< ChForce > 		a_registration_ChForce
ChClassRegister
< ChFunction > 		a_registration
ChClassRegister
< ChFunction_Ramp > 		a_registration_ramp
ChClassRegister
< ChFunction_Sine > 		a_registration_sine
ChClassRegister
< ChFunction_Sigma > 		a_registration_sigma
ChClassRegister
< ChFunction_ConstAcc > 		a_registration_constacc
ChClassRegister
< ChFunction_Poly345 > 		a_registration_poly345
ChClassRegister
< ChFunction_Fillet3 > 		a_registration_fillet3
ChClassRegister
< ChFunction_Mocap > 		a_registration_mocap
ChClassRegister
< ChFunction_Poly > 		a_registration_poly
ChClassRegister
< ChFunction_Operation > 		a_registration_operation
ChClassRegister
< ChFunction_Derive > 		a_registration_derive
ChClassRegister
< ChFunction_Integrate > 		a_registration_integrate
ChClassRegister
< ChFunction_Mirror > 		a_registration_mirror
ChClassRegister
< ChFunction_Repeat > 		a_registration_repeat
ChClassRegister
< ChFunction_Recorder > 		a_registration_recorder
ChClassRegister
< ChFunction_Oscilloscope > 		a_registration_oscilloscope
ChClassRegister
< ChFunction_Sequence > 		a_registration_sequence
ChClassRegister
< ChFunction_Matlab > 		a_registration_matlab
ChClassRegister
< ChFunction_Jscript > 		a_registration_jscript
ChClassRegister
< ChFunction_Noise > 		a_registration_noise
ChGlobals * GLOBAL_Vars = 0
ChGlobals * GLOBAL_Vars
ChClassRegister< ChLink > a_registration_ChLink
ChClassRegister
< ChLinkBrake > 		a_registration_ChLinkBrake
ChClassRegister
< ChLinkClearance > 		a_registration_ChLinkClearance
ChClassRegisterABSTRACT
< ChLinkContact > 		a_registration_ChLinkContact
ChClassRegister
< ChLinkDistance > 		a_registration_ChLinkDistance
ChClassRegister
< ChLinkEngine > 		a_registration_ChLinkEngine
ChClassRegister
< ChLinkFastContact > 		a_registration_ChLinkFastContact
ChClassRegister
< ChLinkGear > 		a_registration_ChLinkGear
ChClassRegister
< ChLinkGPUcontact > 		a_registration_ChLinkGPUcontact
ChClassRegister
< ChLinkLinActuator > 		a_registration_ChLinkLinActuator
ChClassRegister
< ChLinkLock > 		a_registration_ChLinkLock
ChClassRegister
< ChLinkMarkers > 		a_registration_ChLinkMarkers
ChClassRegister
< ChLinkMask > 		a_registration_ChLinkMask
ChClassRegister
< ChLinkMaskLF > 		a_registration_ChLinkMaskLF
ChClassRegister
< ChLinkMasked > 		a_registration_ChLinkMasked
ChClassRegister
< ChLinkNumdiff > 		a_registration_ChLinkNumdiff
ChClassRegister
< ChLinkPneumaticActuator > 		a_registration_ChLinkPneumaticActuator
ChClassRegister
< ChLinkPointSpline > 		a_registration_ChLinkPointSpline
ChClassRegister
< ChLinkPulley > 		a_registration_ChLinkPulley
ChClassRegister
< ChLinkScrew > 		a_registration_ChLinkScrew
ChClassRegister
< ChLinkSpring > 		a_registration_ChLinkSpring
ChClassRegister
< ChLinkTrajectory > 		a_registration_ChLinkTrajectory
ChClassRegister
< ChLinkWheel > 		a_registration_ChLinkWheel
ChClassRegister
< ChMarker > 		a_registration_ChMarker
ChClassRegister< ChObj > a_registration_ChObj
ChClassRegister
< ChParticles > 		a_registration_ChParticles
ChClassRegister
< ChPhysicsItem > 		a_registration_ChPhysicsItem
ChClassRegister
< ChSystem > 		a_registration_ChSystem

Typedef Documentation

typedef ChCoordsys<double> chrono::Coordsys

Shortcut for faster use of typical double-precision coordsys. Instead of writing "ChCoordsys<double> foo;" you can write the shorter version "Coordsys foo;"

typedef ChCoordsys<float> chrono::CoordsysF

Shortcut for faster use of typical single-precision coordsys.

typedef ChQuaternion<double> chrono::Quaternion

Shortcut for faster use of typical double-precision quaternion. Instead of writing "ChQuaternion<double> foo;" you can write the shorter version "Quaternion foo;"

typedef ChQuaternion<float> chrono::QuaternionF

Shortcut for faster use of typical single-precision quaternion.

typedef ChVector<double> chrono::Vector

Shortcut for faster use of typical double-precision vectors. Instead of writing ChVector<double> foo; you can write the shorter version Vector foo;

typedef ChVector<float> chrono::VectorF

Shortcut for faster use of typical single-precision vectors.

Enumeration Type Documentation

anonymous enum

OPERATION BETWEEN FUNCTIONS (math operation between A and B operands

enum chrono::eChConstraintMode

Modes for constraint.

Enumerator:
CONSTRAINT_FREE  the constraint does not enforce anything
CONSTRAINT_LOCK  the constraint enforces c_i=0;
CONSTRAINT_UNILATERAL  the constraint enforces complementarity c_i>0, l_i>0, l_1*c_i=0;
CONSTRAINT_FRIC  the constraint is one of three reactions in friction (cone complementarity problem)

Function Documentation

double chrono::CalcFO ( double  x[],
void *  idData 
)

Ch_local_optimizer Local optimization engine member functions

int chrono::ch_iterative_TFQMR ( ChMatrix<> &  x,
ChMatrix<> &  b,
void(*)(ChMatrix<> &inX, ChMatrix<> &outB, void *userdata)  SolveAX,
void(*)(ChMatrix<> &eIn, ChMatrix<> &eOut, void *userdata)  M1_solve,
void(*)(ChMatrix<> &eIn, ChMatrix<> &eOut, void *userdata)  M2_solve,
double  min_kappa,
int  max_iterations,
int &  iter,
int &  error_code,
void *  userdata 
)

category: itl,algorithms component: function definition: tfqmr.h tparam: Matrix or multiplier for matrix free methods tparam: Vector tparam: Vector tparam: Preconditioner - Incomplete LU, Incomplete LU with threshold, SSOR or identity_preconditioner. tparam: Iteration - Controls the stopping criteria

TF-QMR

TRANSPOSE-FREE QUASI-MINIMAL-RESIDUAL solver for linear systems.

Iterative method to solve linear systems Ax=b, applies to both symmetric and non simmetric matrices, does not breakdown for singular matrices, accepts preconditioning.

x = initial guess for X0 and also matrix to store final value; b = known term vector in Ax=b SolveAX = function which computes b"=Ax (gets x as 1st parameter, outputs in b", the 2nd param, and may use some user data as 3rd param.) M1_solve = function which performs preconditioner M matrix solve as Out=M'*In M2_solve = function which performs preconditioner M matrix solve as Out=M'*In min_kappa = threshold for convergence max_iterations = limit on number of iterations iter = returns tot iterations done before exiting error_code= returns error, if any: 0: convergence within maximum iterations 1: no convergence after maximum iterations 2: breakdown in tau 3: breakdown in alpha 4: breakdown in gamma 5: breakdown in rho userdata = generic pointer to whatever one needs (it will be passed to SolveAX as 3rd parameter, so it may be useful to pass some pointer to application, geometric or modeling data, etc., then avoiding the use of global vars.)

int chrono::ch_iterative_TFQMR_easy ( ChMatrix<> &  A,
ChMatrix<> &  x,
ChMatrix<> &  b,
double  mkappa,
int  max_iterations 
)

As before, but with less parameters, easier to use.

double chrono::CHatan2 ( double  mcos,
double  msin 
)

Computes the atan2, returning angle given cosine and sine.

int chrono::ChLineLineIntersect ( Vector  p1,
Vector  p2,
Vector  p3,
Vector  p4,
Vector *  pa,
Vector *  pb,
double *  mua,
double *  mub 
)

Calculate the line segment PaPb that is the shortest route between two lines P1P2 and P3P4. Calculate also the values of mua and mub where Pa = P1 + mua (P2 - P1) Pb = P3 + mub (P4 - P3) Return FALSE if no solution exists.

double chrono::CHmax ( double  a,
double  b 
)

Maximum between two values.

int chrono::CHmax ( int  a,
int  b 
)

Maximum between two values.

double chrono::CHmin ( double  a,
double  b 
)

Minimum between two values.

int chrono::CHmin ( int  a,
int  b 
)

Minimum between two values.

double chrono::CHnoise ( double  x,
double  amp,
double  freq,
int  octaves,
double  amp_ratio 
)

Computes a 1D harmonic multi-octave noise.

void chrono::ChPeriodicPar ( double &  u,
int  closed 
)

Parameter make periodic in 0..1 (using 0..1 modulus if closed, otherwise clamping in 0..1 range)

double chrono::ChPointLineDistance ( Vector  p,
Vector  dA,
Vector  dB,
double &  mu,
int &  is_insegment 
)

Calculate distance between a point p and a line identified with segment dA,dB. Returns distance. Also, the mu value reference tells if the nearest projection of point on line falls into segment (for mu 0...1)

double chrono::ChPointTriangleDistance ( Vector  B,
Vector  A1,
Vector  A2,
Vector  A3,
double &  mu,
double &  mv,
int &  is_into,
Vector &  Bprojected 
)

Calculate distance of a point from a triangle surface. Also computes if projection is inside the triangle.

double chrono::CHrandom (  ) 

Returns random value in (0..1) interval with Park-Miller method.

void chrono::CHsetRandomSeed ( long  newseed  ) 

Sets the seed of the CHrandom function (Park-Miller method).

template<class T>
void chrono::create ( std::string  cls_name,
T **  ppObj 
)

This function return a pointer to an object that belong to the class specified by the string cls_name. If success put in *ppObj that pointer, otherwise put a NULL value in *ppObj.

ChGlobals * chrono::DLL_CreateGlobals (  ) 

Create and returns the GLOBAL_Vars object. Must be called ALWAYS at the beginning of the program using Chrono dll.

void chrono::DLL_DeleteGlobals (  ) 

Deletes the GLOBAL_Vars object. Must be called ALWAYS at the end of the program using Chrono dll.

Coordsys chrono::Force2Dcsys ( Coordsys *  cs  ) 

Force 3d coordsys to lie on a XY plane (note: no normaliz. on quat).

ChLog & chrono::GetLog (  ) 

Global function to get the current ChLog object.

template<class Real>
ChVector<Real> chrono::operator * ( const double  v,
const ChVector< Real >  V 
)

Operator for scaling the vector by a scalar value, as v*s.

void chrono::SetLog ( ChLog &  new_logobject  ) 

Global function to set another ChLog object as current 'global' logging system. For example, a plugin developer may like to see logs on a GUI dialog: if so, he can inherit a specialized ChLog class (overriding the Output() function) and use the SetLog() function to have it available all times. Doing so, in your code you can write, for example:

chrono::GetLog() << "message";

void chrono::SetLogDefault (  ) 

Global function to set the default ChLogConsole output to std::output.

template<class T>
void chrono::StreamSwapBytes ( T *  ptData  ) 

Templated function for swapping bytes of objects of type 'T', in general fo rwhatever T type. This is used for cross-platform compatibility when sharing objects between big-endian and little-endian memory models, depending on the microprocessor type.

Variable Documentation

ChClassRegister<ChControls> chrono::a_registration_ChControls

CLASS

const int chrono::BODY_DOF = 6

degrees of freedom of body in 3d space

const int chrono::BODY_QDOF = 7

degrees of freedom with quaternion rotation state

const int chrono::BODY_ROT = 3

rotational dof in Newton dynamics

ChGlobals* chrono::GLOBAL_Vars

DECLARE THAT THERE'S A GLOBAL POINTER TO A "GLOBAL_Vars" OBJECT!!! (this global object will be created, for example, at plugin loading, or as soon as a main() has begun. The pointer will be set there! Using a DLL, you can create global vars and initialize them by using the shortcut DLL_CreateGlobals(), for example, in CHapidll.h.

ChGlobals* chrono::GLOBAL_Vars = 0

DECLARE THAT THERE'S A GLOBAL POINTER TO A "GLOBAL_Vars" OBJECT!!! (this global object will be created, for example, at plugin loading, or as soon as a main() has begun. The pointer will be set there! Using a DLL, you can create global vars and initialize them by using the shortcut DLL_CreateGlobals(), for example, in CHapidll.h.

CHRONO::ENGINE
C++ library for multibody simulation, (C) Alessandro Tasora
This API documentation has been generated on 17 Jul 2009 by Doxygen