Description

Physical system.

This class is used to represent a multibody physical system, so it acts also as a database for most items involved in simulations, most noticeably objects of ChBody and ChLink classes, which are used to represent mechanisms.

Moreover, it also owns some global settings and features, like the gravity acceleration, the global time and so on.

This object will be responsible of performing the entire physical simulation (dynamics, kinematics, statics, etc.), so you need at least one ChSystem object in your program, in order to perform simulations (you'll insert rigid bodies and links into it..)

Note that this is an abstract class, in your code you must create a system from one of the concrete classes: chrono::ChSystemNSC (for non-smooth contacts) or chrono::ChSystemSMC (for smooth 'penalty' contacts).

Further info at the Simulation system manual page.

#include <ChSystem.h>

Inheritance diagram for chrono::ChSystem:
Collaboration diagram for chrono::ChSystem:

Classes

class  CustomCollisionCallback
 Class to be used as a callback interface for user defined actions performed at each collision detection step. More...
 

Public Member Functions

 ChSystem ()
 Create a physical system.
 
 ChSystem (const ChSystem &other)
 Copy constructor.
 
virtual ~ChSystem ()
 Destructor.
 
virtual ChSystemClone () const =0
 "Virtual" copy constructor. More...
 
void SetStep (double m_step)
 Sets the time step used for integration (dynamical simulation). More...
 
double GetStep () const
 Gets the current time step used for the integration (dynamical simulation).
 
void SetStepMin (double m_step_min)
 Sets the lower limit for time step (only needed if using integration methods which support time step adaption).
 
double GetStepMin () const
 Gets the lower limit for time step.
 
void SetStepMax (double m_step_max)
 Sets the upper limit for time step (only needed if using integration methods which support time step adaption).
 
double GetStepMax () const
 Gets the upper limit for time step.
 
void SetTimestepperType (ChTimestepper::Type type)
 Set the method for time integration (time stepper type). More...
 
ChTimestepper::Type GetTimestepperType () const
 Get the current method for time integration (time stepper type).
 
void SetTimestepper (std::shared_ptr< ChTimestepper > mstepper)
 Set the timestepper object to be used for time integration.
 
std::shared_ptr< ChTimestepperGetTimestepper () const
 Get the timestepper currently used for time integration.
 
void SetMaxiter (int m_maxiter)
 Sets outer iteration limit for assembly constraints. More...
 
int GetMaxiter () const
 Gets iteration limit for assembly constraints.
 
virtual void SetMaterialCompositionStrategy (std::unique_ptr< ChMaterialCompositionStrategy > &&strategy)
 Change the default composition laws for contact surface materials (coefficient of friction, cohesion, compliance, etc.)
 
const ChMaterialCompositionStrategyGetMaterialCompositionStrategy () const
 Accessor for the current composition laws for contact surface material.
 
void SetMinBounceSpeed (double mval)
 For elastic collisions, with objects that have nonzero restitution coefficient: objects will rebounce only if their relative colliding speed is above this threshold. More...
 
double GetMinBounceSpeed () const
 Objects will rebounce only if their relative colliding speed is above this threshold.
 
void SetMaxPenetrationRecoverySpeed (double mval)
 For the default stepper, you can limit the speed of exiting from penetration situations. More...
 
double GetMaxPenetrationRecoverySpeed () const
 Get the limit on the speed for exiting from penetration situations (for Anitescu stepper)
 
virtual void SetSolver (std::shared_ptr< ChSolver > newsolver)
 Attach a solver (derived from ChSolver) for use by this system.
 
virtual std::shared_ptr< ChSolverGetSolver ()
 Access the solver currently associated with this system.
 
void SetSolverType (ChSolver::Type type)
 Choose the solver type, to be used for the simultaneous solution of the constraints in dynamical simulations (as well as in kinematics, statics, etc.) More...
 
ChSolver::Type GetSolverType () const
 Gets the current solver type.
 
void SetSolverMaxIterations (int max_iters)
 Set the maximum number of iterations, if using an iterative solver. More...
 
int GetSolverMaxIterations () const
 Get the current maximum number of iterations, if using an iterative solver. More...
 
void SetSolverTolerance (double tolerance)
 Set the solver tolerance threshold (used with iterative solvers only). More...
 
double GetSolverTolerance () const
 Get the current tolerance value (used with iterative solvers only).
 
void SetSolverForceTolerance (double tolerance)
 Set a solver tolerance threshold at force level (default: not specified). More...
 
double GetSolverForceTolerance () const
 Get the current value of the force-level tolerance (used with iterative solvers only).
 
void SetSystemDescriptor (std::shared_ptr< ChSystemDescriptor > newdescriptor)
 Instead of using the default 'system descriptor', you can create your own custom descriptor (inherited from ChSystemDescriptor) and plug it into the system using this function.
 
std::shared_ptr< ChSystemDescriptorGetSystemDescriptor ()
 Access directly the 'system descriptor'.
 
void Set_G_acc (const ChVector<> &m_acc)
 Set the G (gravity) acceleration vector, affecting all the bodies in the system.
 
const ChVectorGet_G_acc () const
 Get the G (gravity) acceleration vector affecting all the bodies in the system.
 
double GetChTime () const
 Get the simulation time of this system.
 
void SetChTime (double time)
 Set (overwrite) the simulation time of this system.
 
virtual void SetNumThreads (int num_threads_chrono, int num_threads_collision=0, int num_threads_eigen=0)
 Set the number of OpenMP threads used by Chrono itself, Eigen, and the collision detection system. More...
 
int GetNumThreadsChrono () const
 
int GetNumthreadsCollision () const
 
int GetNumthreadsEigen () const
 
const ChAssemblyGetAssembly () const
 Get the underlying assembly containing all physics items.
 
virtual void AddBody (std::shared_ptr< ChBody > body)
 Attach a body to the underlying assembly.
 
virtual void AddLink (std::shared_ptr< ChLinkBase > link)
 Attach a link to the underlying assembly.
 
virtual void AddMesh (std::shared_ptr< fea::ChMesh > mesh)
 Attach a mesh to the underlying assembly.
 
virtual void AddOtherPhysicsItem (std::shared_ptr< ChPhysicsItem > item)
 Attach a ChPhysicsItem object that is not a body, link, or mesh.
 
void Add (std::shared_ptr< ChPhysicsItem > item)
 Attach an arbitrary ChPhysicsItem (e.g. More...
 
void AddBatch (std::shared_ptr< ChPhysicsItem > item)
 Items added in this way are added like in the Add() method, but not instantly, they are simply queued in a batch of 'to add' items, that are added automatically at the first Setup() call. More...
 
void FlushBatch ()
 If some items are queued for addition in the assembly, using AddBatch(), this will effectively add them and clean the batch. More...
 
virtual void RemoveBody (std::shared_ptr< ChBody > body)
 Remove a body from this assembly.
 
virtual void RemoveLink (std::shared_ptr< ChLinkBase > link)
 Remove a link from this assembly.
 
virtual void RemoveMesh (std::shared_ptr< fea::ChMesh > mesh)
 Remove a mesh from the assembly.
 
virtual void RemoveOtherPhysicsItem (std::shared_ptr< ChPhysicsItem > item)
 Remove a ChPhysicsItem object that is not a body or a link.
 
void Remove (std::shared_ptr< ChPhysicsItem > item)
 Remove arbitrary ChPhysicsItem that was added to the underlying assembly.
 
void RemoveAllBodies ()
 Remove all bodies from the underlying assembly.
 
void RemoveAllLinks ()
 Remove all links from the underlying assembly.
 
void RemoveAllMeshes ()
 Remove all meshes from the underlying assembly.
 
void RemoveAllOtherPhysicsItems ()
 Remove all physics items not in the body, link, or mesh lists.
 
const std::vector< std::shared_ptr< ChBody > > & Get_bodylist () const
 Get the list of bodies.
 
const std::vector< std::shared_ptr< ChLinkBase > > & Get_linklist () const
 Get the list of links.
 
const std::vector< std::shared_ptr< fea::ChMesh > > & Get_meshlist () const
 Get the list of meshes.
 
const std::vector< std::shared_ptr< ChPhysicsItem > > & Get_otherphysicslist () const
 Get the list of physics items that are not in the body or link lists.
 
std::shared_ptr< ChBodySearchBody (const char *name)
 Search a body by its name.
 
std::shared_ptr< ChLinkBaseSearchLink (const char *name)
 Search a link by its name.
 
std::shared_ptr< fea::ChMeshSearchMesh (const char *name)
 Search a mesh by its name.
 
std::shared_ptr< ChPhysicsItemSearchOtherPhysicsItem (const char *name)
 Search from other ChPhysics items (not bodies, links, or meshes) by name.
 
std::shared_ptr< ChMarkerSearchMarker (const char *name)
 Search a marker by its name.
 
std::shared_ptr< ChPhysicsItemSearch (const char *name)
 Search an item (body, link or other ChPhysics items) by name.
 
std::shared_ptr< ChBodySearchBodyID (int bodyID)
 Search a body by its ID.
 
std::shared_ptr< ChMarkerSearchMarker (int markID)
 Search a marker by its unique ID.
 
int GetNbodies () const
 Get the number of active bodies (excluding those that are sleeping or are fixed to ground).
 
int GetNbodiesSleeping () const
 Get the number of bodies that are in sleeping mode (excluding fixed bodies).
 
int GetNbodiesFixed () const
 Get the number of bodies that are fixed to ground.
 
int GetNbodiesTotal () const
 Get the total number of bodies in the assembly, including the grounded and sleeping bodies.
 
int GetNlinks () const
 Get the number of links.
 
int GetNmeshes () const
 Get the number of meshes.
 
int GetNphysicsItems () const
 Get the number of other physics items (other than bodies, links, or meshes).
 
int GetNcoords () const
 Get the number of coordinates (considering 7 coords for rigid bodies because of the 4 dof of quaternions).
 
int GetNdof () const
 Get the number of degrees of freedom of the assembly.
 
int GetNdoc () const
 Get the number of scalar constraints added to the assembly, including constraints on quaternion norms.
 
int GetNsysvars () const
 Get the number of system variables (coordinates plus the constraint multipliers, in case of quaternions).
 
int GetNcoords_w () const
 Get the number of coordinates (considering 6 coords for rigid bodies, 3 transl.+3rot.)
 
int GetNdoc_w () const
 Get the number of scalar constraints added to the assembly.
 
int GetNdoc_w_C () const
 Get the number of scalar constraints added to the assembly (only bilaterals).
 
int GetNdoc_w_D () const
 Get the number of scalar constraints added to the assembly (only unilaterals).
 
int GetNsysvars_w () const
 Get the number of system variables (coordinates plus the constraint multipliers).
 
int GetDOF () const
 Get the number of scalar coordinates (ex. dim of position vector)
 
int GetDOF_w () const
 Get the number of scalar coordinates of variables derivatives (ex. dim of speed vector)
 
int GetDOC () const
 Get the number of scalar constraints, if any, in this item.
 
int GetDOC_c () const
 Get the number of scalar constraints, if any, in this item (only bilateral constr.)
 
int GetDOC_d () const
 Get the number of scalar constraints, if any, in this item (only unilateral constr.)
 
void ShowHierarchy (ChStreamOutAscii &m_file, int level=0) const
 Write the hierarchy of contained bodies, markers, etc. More...
 
void Clear ()
 Removes all bodies/marker/forces/links/contacts, also resets timers and events.
 
virtual ChContactMethod GetContactMethod () const =0
 Return the contact method supported by this system. More...
 
virtual ChBodyNewBody ()
 Create and return the pointer to a new body. More...
 
virtual ChBodyAuxRefNewBodyAuxRef ()
 Create and return the pointer to a new body with auxiliary reference frame. More...
 
void Reference_LM_byID ()
 Given inserted markers and links, restores the pointers of links to markers given the information about the marker IDs. More...
 
int GetNcontacts ()
 Gets the number of contacts.
 
virtual double GetTimerStep () const
 Return the time (in seconds) spent for computing the time step.
 
virtual double GetTimerAdvance () const
 Return the time (in seconds) for time integration, within the time step.
 
virtual double GetTimerLSsolve () const
 Return the time (in seconds) for the solver, within the time step. More...
 
virtual double GetTimerLSsetup () const
 Return the time (in seconds) for the solver Setup phase, within the time step.
 
virtual double GetTimerJacobian () const
 Return the time (in seconds) for calculating/loading Jacobian information, within the time step.
 
virtual double GetTimerCollision () const
 Return the time (in seconds) for runnning the collision detection step, within the time step.
 
virtual double GetTimerSetup () const
 Return the time (in seconds) for system setup, within the time step.
 
virtual double GetTimerUpdate () const
 Return the time (in seconds) for updating auxiliary data, within the time step.
 
double GetTimerCollisionBroad () const
 Return the time (in seconds) for broadphase collision detection, within the time step.
 
double GetTimerCollisionNarrow () const
 Return the time (in seconds) for narrowphase collision detection, within the time step.
 
void ResetTimers ()
 Resets the timers.
 
virtual void Setup ()
 Counts the number of bodies and links. More...
 
void Update (double mytime, bool update_assets=true)
 Updates all the auxiliary data and children of bodies, forces, links, given their current state.
 
void Update (bool update_assets=true)
 Updates all the auxiliary data and children of bodies, forces, links, given their current state.
 
void ForceUpdate ()
 In normal usage, no system update is necessary at the beginning of a new dynamics step (since an update is performed at the end of a step). More...
 
void IntToDescriptor (const unsigned int off_v, const ChStateDelta &v, const ChVectorDynamic<> &R, const unsigned int off_L, const ChVectorDynamic<> &L, const ChVectorDynamic<> &Qc)
 
void IntFromDescriptor (const unsigned int off_v, ChStateDelta &v, const unsigned int off_L, ChVectorDynamic<> &L)
 
void InjectVariables (ChSystemDescriptor &mdescriptor)
 
void InjectConstraints (ChSystemDescriptor &mdescriptor)
 
void ConstraintsLoadJacobians ()
 
void InjectKRMmatrices (ChSystemDescriptor &mdescriptor)
 
void KRMmatricesLoad (double Kfactor, double Rfactor, double Mfactor)
 
void VariablesFbReset ()
 
void VariablesFbLoadForces (double factor=1)
 
void VariablesQbLoadSpeed ()
 
void VariablesFbIncrementMq ()
 
void VariablesQbSetSpeed (double step=0)
 
void VariablesQbIncrementPosition (double step)
 
void ConstraintsBiReset ()
 
void ConstraintsBiLoad_C (double factor=1, double recovery_clamp=0.1, bool do_clamp=false)
 
void ConstraintsBiLoad_Ct (double factor=1)
 
void ConstraintsBiLoad_Qc (double factor=1)
 
void ConstraintsFbLoadForces (double factor=1)
 
void ConstraintsFetch_react (double factor=1)
 
virtual int GetNcoords_x () override
 Tells the number of position coordinates x in y = {x, v}.
 
virtual int GetNcoords_v () override
 Tells the number of speed coordinates of v in y = {x, v} and dy/dt={v, a}.
 
virtual int GetNconstr () override
 Tells the number of lagrangian multipliers (constraints)
 
virtual void StateGather (ChState &x, ChStateDelta &v, double &T) override
 From system to state y={x,v}.
 
virtual void StateScatter (const ChState &x, const ChStateDelta &v, const double T, bool full_update) override
 From state Y={x,v} to system. This also triggers an update operation.
 
virtual void StateGatherAcceleration (ChStateDelta &a) override
 From system to state derivative (acceleration), some timesteppers might need last computed accel.
 
virtual void StateScatterAcceleration (const ChStateDelta &a) override
 From state derivative (acceleration) to system, sometimes might be needed.
 
virtual void StateGatherReactions (ChVectorDynamic<> &L) override
 From system to reaction forces (last computed) - some timestepper might need this.
 
virtual void StateScatterReactions (const ChVectorDynamic<> &L) override
 From reaction forces to system, ex. store last computed reactions in ChLink objects for plotting etc.
 
virtual void StateIncrementX (ChState &x_new, const ChState &x, const ChStateDelta &Dx) override
 Perform x_new = x + dx, for x in Y = {x, dx/dt}. More...
 
virtual bool StateSolveCorrection (ChStateDelta &Dv, ChVectorDynamic<> &L, const ChVectorDynamic<> &R, const ChVectorDynamic<> &Qc, const double c_a, const double c_v, const double c_x, const ChState &x, const ChStateDelta &v, const double T, bool force_state_scatter, bool full_update, bool force_setup) override
 Assuming a DAE of the form. More...
 
virtual void LoadResidual_F (ChVectorDynamic<> &R, const double c) override
 Increment a vector R with the term c*F: R += c*F. More...
 
virtual void LoadResidual_Mv (ChVectorDynamic<> &R, const ChVectorDynamic<> &w, const double c) override
 Increment a vector R with a term that has M multiplied a given vector w: R += c*M*w. More...
 
virtual void LoadResidual_CqL (ChVectorDynamic<> &R, const ChVectorDynamic<> &L, const double c) override
 Increment a vectorR with the term Cq'*L: R += c*Cq'*L. More...
 
virtual void LoadConstraint_C (ChVectorDynamic<> &Qc, const double c, const bool do_clamp=false, const double clamp=1e30) override
 Increment a vector Qc with the term C: Qc += c*C. More...
 
virtual void LoadConstraint_Ct (ChVectorDynamic<> &Qc, const double c) override
 Increment a vector Qc with the term Ct = partial derivative dC/dt: Qc += c*Ct. More...
 
virtual void CustomEndOfStep ()
 Executes custom processing at the end of step. More...
 
double ComputeCollisions ()
 Perform the collision detection. More...
 
void RegisterCustomCollisionCallback (std::shared_ptr< CustomCollisionCallback > callback)
 Specify a callback object to be invoked at each collision detection step. More...
 
void UnregisterCustomCollisionCallback (std::shared_ptr< CustomCollisionCallback > callback)
 Remove the given collision callback from this system.
 
virtual void SetCollisionSystemType (collision::ChCollisionSystemType type)
 Change the underlying collision detection system to the specified type. More...
 
virtual void SetCollisionSystem (std::shared_ptr< collision::ChCollisionSystem > newcollsystem)
 Change the underlying collision system. More...
 
std::shared_ptr< collision::ChCollisionSystemGetCollisionSystem () const
 Access the underlying collision system. More...
 
virtual void SetContactContainer (collision::ChCollisionSystemType type)
 Change the underlying contact container given the specified type of the collision detection system. More...
 
virtual void SetContactContainer (std::shared_ptr< ChContactContainer > contactcontainer)
 Change the underlying contact container. More...
 
std::shared_ptr< ChContactContainerGetContactContainer () const
 Access the underlying contact container. More...
 
void SetUseSleeping (bool ms)
 Turn on this feature to let the system put to sleep the bodies whose motion has almost come to a rest. More...
 
bool GetUseSleeping () const
 Tell if the system will put to sleep the bodies whose motion has almost come to a rest.
 
int DoStepDynamics (double step_size)
 Advances the dynamical simulation for a single step, of length step_size. More...
 
bool DoFrameDynamics (double end_time)
 Performs integration until the m_endtime is exactly reached, but current time step may be automatically "retouched" to meet exactly the m_endtime after n steps. More...
 
bool DoEntireDynamics (double end_time)
 Given the current state, the sw simulates the dynamical behavior of the system, until the end time is reached, repeating many steps (maybe the step size will be automatically changed if the integrator method supports step size adaption).
 
bool DoEntireUniformDynamics (double end_time, double frame_step)
 Like "DoEntireDynamics", but results are provided at uniform steps "frame_step", using the DoFrameDynamics() many times.
 
size_t GetStepcount () const
 Return the total number of time steps taken so far.
 
void ResetStepcount ()
 Reset to 0 the total number of time steps.
 
int GetSolverCallsCount () const
 Return the number of calls to the solver's Solve() function. More...
 
int GetSolverSetupCount () const
 Return the number of calls to the solver's Setup() function. More...
 
void SetDumpSolverMatrices (bool md)
 Set this to "true" to enable automatic saving of solver matrices at each time step, for debugging purposes. More...
 
bool GetDumpSolverMatrices () const
 
void DumpSystemMatrices (bool save_M, bool save_K, bool save_R, bool save_Cq, const char *path)
 Dump the current M mass matrix, K damping matrix, R damping matrix, Cq constraint jacobian matrix (at the current configuration). More...
 
void GetMassMatrix (ChSparseMatrix *M)
 Compute the system-level mass matrix. More...
 
void GetStiffnessMatrix (ChSparseMatrix *K)
 Compute the system-level stiffness matrix, i.e. More...
 
void GetDampingMatrix (ChSparseMatrix *R)
 Compute the system-level damping matrix, i.e. More...
 
void GetConstraintJacobianMatrix (ChSparseMatrix *Cq)
 Compute the system-level constraint jacobian matrix, i.e. More...
 
bool DoStepKinematics (double step_size)
 Advances the kinematic simulation for a single step of given length.
 
bool DoFrameKinematics (double end_time)
 Performs kinematics until the end time is exactly reached. More...
 
bool DoEntireKinematics (double end_time)
 Given the current state, this kinematic simulation satisfies all the constraints with the "DoStepKinematics" procedure for each time step, from the current time to the end time.
 
bool DoAssembly (int action)
 Given the current time and state, attempt to satisfy all constraints, using a Newton-Raphson iteration loop. More...
 
bool DoFullAssembly ()
 Shortcut for full position/velocity/acceleration assembly.
 
bool DoStaticAnalysis (std::shared_ptr< ChStaticAnalysis > analysis)
 Perform a generic static analysis. More...
 
bool DoStaticLinear ()
 Solve the position of static equilibrium (and the reactions). More...
 
bool DoStaticNonlinear (int nsteps=10, bool verbose=false)
 Solve the position of static equilibrium (and the reactions). More...
 
bool DoStaticNonlinearRheonomic (int nsteps=10, bool verbose=false, std::shared_ptr< ChStaticNonLinearRheonomicAnalysis::IterationCallback > mcallback=nullptr)
 Solve the position of static equilibrium (and the reactions). More...
 
bool DoStaticRelaxing (int nsteps=10)
 Finds the position of static equilibrium (and the reactions) starting from the current position. More...
 
virtual void ArchiveOUT (ChArchiveOut &marchive)
 Method to allow serialization of transient data to archives.
 
virtual void ArchiveIN (ChArchiveIn &marchive)
 Method to allow deserialization of transient data from archives.
 
int FileProcessChR (ChStreamInBinary &m_file)
 Process a ".chr" binary file containing the full system object hierarchy as exported -for example- by the R3D modeler, with chrono plug-in version, or by using the FileWriteChR() function.
 
int FileWriteChR (ChStreamOutBinary &m_file)
 Write a ".chr" binary file containing the full system object hierarchy (bodies, forces, links, etc.) (deprecated function - obsolete)
 
- Public Member Functions inherited from chrono::ChIntegrableIIorder
virtual int GetNcoords_a ()
 Return the number of acceleration coordinates of a in dy/dt={v, a} This is a default implementation that works in almost all cases, as dim(a) = dim(v),.
 
virtual void StateSetup (ChState &x, ChStateDelta &v, ChStateDelta &a)
 Set up the system state with separate II order components x, v, a for y = {x, v} and dy/dt={v, a}.
 
virtual bool StateSolveA (ChStateDelta &Dvdt, ChVectorDynamic<> &L, const ChState &x, const ChStateDelta &v, const double T, const double dt, bool force_state_scatter, bool full_update)
 Solve for accelerations: a = f(x,v,t) Given current state y={x,v} , computes acceleration a in the state derivative dy/dt={v,a} and lagrangian multipliers L (if any). More...
 
virtual int GetNcoords_y () override
 Return the number of coordinates in the state Y. More...
 
virtual int GetNcoords_dy () override
 Return the number of coordinates in the state increment. More...
 
virtual void StateGather (ChState &y, double &T) override
 Gather system state in specified array. More...
 
virtual void StateScatter (const ChState &y, const double T, bool full_update) override
 Scatter the states from the provided array to the system. More...
 
virtual void StateGatherDerivative (ChStateDelta &Dydt) override
 Gather from the system the state derivatives in specified array. More...
 
virtual void StateScatterDerivative (const ChStateDelta &Dydt) override
 Scatter the state derivatives from the provided array to the system. More...
 
virtual void StateIncrement (ChState &y_new, const ChState &y, const ChStateDelta &Dy) override
 Increment state array: y_new = y + Dy. More...
 
virtual bool StateSolve (ChStateDelta &dydt, ChVectorDynamic<> &L, const ChState &y, const double T, const double dt, bool force_state_scatter, bool full_update) override
 Solve for state derivatives: dy/dt = f(y,t). More...
 
virtual bool StateSolveCorrection (ChStateDelta &Dy, ChVectorDynamic<> &L, const ChVectorDynamic<> &R, const ChVectorDynamic<> &Qc, const double a, const double b, const ChState &y, const double T, const double dt, bool force_state_scatter, bool full_update, bool force_setup) override final
 Override of method for Ist order implicit integrators. More...
 
- Public Member Functions inherited from chrono::ChIntegrable
virtual void StateSetup (ChState &y, ChStateDelta &dy)
 Set up the system state.
 
virtual void LoadResidual_Hv (ChVectorDynamic<> &R, const ChVectorDynamic<> &v, const double c)
 Increment a vector R (usually the residual in a Newton Raphson iteration for solving an implicit integration step) with a term that has H multiplied a given vector w: R += c*H*w. More...
 

Protected Member Functions

virtual void DescriptorPrepareInject (ChSystemDescriptor &mdescriptor)
 Pushes all ChConstraints and ChVariables contained in links, bodies, etc. into the system descriptor.
 
void SetupInitial ()
 Initial system setup before analysis. More...
 
virtual ChVector GetBodyAppliedForce (ChBody *body)
 Return the resultant applied force on the specified body. More...
 
virtual ChVector GetBodyAppliedTorque (ChBody *body)
 Return the resultant applied torque on the specified body. More...
 

Protected Attributes

ChAssembly assembly
 
std::shared_ptr< ChContactContainercontact_container
 the container of contacts
 
ChVector G_acc
 gravitational acceleration
 
bool is_initialized
 if false, an initial setup is required (i.e. a call to SetupInitial)
 
bool is_updated
 if false, a new update is required (i.e. a call to Update)
 
int ncoords
 number of scalar coordinates (including 4th dimension of quaternions) for all active bodies
 
int ndoc
 number of scalar constraints (including constr. on quaternions)
 
int nsysvars
 number of variables (coords+lagrangian mult.), i.e. = ncoords+ndoc for all active bodies
 
int ncoords_w
 number of scalar coordinates when using 3 rot. dof. per body; for all active bodies
 
int ndoc_w
 number of scalar constraints when using 3 rot. dof. per body; for all active bodies
 
int nsysvars_w
 number of variables when using 3 rot. dof. per body; i.e. = ncoords_w+ndoc_w
 
int ndof
 number of degrees of freedom, = ncoords-ndoc = ncoords_w-ndoc_w ,
 
int ndoc_w_C
 number of scalar constraints C, when using 3 rot. dof. per body (excluding unilaterals)
 
int ndoc_w_D
 number of scalar constraints D, when using 3 rot. dof. per body (only unilaterals)
 
double ch_time
 simulation time of the system
 
double step
 time step
 
double step_min
 min time step
 
double step_max
 max time step
 
double tol_force
 tolerance for forces (used to obtain a tolerance for impulses)
 
int maxiter
 max iterations for nonlinear convergence in DoAssembly()
 
bool use_sleeping
 if true, put to sleep objects that come to rest
 
std::shared_ptr< ChSystemDescriptordescriptor
 system descriptor
 
std::shared_ptr< ChSolversolver
 solver for DVI or DAE problem
 
double min_bounce_speed
 minimum speed for rebounce after impacts. Lower speeds are clamped to 0
 
double max_penetration_recovery_speed
 limit for the speed of penetration recovery (positive, speed of exiting)
 
size_t stepcount
 internal counter for steps
 
int setupcount
 number of calls to the solver's Setup()
 
int solvecount
 number of StateSolveCorrection (reset to 0 at each timestep of static analysis)
 
bool dump_matrices
 for debugging
 
int ncontacts
 total number of contacts
 
collision::ChCollisionSystemType collision_system_type
 type of the collision engine
 
std::shared_ptr< collision::ChCollisionSystemcollision_system
 collision engine
 
std::vector< std::shared_ptr< CustomCollisionCallback > > collision_callbacks
 user-defined collision callbacks
 
std::unique_ptr< ChMaterialCompositionStrategycomposition_strategy
 
int nthreads_chrono
 material composition strategy
 
int nthreads_eigen
 
int nthreads_collision
 
ChTimer< double > timer_step
 timer for integration step
 
ChTimer< double > timer_advance
 timer for time integration
 
ChTimer< double > timer_ls_solve
 timer for solver (excluding setup phase)
 
ChTimer< double > timer_ls_setup
 timer for solver setup
 
ChTimer< double > timer_jacobian
 timer for computing/loading Jacobian information
 
ChTimer< double > timer_collision
 timer for collision detection
 
ChTimer< double > timer_setup
 timer for system setup
 
ChTimer< double > timer_update
 timer for system update
 
std::shared_ptr< ChTimesteppertimestepper
 time-stepper object
 
bool last_err
 indicates error over the last kinematic/dynamics/statics
 
ChVectorDynamic applied_forces
 system-wide vector of applied forces (lazy evaluation)
 
bool applied_forces_current
 indicates if system-wide vector of forces is up-to-date
 

Friends

class ChAssembly
 
class ChBody
 
class fea::ChMesh
 
class ChContactContainerNSC
 
class ChContactContainerSMC
 

Member Function Documentation

◆ Add()

void chrono::ChSystem::Add ( std::shared_ptr< ChPhysicsItem item)

Attach an arbitrary ChPhysicsItem (e.g.

ChBody, ChParticles, ChLink, etc.) to the assembly. It will take care of adding it to the proper list of bodies, links, meshes, or generic physic item. (i.e. it calls AddBody(), AddLink(), AddMesh(), or AddOtherPhysicsItem()). Note, you cannot call Add() during an Update (i.e. items like particle generators that are already inserted in the assembly cannot call this) because not thread safe; instead, use AddBatch().

◆ AddBatch()

void chrono::ChSystem::AddBatch ( std::shared_ptr< ChPhysicsItem item)
inline

Items added in this way are added like in the Add() method, but not instantly, they are simply queued in a batch of 'to add' items, that are added automatically at the first Setup() call.

This is thread safe.

◆ Clone()

virtual ChSystem* chrono::ChSystem::Clone ( ) const
pure virtual

"Virtual" copy constructor.

Concrete derived classes must implement this.

Implemented in chrono::ChSystemMulticoreSMC, chrono::ChSystemMulticoreNSC, chrono::ChSystemSMC, and chrono::ChSystemNSC.

◆ ComputeCollisions()

double chrono::ChSystem::ComputeCollisions ( )

Perform the collision detection.

New contacts are inserted in the ChContactContainer object(s), and old ones are removed. This is mostly called automatically by time integration.

◆ CustomEndOfStep()

virtual void chrono::ChSystem::CustomEndOfStep ( )
inlinevirtual

Executes custom processing at the end of step.

By default it does nothing, but if you inherit a special ChSystem you can implement this.

◆ DoAssembly()

bool chrono::ChSystem::DoAssembly ( int  action)

Given the current time and state, attempt to satisfy all constraints, using a Newton-Raphson iteration loop.

Used iteratively in inverse kinematics. Action can be one of AssemblyLevel::POSITION, AssemblyLevel::VELOCITY, or AssemblyLevel::ACCELERATION (or a combination of these) Returns true if no errors and false if an error occurred (impossible assembly?)

◆ DoFrameDynamics()

bool chrono::ChSystem::DoFrameDynamics ( double  end_time)

Performs integration until the m_endtime is exactly reached, but current time step may be automatically "retouched" to meet exactly the m_endtime after n steps.

Useful when you want to advance the simulation in a simulations (3d modeling software etc.) which needs updates of the screen at a fixed rate (ex.30th of second) while the integration must use more steps.

◆ DoFrameKinematics()

bool chrono::ChSystem::DoFrameKinematics ( double  end_time)

Performs kinematics until the end time is exactly reached.

The current time step may be automatically adjusted to meet exactly the m_endtime after n steps.

◆ DoStaticAnalysis()

bool chrono::ChSystem::DoStaticAnalysis ( std::shared_ptr< ChStaticAnalysis analysis)

Perform a generic static analysis.

Low level API, where the user creates and configures a ChStaticAnalysis-inherited object by his own. For ready-to-use analysis, use DoStaticLinear, DoStaticNonLinear, DoStaticNonlinearRheonomic etc. instead.

◆ DoStaticLinear()

bool chrono::ChSystem::DoStaticLinear ( )

Solve the position of static equilibrium (and the reactions).

This is a one-step only approach that solves the linear equilibrium. Appropriate mostly for FEM problems with small deformations.

◆ DoStaticNonlinear()

bool chrono::ChSystem::DoStaticNonlinear ( int  nsteps = 10,
bool  verbose = false 
)

Solve the position of static equilibrium (and the reactions).

This function solves the equilibrium for the nonlinear problem (large displacements). This version uses a nonlinear static analysis solver with default parameters.

◆ DoStaticNonlinearRheonomic()

bool chrono::ChSystem::DoStaticNonlinearRheonomic ( int  nsteps = 10,
bool  verbose = false,
std::shared_ptr< ChStaticNonLinearRheonomicAnalysis::IterationCallback mcallback = nullptr 
)

Solve the position of static equilibrium (and the reactions).

This function solves the equilibrium for the nonlinear problem (large displacements), but differently from DoStaticNonlinear, it considers rheonomic constraints (ex. ChLinkMotorRotationSpeed) that can impose steady-state speeds&accelerations to the mechanism, ex. to generate centrifugal forces in turbine blades. This version uses a nonlinear static analysis solver with default parameters.

◆ DoStaticRelaxing()

bool chrono::ChSystem::DoStaticRelaxing ( int  nsteps = 10)

Finds the position of static equilibrium (and the reactions) starting from the current position.

Since a truncated iterative method is used, you may need to call this method multiple times in case of large nonlinearities before coming to the precise static solution.

◆ DoStepDynamics()

int chrono::ChSystem::DoStepDynamics ( double  step_size)

Advances the dynamical simulation for a single step, of length step_size.

This function is typically called many times in a loop in order to simulate up to a desired end time.

◆ DumpSystemMatrices()

void chrono::ChSystem::DumpSystemMatrices ( bool  save_M,
bool  save_K,
bool  save_R,
bool  save_Cq,
const char *  path 
)

Dump the current M mass matrix, K damping matrix, R damping matrix, Cq constraint jacobian matrix (at the current configuration).

These can be later used for linearized motion, modal analysis, buckling analysis, etc. The name of the files will be [path]_M.dat [path]_K.dat [path]_R.dat [path]_Cq.dat Might throw ChException if file can't be saved.

◆ FlushBatch()

void chrono::ChSystem::FlushBatch ( )
inline

If some items are queued for addition in the assembly, using AddBatch(), this will effectively add them and clean the batch.

Called automatically at each Setup().

◆ ForceUpdate()

void chrono::ChSystem::ForceUpdate ( )

In normal usage, no system update is necessary at the beginning of a new dynamics step (since an update is performed at the end of a step).

However, this is not the case if external changes to the system are made. Most such changes are discovered automatically (addition/removal of items, input of mesh loads). For special cases, this function allows the user to trigger a system update at the beginning of the step immediately following this call.

◆ GetBodyAppliedForce()

ChVector chrono::ChSystem::GetBodyAppliedForce ( ChBody body)
protectedvirtual

Return the resultant applied force on the specified body.

This resultant force includes all external applied loads acting on the body (from gravity, loads, springs, etc). However, this does not include any constraint forces. In particular, contact forces are not included if using the NSC formulation, but are included when using the SMC formulation.

Reimplemented in chrono::ChSystemMulticore.

◆ GetBodyAppliedTorque()

ChVector chrono::ChSystem::GetBodyAppliedTorque ( ChBody body)
protectedvirtual

Return the resultant applied torque on the specified body.

This resultant torque includes all external applied loads acting on the body (from gravity, loads, springs, etc). However, this does not include any constraint forces. In particular, contact torques are not included if using the NSC formulation, but are included when using the SMC formulation.

Reimplemented in chrono::ChSystemMulticore.

◆ GetCollisionSystem()

std::shared_ptr<collision::ChCollisionSystem> chrono::ChSystem::GetCollisionSystem ( ) const
inline

Access the underlying collision system.

Usually this is not needed, as the collision system is automatically handled by the ChSystem.

◆ GetConstraintJacobianMatrix()

void chrono::ChSystem::GetConstraintJacobianMatrix ( ChSparseMatrix Cq)

Compute the system-level constraint jacobian matrix, i.e.

the jacobian Cq=-dC/dq where C are constraints (the lower left part of the KKT matrix). This function has a small overhead, because it must assembly the sparse matrix -which is used only for the purpose of this function. fill this system damping matrix

◆ GetContactContainer()

std::shared_ptr<ChContactContainer> chrono::ChSystem::GetContactContainer ( ) const
inline

Access the underlying contact container.

Usually this is not needed, as the contact container is automatically handled by the ChSystem.

◆ GetContactMethod()

virtual ChContactMethod chrono::ChSystem::GetContactMethod ( ) const
pure virtual

Return the contact method supported by this system.

Contactables (bodies, FEA nodes, FEA traiangles, etc.) added to this system must be compatible.

Implemented in chrono::ChSystemNSC, chrono::ChSystemMulticoreSMC, chrono::ChSystemMulticoreNSC, and chrono::ChSystemSMC.

◆ GetDampingMatrix()

void chrono::ChSystem::GetDampingMatrix ( ChSparseMatrix R)

Compute the system-level damping matrix, i.e.

the jacobian -dF/dv where F are stiff loads. Note that not all loads provide a jacobian, as this is optional in their implementation. This function has a small overhead, because it must assembly the sparse matrix -which is used only for the purpose of this function. fill this system damping matrix

◆ GetMassMatrix()

void chrono::ChSystem::GetMassMatrix ( ChSparseMatrix M)

Compute the system-level mass matrix.

This function has a small overhead, because it must assembly the sparse matrix -which is used only for the purpose of this function. fill this system mass matrix

◆ GetSolverCallsCount()

int chrono::ChSystem::GetSolverCallsCount ( ) const
inline

Return the number of calls to the solver's Solve() function.

This counter is reset at each timestep.

◆ GetSolverMaxIterations()

int chrono::ChSystem::GetSolverMaxIterations ( ) const

Get the current maximum number of iterations, if using an iterative solver.

Deprecated:
Prefer using GetSolver and accessing solver statistics directly.

◆ GetSolverSetupCount()

int chrono::ChSystem::GetSolverSetupCount ( ) const
inline

Return the number of calls to the solver's Setup() function.

This counter is reset at each timestep.

◆ GetStiffnessMatrix()

void chrono::ChSystem::GetStiffnessMatrix ( ChSparseMatrix K)

Compute the system-level stiffness matrix, i.e.

the jacobian -dF/dq where F are stiff loads. Note that not all loads provide a jacobian, as this is optional in their implementation. This function has a small overhead, because it must assembly the sparse matrix -which is used only for the purpose of this function. fill this system stiffness matrix

◆ GetTimerLSsolve()

virtual double chrono::ChSystem::GetTimerLSsolve ( ) const
inlinevirtual

Return the time (in seconds) for the solver, within the time step.

Note that this time excludes any calls to the solver's Setup function.

Reimplemented in chrono::ChSystemMulticore.

◆ LoadConstraint_C()

void chrono::ChSystem::LoadConstraint_C ( ChVectorDynamic<> &  Qc,
const double  c,
const bool  do_clamp = false,
const double  clamp = 1e30 
)
overridevirtual

Increment a vector Qc with the term C: Qc += c*C.

Parameters
Qcresult: the Qc residual, Qc += c*C
ca scaling factor
do_clampenable optional clamping of Qc
clampclamping value

Reimplemented from chrono::ChIntegrableIIorder.

◆ LoadConstraint_Ct()

void chrono::ChSystem::LoadConstraint_Ct ( ChVectorDynamic<> &  Qc,
const double  c 
)
overridevirtual

Increment a vector Qc with the term Ct = partial derivative dC/dt: Qc += c*Ct.

Parameters
Qcresult: the Qc residual, Qc += c*Ct
ca scaling factor

Reimplemented from chrono::ChIntegrableIIorder.

◆ LoadResidual_CqL()

void chrono::ChSystem::LoadResidual_CqL ( ChVectorDynamic<> &  R,
const ChVectorDynamic<> &  L,
const double  c 
)
overridevirtual

Increment a vectorR with the term Cq'*L: R += c*Cq'*L.

Parameters
Rresult: the R residual, R += c*Cq'*L
Lthe L vector
ca scaling factor

Reimplemented from chrono::ChIntegrableIIorder.

◆ LoadResidual_F()

void chrono::ChSystem::LoadResidual_F ( ChVectorDynamic<> &  R,
const double  c 
)
overridevirtual

Increment a vector R with the term c*F: R += c*F.

Parameters
Rresult: the R residual, R += c*F
ca scaling factor

Reimplemented from chrono::ChIntegrableIIorder.

◆ LoadResidual_Mv()

void chrono::ChSystem::LoadResidual_Mv ( ChVectorDynamic<> &  R,
const ChVectorDynamic<> &  w,
const double  c 
)
overridevirtual

Increment a vector R with a term that has M multiplied a given vector w: R += c*M*w.

Parameters
Rresult: the R residual, R += c*M*v
wthe w vector
ca scaling factor

Reimplemented from chrono::ChIntegrableIIorder.

◆ NewBody()

ChBody * chrono::ChSystem::NewBody ( )
virtual

Create and return the pointer to a new body.

The body is consistent with the type of the collision system currently associated with this ChSystem. Note that the body is not attached to this system.

Reimplemented in chrono::ChSystemDistributed, and chrono::ChSystemMulticore.

◆ NewBodyAuxRef()

ChBodyAuxRef * chrono::ChSystem::NewBodyAuxRef ( )
virtual

Create and return the pointer to a new body with auxiliary reference frame.

The body is consistent with the type of the collision system currently associated with this ChSystem. Note that the body is not attached to this system.

Reimplemented in chrono::ChSystemDistributed, and chrono::ChSystemMulticore.

◆ Reference_LM_byID()

void chrono::ChSystem::Reference_LM_byID ( )

Given inserted markers and links, restores the pointers of links to markers given the information about the marker IDs.

Will be made obsolete in future with new serialization systems.

◆ RegisterCustomCollisionCallback()

void chrono::ChSystem::RegisterCustomCollisionCallback ( std::shared_ptr< CustomCollisionCallback callback)

Specify a callback object to be invoked at each collision detection step.

Multiple such callback objects can be registered with a system. If present, their OnCustomCollision() method is invoked. Use this if you want that some specific callback function is executed at each collision detection step (ex. all the times that ComputeCollisions() is automatically called by the integration method). For example some other collision engine could add further contacts using this callback.

◆ SetCollisionSystem()

void chrono::ChSystem::SetCollisionSystem ( std::shared_ptr< collision::ChCollisionSystem newcollsystem)
virtual

Change the underlying collision system.

By default, a ChSystem uses a Bullet-based collision detection engine.

◆ SetCollisionSystemType()

void chrono::ChSystem::SetCollisionSystemType ( collision::ChCollisionSystemType  type)
virtual

Change the underlying collision detection system to the specified type.

By default, a ChSystem uses a Bullet-based collision detection engine (collision::ChCollisionSystemType::BULLET).

Reimplemented in chrono::ChSystemMulticoreSMC, and chrono::ChSystemMulticore.

◆ SetContactContainer() [1/2]

virtual void chrono::ChSystem::SetContactContainer ( collision::ChCollisionSystemType  type)
inlinevirtual

Change the underlying contact container given the specified type of the collision detection system.

Usually this is not needed, as the contact container is automatically handled by the ChSystem. The default implementation is a no-op, since the default contact container for a ChSystem is suitable for all types of supported collision detection systems.

Reimplemented in chrono::ChSystemMulticoreSMC, and chrono::ChSystemMulticoreNSC.

◆ SetContactContainer() [2/2]

void chrono::ChSystem::SetContactContainer ( std::shared_ptr< ChContactContainer contactcontainer)
virtual

Change the underlying contact container.

The contact container collects information from the underlying collision detection system required for contact force generation. Usually this is not needed, as the contact container is automatically handled by the ChSystem. Make sure the provided contact container is compatible with both the collision detection system and the contact force formulation (NSC or SMC).

Reimplemented in chrono::ChSystemMulticoreSMC, chrono::ChSystemMulticoreNSC, chrono::ChSystemSMC, and chrono::ChSystemNSC.

◆ SetDumpSolverMatrices()

void chrono::ChSystem::SetDumpSolverMatrices ( bool  md)
inline

Set this to "true" to enable automatic saving of solver matrices at each time step, for debugging purposes.

Note that matrices will be saved in the working directory of the exe, with format 0001_01_H.dat 0002_01_H.dat (if the timestepper requires multiple solves, also 0001_01. 0001_02.. etc.) The matrices being saved are: dump_Z.dat has the assembled optimization matrix (Matlab sparse format) dump_rhs.dat has the assembled RHS dump_H.dat has usually H=M (mass), but could be also H=a*M+b*K+c*R or such. (Matlab sparse format) dump_Cq.dat has the jacobians (Matlab sparse format) dump_E.dat has the constr.compliance (Matlab sparse format) dump_f.dat has the applied loads dump_b.dat has the constraint rhs as passed to the solver in the problem

 | H -Cq'|*|q|- | f|= |0|
 | Cq -E | |l|  |-b|  |c|

where l \(\in Y, c \in Ny\), normal cone to Y

◆ SetMaxiter()

void chrono::ChSystem::SetMaxiter ( int  m_maxiter)
inline

Sets outer iteration limit for assembly constraints.

When trying to keep constraints together, the iterative process is stopped if this max.number of iterations (or tolerance) is reached.

◆ SetMaxPenetrationRecoverySpeed()

void chrono::ChSystem::SetMaxPenetrationRecoverySpeed ( double  mval)
inline

For the default stepper, you can limit the speed of exiting from penetration situations.

Usually set a positive value, about 0.1 .. 2 . (as exiting speed, in m/s)

◆ SetMinBounceSpeed()

void chrono::ChSystem::SetMinBounceSpeed ( double  mval)
inline

For elastic collisions, with objects that have nonzero restitution coefficient: objects will rebounce only if their relative colliding speed is above this threshold.

Default 0.15 m/s. If this is too low, aliasing problems can happen with small high frequency rebounces, and settling to static stacking might be more difficult.

◆ SetNumThreads()

void chrono::ChSystem::SetNumThreads ( int  num_threads_chrono,
int  num_threads_collision = 0,
int  num_threads_eigen = 0 
)
virtual

Set the number of OpenMP threads used by Chrono itself, Eigen, and the collision detection system.

  num_threads_chrono    - used in FEA (parallel evaluation of internal forces and Jacobians) and
                          in SCM deformable terrain calculations.
  num_threads_collision - used in parallelization of collision detection (if applicable).
                          If passing 0, then num_threads_collision = num_threads_chrono.
  num_threads_eigen     - used in the Eigen sparse direct solvers and a few linear algebra operations.
                          Note that Eigen enables multi-threaded execution only under certain size conditions.
                          See the Eigen documentation.
                          If passing 0, then num_threads_eigen = num_threads_chrono.
By default (if this function is not called), the following values are used:
  num_threads_chrono = omp_get_num_procs()
  num_threads_collision = 1
  num_threads_eigen = 1

Note that a derived class may ignore some or all of these settings.

Reimplemented in chrono::ChSystemMulticore.

◆ SetSolverForceTolerance()

void chrono::ChSystem::SetSolverForceTolerance ( double  tolerance)
inline

Set a solver tolerance threshold at force level (default: not specified).

Specify this value only if solving the problem at velocity level (e.g. solving a DVI problem). If this tolerance is specified, it is multiplied by the current integration stepsize and overwrites the current solver tolerance. By default, this tolerance is invalid and hence the solver's own tolerance threshold is used.

◆ SetSolverMaxIterations()

void chrono::ChSystem::SetSolverMaxIterations ( int  max_iters)

Set the maximum number of iterations, if using an iterative solver.

Deprecated:
Prefer using SetSolver and setting solver parameters directly.

◆ SetSolverTolerance()

void chrono::ChSystem::SetSolverTolerance ( double  tolerance)

Set the solver tolerance threshold (used with iterative solvers only).

Note that the stopping criteria differs from solver to solver.

◆ SetSolverType()

void chrono::ChSystem::SetSolverType ( ChSolver::Type  type)

Choose the solver type, to be used for the simultaneous solution of the constraints in dynamical simulations (as well as in kinematics, statics, etc.)

  • Suggested solver for speed, but lower precision: PSOR
  • Suggested solver for higher precision: BARZILAIBORWEIN or APGD
  • For problems that involve a stiffness matrix: GMRES, MINRES

Notes:

  • This function is a shortcut, internally equivalent to a call to SetSolver().
  • Only a subset of available Chrono solvers can be set through this mechanism.
  • Prefer explicitly creating a solver, setting solver parameters, and then attaching the solver with SetSolver.
Deprecated:
This function does not support all available Chrono solvers. Prefer using SetSolver.

◆ SetStep()

void chrono::ChSystem::SetStep ( double  m_step)
inline

Sets the time step used for integration (dynamical simulation).

The lower this value, the more precise the simulation. Usually, values about 0.01 s are enough for simple simulations. It may be modified automatically by integration methods, if they support automatic time adaption.

◆ SetTimestepperType()

void chrono::ChSystem::SetTimestepperType ( ChTimestepper::Type  type)

Set the method for time integration (time stepper type).

  • Suggested for fast dynamics with hard (NSC) contacts: EULER_IMPLICIT_LINEARIZED
  • Suggested for fast dynamics with hard (NSC) contacts and low inter-penetration: EULER_IMPLICIT_PROJECTED
  • Suggested for finite element smooth dynamics: HHT, EULER_IMPLICIT_LINEARIZED

Notes:

  • for more advanced customization, use SetTimestepper()
  • old methods ANITESCU and TASORA were replaced by EULER_IMPLICIT_LINEARIZED and EULER_IMPLICIT_PROJECTED, respectively

◆ Setup()

void chrono::ChSystem::Setup ( )
virtual

Counts the number of bodies and links.

Computes the offsets of object states in the global state. Assumes that offset_x, offset_w, and offset_L are already set as starting point for offsetting all the contained sub objects.

Reimplemented in chrono::ChSystemMulticoreSMC, and chrono::ChSystemMulticore.

◆ SetupInitial()

void chrono::ChSystem::SetupInitial ( )
protected

Initial system setup before analysis.

This function performs an initial system setup, once system construction is completed and before an analysis.

◆ SetUseSleeping()

void chrono::ChSystem::SetUseSleeping ( bool  ms)
inline

Turn on this feature to let the system put to sleep the bodies whose motion has almost come to a rest.

This feature will allow faster simulation of large scenarios for real-time purposes, but it will affect the precision! This functionality can be turned off selectively for specific ChBodies.

◆ ShowHierarchy()

void chrono::ChSystem::ShowHierarchy ( ChStreamOutAscii m_file,
int  level = 0 
) const
inline

Write the hierarchy of contained bodies, markers, etc.

in ASCII readable form, mostly for debugging purposes. Level is the tab spacing at the left.

◆ StateIncrementX()

void chrono::ChSystem::StateIncrementX ( ChState x_new,
const ChState x,
const ChStateDelta Dx 
)
overridevirtual

Perform x_new = x + dx, for x in Y = {x, dx/dt}.


It takes care of the fact that x has quaternions, dx has angular vel etc. NOTE: the system is not updated automatically after the state increment, so one might need to call StateScatter() if needed.

Parameters
x_newresulting x_new = x + Dx
xinitial state x
Dxstate increment Dx

Reimplemented from chrono::ChIntegrableIIorder.

◆ StateSolveCorrection()

bool chrono::ChSystem::StateSolveCorrection ( ChStateDelta Dv,
ChVectorDynamic<> &  L,
const ChVectorDynamic<> &  R,
const ChVectorDynamic<> &  Qc,
const double  c_a,
const double  c_v,
const double  c_x,
const ChState x,
const ChStateDelta v,
const double  T,
bool  force_state_scatter,
bool  full_update,
bool  force_setup 
)
overridevirtual

Assuming a DAE of the form.

      M*a = F(x,v,t) + Cq'*L
      C(x,t) = 0

this function computes the solution of the change Du (in a or v or x) for a Newton iteration within an implicit integration scheme.

 |Du| = [ G   Cq' ]^-1 * | R |
 |DL|   [ Cq  0   ]      | Qc|

for residual R and G = [ c_a*M + c_v*dF/dv + c_x*dF/dx ].
This function returns true if successful and false otherwise.

Parameters
Dvresult: computed Dv
Lresult: computed lagrangian multipliers, if any
Rthe R residual
Qcthe Qc residual
c_athe factor in c_a*M
c_vthe factor in c_v*dF/dv
c_xthe factor in c_x*dF/dv
xcurrent state, x part
vcurrent state, v part
Tcurrent time T
force_state_scatterif false, x and v are not scattered to the system
full_updateif true, perform a full update during scatter
force_setupif true, call the solver's Setup() function

Reimplemented from chrono::ChIntegrableIIorder.


The documentation for this class was generated from the following files:
  • /builds/uwsbel/chrono/src/chrono/physics/ChSystem.h
  • /builds/uwsbel/chrono/src/chrono/physics/ChSystem.cpp