MainSystemCreateExt.tex

\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L148}{CreateGround}{}}}\label{sec:mainsystemextensions:CreateGround}
({\it name}= '', {\it referencePosition}= [0.,0.,0.], {\it referenceRotationMatrix}= np.eye(3), {\it graphicsDataList}= [], {\it graphicsDataUserFunction}= 0, {\it show}= True)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create a ground object, using arguments of ObjectGround; this function is mainly added for consistency with other mainSystemExtensions
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateGround.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for object
\item[]{\it referencePosition}: reference coordinates for point node (always a 3D vector, no matter if 2D or 3D mass)
\item[]{\it referenceRotationMatrix}: reference rotation matrix for rigid body node (always 3D matrix, no matter if 2D or 3D body)
\item[]{\it graphicsDataList}: list of GraphicsData for optional ground visualization
\item[]{\it graphicsDataUserFunction}: a user function graphicsDataUserFunction(mbs, itemNumber)->BodyGraphicsData (list of GraphicsData), which can be used to draw user-defined graphics; this is much slower than regular GraphicsData
\item[]{\it color}: color of node
\item[]{\it show}: True: show ground object;
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns ground object index
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  ground=mbs.CreateGround(referencePosition = [2,0,0],
                          graphicsDataList = [exu.graphics.CheckerBoard(point=[0,0,0], normal=[0,1,0],size=4)])
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateGround see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/ballBearningModel.py}{\texttt{ballBearningModel.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/basicTutorial2024.py}{\texttt{basicTutorial2024.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/beamTutorial.py}{\texttt{beamTutorial.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/bicycleIftommBenchmark.py}{\texttt{bicycleIftommBenchmark.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/bungeeJump.py}{\texttt{bungeeJump.py}} (Ex), 
 ...
, 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/ballBearingTest.py}{\texttt{ballBearingTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/contactCurveExample.py}{\texttt{contactCurveExample.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/contactSphereSphereTest.py}{\texttt{contactSphereSphereTest.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L217}{CreateMassPoint}{}}}\label{sec:mainsystemextensions:CreateMassPoint}
({\it name}= '', {\it referencePosition}= [0.,0.,0.], {\it initialDisplacement}= [0.,0.,0.], {\it initialVelocity}= [0.,0.,0.], {\it physicsMass}= 0, {\it gravity}= [0.,0.,0.], {\it graphicsDataList}= [], {\it drawSize}= -1, {\it color}= [-1.,-1.,-1.,-1.], {\it show}= True, {\it create2D}= False, {\it returnDict}= False)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create 2D or 3D mass point object and node, using arguments as in NodePoint and MassPoint
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateMassPoint.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for object, node is 'Node:'+name
\item[]{\it referencePosition}: reference coordinates for point node (always a 3D vector, no matter if 2D or 3D mass)
\item[]{\it initialDisplacement}: initial displacements for point node (always a 3D vector, no matter if 2D or 3D mass)
\item[]{\it initialVelocity}: initial velocities for point node (always a 3D vector, no matter if 2D or 3D mass)
\item[]{\it physicsMass}: mass of mass point
\item[]{\it gravity}: gravity vevtor applied (always a 3D vector, no matter if 2D or 3D mass)
\item[]{\it graphicsDataList}: list of GraphicsData for optional mass visualization
\item[]{\it drawSize}: general drawing size of node
\item[]{\it color}: color of node
\item[]{\it show}: True: if graphicsData list is empty, node is shown, otherwise body is shown; False: nothing is shown
\item[]{\it create2D}: if True, create NodePoint2D and MassPoint2D
\item[]{\it returnDict}: if False, returns object index; if True, returns dict of all information on created object and node
\end{itemize}
\item[--]
{\bf output}: Union[dict, ObjectIndex]; returns mass point object index or dict with all data on request (if returnDict=True)
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0=mbs.CreateMassPoint(referencePosition = [0,0,0],
                         initialVelocity = [2,5,0],
                         physicsMass = 1, gravity = [0,-9.81,0],
                         drawSize = 0.5, color=exu.graphics.color.blue)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateMassPoint see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/basicTutorial2024.py}{\texttt{basicTutorial2024.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/cartesianSpringDamper.py}{\texttt{cartesianSpringDamper.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/cartesianSpringDamperUserFunction.py}{\texttt{cartesianSpringDamperUserFunction.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate.py}{\texttt{chatGPTupdate.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/NGsolveOCCgeometry.py}{\texttt{NGsolveOCCgeometry.py}} (Ex), 
 ...
, 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/deleteItemsTest.py}{\texttt{deleteItemsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/loadUserFunctionTest.py}{\texttt{loadUserFunctionTest.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L351}{CreateRigidBody}{}}}\label{sec:mainsystemextensions:CreateRigidBody}
({\it name}= '', {\it referencePosition}= [0.,0.,0.], {\it referenceRotationMatrix}= np.eye(3), {\it initialVelocity}= [0.,0.,0.], {\it initialAngularVelocity}= [0.,0.,0.], {\it initialDisplacement}= None, {\it initialRotationMatrix}= None, {\it inertia}= None, {\it gravity}= [0.,0.,0.], {\it nodeType}= exudyn.NodeType.RotationEulerParameters, {\it graphicsDataList}= [], {\it graphicsDataUserFunction}= 0, {\it drawSize}= -1, {\it color}= [-1.,-1.,-1.,-1.], {\it show}= True, {\it create2D}= False, {\it returnDict}= False)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create 3D (or 2D) rigid body object and node; all quantities are global (angular velocity, etc.); use this function to easily create a rigid body; graphics can be directly obtained from inertia object, e.g. in case of cylindrical or cuboid shape
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateRigidBody.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for object, node is 'Node:'+name
\item[]{\it referencePosition}: reference position vector for rigid body node (always a 3D vector, no matter if 2D or 3D body)
\item[]{\it referenceRotationMatrix}: reference rotation matrix for rigid body node (always 3D matrix, no matter if 2D or 3D body)
\item[]{\it initialVelocity}: initial translational velocity vector for node (always a 3D vector, no matter if 2D or 3D body)
\item[]{\it initialAngularVelocity}: initial angular velocity vector for node (always a 3D vector, no matter if 2D or 3D body)
\item[]{\it initialDisplacement}: initial translational displacement vector for node (always a 3D vector, no matter if 2D or 3D body); these displacements are deviations from reference position, e.g. for a finite element node [None: unused]
\item[]{\it initialRotationMatrix}: initial rotation provided as matrix (always a 3D matrix, no matter if 2D or 3D body); this rotation is superimposed to reference rotation [None: unused]
\item[]{\it inertia}: an instance of class RigidBodyInertia, see rigidBodyUtilities; may also be from derived class (InertiaCuboid, InertiaMassPoint, InertiaCylinder, ...)
\item[]{\it gravity}: gravity vevtor applied (always a 3D vector, no matter if 2D or 3D mass)
\item[]{\it graphicsDataList}: list of GraphicsData for rigid body visualization; use exudyn.graphics functions to create GraphicsData for basic solids
\item[]{\it graphicsDataUserFunction}: a user function graphicsDataUserFunction(mbs, itemNumber)->BodyGraphicsData (list of GraphicsData), which can be used to draw user-defined graphics; this is much slower than regular GraphicsData
\item[]{\it drawSize}: general drawing size of node
\item[]{\it color}: color of node
\item[]{\it show}: True: if graphicsData list is empty, node is shown, otherwise body is shown; False: nothing is shown
\item[]{\it create2D}: if True, create NodeRigidBody2D and ObjectRigidBody2D
\item[]{\it returnDict}: if False, returns object index; if True, returns dict of all information on created object and node
\end{itemize}
\item[--]
{\bf output}: Union[dict, ObjectIndex]; returns rigid body object index (or dict with 'nodeNumber', 'objectNumber' and possibly 'loadNumber' and 'markerBodyMass' if returnDict=True)
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
                                                   sideLengths=[1,0.1,0.1]),
                           referencePosition = [1,0,0],
                           initialVelocity = [2,5,0],
                           initialAngularVelocity = [5,0.5,0.7],
                           gravity = [0,-9.81,0],
                           graphicsDataList = [exu.graphics.Brick(size=[1,0.1,0.1],
                                                                        color=exu.graphics.color.red)])
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateRigidBody see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/addPrismaticJoint.py}{\texttt{addPrismaticJoint.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/addRevoluteJoint.py}{\texttt{addRevoluteJoint.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/ANCFrotatingCable2D.py}{\texttt{ANCFrotatingCable2D.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/ballBearningModel.py}{\texttt{ballBearningModel.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/bicycleIftommBenchmark.py}{\texttt{bicycleIftommBenchmark.py}} (Ex), 
 ...
, 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/ballBearingTest.py}{\texttt{ballBearingTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/bricardMechanism.py}{\texttt{bricardMechanism.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/carRollingDiscTest.py}{\texttt{carRollingDiscTest.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L589}{CreateSpringDamper}{}}}\label{sec:mainsystemextensions:CreateSpringDamper}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it localPosition0}= [0.,0.,0.], {\it localPosition1}= [0.,0.,0.], {\it referenceLength}= None, {\it stiffness}= 0., {\it damping}= 0., {\it force}= 0., {\it velocityOffset}= 0., {\it springForceUserFunction}= 0, {\it bodyOrNodeList}= [None, None], {\it bodyList}= [None, None], {\it show}= True, {\it drawSize}= -1, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create SpringDamper connector, using arguments from ObjectConnectorSpringDamper; similar interface as CreateDistanceConstraint(...), see there for for further information
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateSpringDamper.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for connector; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of two body numbers (ObjectIndex) to be connected
\item[]{\it localPosition0}: local position (as 3D list or numpy array) on body0, if not a node number
\item[]{\it localPosition1}: local position (as 3D list or numpy array) on body1, if not a node number
\item[]{\it referenceLength}: if None, length is computed from reference position of bodies or nodes; if not None, this scalar reference length is used for spring
\item[]{\it stiffness}: scalar stiffness coefficient
\item[]{\it damping}: scalar damping coefficient
\item[]{\it force}: scalar additional force applied
\item[]{\it velocityOffset}: scalar offset: if referenceLength is changed over time, the velocityOffset may be changed accordingly to emulate a reference motion
\item[]{\it springForceUserFunction}: a user function springForceUserFunction(mbs, t, itemNumber, deltaL, deltaL\_t, stiffness, damping, force)->float ; this function replaces the internal connector force computation
\item[]{\it bodyOrNodeList}: alternative to bodyNumbers; a list of object numbers (with specific localPosition0/1) or node numbers; may alse be mixed types; to use this case, set bodyNumbers = [None,None]
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it drawSize}: general drawing size of connector
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of newly created object
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateMassPoint(referencePosition = [2,0,0],
                           initialVelocity = [2,5,0],
                           physicsMass = 1, gravity = [0,-9.81,0],
                           drawSize = 0.5, color=exu.graphics.color.blue)
  oGround = mbs.AddObject(ObjectGround())
  #add vertical spring
  oSD = mbs.CreateSpringDamper(bodyNumbers=[oGround, b0],
                               localPosition0=[2,1,0],
                               localPosition1=[0,0,0],
                               stiffness=1e4, damping=1e2,
                               drawSize=0.2)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  SC.visualizationSettings.nodes.drawNodesAsPoint=False
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateSpringDamper see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/basicTutorial2024.py}{\texttt{basicTutorial2024.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/camFollowerExample.py}{\texttt{camFollowerExample.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate.py}{\texttt{chatGPTupdate.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/contactCurveWithLongCurve.py}{\texttt{contactCurveWithLongCurve.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/springDamperTutorialNew.py}{\texttt{springDamperTutorialNew.py}} (Ex), 
 ...
, 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/loadUserFunctionTest.py}{\texttt{loadUserFunctionTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/mainSystemExtensionsTests.py}{\texttt{mainSystemExtensionsTests.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L723}{CreateCartesianSpringDamper}{}}}\label{sec:mainsystemextensions:CreateCartesianSpringDamper}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it localPosition0}= [0.,0.,0.], {\it localPosition1}= [0.,0.,0.], {\it stiffness}= [0.,0.,0.], {\it damping}= [0.,0.,0.], {\it offset}= [0.,0.,0.], {\it springForceUserFunction}= 0, {\it bodyOrNodeList}= [None, None], {\it bodyList}= [None, None], {\it show}= True, {\it drawSize}= -1, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create CartesianSpringDamper connector, using arguments from ObjectConnectorCartesianSpringDamper
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateCartesianSpringDamper.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for connector; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of two body numbers (ObjectIndex) to be connected
\item[]{\it localPosition0}: local position (as 3D list or numpy array) on body0, if not a node number
\item[]{\it localPosition1}: local position (as 3D list or numpy array) on body1, if not a node number
\item[]{\it stiffness}: stiffness coefficients (as 3D list or numpy array)
\item[]{\it damping}: damping coefficients (as 3D list or numpy array)
\item[]{\it offset}: offset vector (as 3D list or numpy array)
\item[]{\it springForceUserFunction}: a user function springForceUserFunction(mbs, t, itemNumber, displacement, velocity, stiffness, damping, offset)->[float,float,float] ; this function replaces the internal connector force computation
\item[]{\it bodyOrNodeList}: alternative to bodyNumbers; a list of object numbers (with specific localPosition0/1) or node numbers; may alse be mixed types; to use this case, set bodyNumbers = [None,None]
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it drawSize}: general drawing size of connector
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of newly created object
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateMassPoint(referencePosition = [7,0,0],
                            physicsMass = 1, gravity = [0,-9.81,0],
                            drawSize = 0.5, color=exu.graphics.color.blue)
  oGround = mbs.AddObject(ObjectGround())
  oSD = mbs.CreateCartesianSpringDamper(bodyNumbers=[oGround, b0],
                                localPosition0=[7.5,1,0],
                                localPosition1=[0,0,0],
                                stiffness=[200,2000,0], damping=[2,20,0],
                                drawSize=0.2)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  SC.visualizationSettings.nodes.drawNodesAsPoint=False
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateCartesianSpringDamper see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/cartesianSpringDamper.py}{\texttt{cartesianSpringDamper.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/cartesianSpringDamperUserFunction.py}{\texttt{cartesianSpringDamperUserFunction.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate.py}{\texttt{chatGPTupdate.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/complexEigenvaluesTest.py}{\texttt{complexEigenvaluesTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/computeODE2AEeigenvaluesTest.py}{\texttt{computeODE2AEeigenvaluesTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/mainSystemExtensionsTests.py}{\texttt{mainSystemExtensionsTests.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/mainSystemUserFunctionsTest.py}{\texttt{mainSystemUserFunctionsTest.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L812}{CreateRigidBodySpringDamper}{}}}\label{sec:mainsystemextensions:CreateRigidBodySpringDamper}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it localPosition0}= [0.,0.,0.], {\it localPosition1}= [0.,0.,0.], {\it stiffness}= np.zeros((6,6)), {\it damping}= np.zeros((6,6)), {\it offset}= [0.,0.,0.,0.,0.,0.], {\it rotationMatrixJoint}= np.eye(3), {\it useGlobalFrame}= True, {\it intrinsicFormulation}= True, {\it springForceTorqueUserFunction}= 0, {\it postNewtonStepUserFunction}= 0, {\it bodyOrNodeList}= [None, None], {\it bodyList}= [None, None], {\it show}= True, {\it drawSize}= -1, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create RigidBodySpringDamper connector, using arguments from ObjectConnectorRigidBodySpringDamper, see there for the full documentation
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateRigidBodySpringDamper.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for connector; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of two body numbers (ObjectIndex) to be connected
\item[]{\it localPosition0}: local position (as 3D list or numpy array) on body0, if not a node number
\item[]{\it localPosition1}: local position (as 3D list or numpy array) on body1, if not a node number
\item[]{\it stiffness}: stiffness coefficients (as 6D matrix or numpy array)
\item[]{\it damping}: damping coefficients (as 6D matrix or numpy array)
\item[]{\it offset}: offset vector (as 6D list or numpy array)
\item[]{\it rotationMatrixJoint}: additional rotation matrix; in case  useGlobalFrame=False, it transforms body0/node0 local frame to joint frame; if useGlobalFrame=True, it transforms global frame to joint frame
\item[]{\it useGlobalFrame}: if False, the rotationMatrixJoint is defined in the local coordinate system of body0
\item[]{\it intrinsicFormulation}: if True, uses intrinsic formulation of Maserati and Morandini, which uses matrix logarithm and is independent of order of markers (preferred formulation); otherwise, Tait-Bryan angles are used for computation of torque, see documentation
\item[]{\it springForceTorqueUserFunction}: a user function springForceTorqueUserFunction(mbs, t, itemNumber, displacement, rotation, velocity, angularVelocity, stiffness, damping, rotJ0, rotJ1, offset)->[float,float,float, float,float,float] ; this function replaces the internal connector force / torque computation
\item[]{\it postNewtonStepUserFunction}: a special user function postNewtonStepUserFunction(mbs, t, Index itemIndex, dataCoordinates, displacement, rotation, velocity, angularVelocity, stiffness, damping, rotJ0, rotJ1, offset)->[PNerror, recommendedStepSize, data[0], data[1], ...] ; for details, see RigidBodySpringDamper for full docu
\item[]{\it bodyOrNodeList}: alternative to bodyNumbers; a list of object numbers (with specific localPosition0/1) or node numbers; may alse be mixed types; to use this case, set bodyNumbers = [None,None]
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it drawSize}: general drawing size of connector
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of newly created object
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  #coming later
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateRigidBodySpringDamper see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/bricardMechanism.py}{\texttt{bricardMechanism.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/rigidBodySpringDamperIntrinsic.py}{\texttt{rigidBodySpringDamperIntrinsic.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L942}{CreateTorsionalSpringDamper}{}}}\label{sec:mainsystemextensions:CreateTorsionalSpringDamper}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it position}= [0.,0.,0.], {\it axis}= [0.,0.,0.], {\it stiffness}= 0., {\it damping}= 0., {\it offset}= 0., {\it velocityOffset}= 0., {\it torque}= 0., {\it useGlobalFrame}= True, {\it springTorqueUserFunction}= 0, {\it unlimitedRotations}= True, {\it show}= True, {\it drawSize}= -1, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create TorsionalSpringDamper connector, using arguments from ObjectConnectorTorsionalSpringDamper, see there for the full documentation
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateTorsionalSpringDamper.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for connector; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of two body numbers (ObjectIndex) to be connected
\item[]{\it position}: a 3D vector as list or np.array: if useGlobalFrame=True it describes the global position of the joint in reference configuration; else: local position in body0
\item[]{\it axis}: a 3D vector as list or np.array containing the axis around which the spring acts, either in local body0 coordinates (useGlobalFrame=False), or in global reference configuration (useGlobalFrame=True)
\item[]{\it stiffness}: scalar stiffness of spring
\item[]{\it damping}: scalar damping added to spring
\item[]{\it offset}: scalar offset, which can be used to realize a P-controlled actuator
\item[]{\it velocityOffset}: scalar velocity offset, which can be used to realize a D-controlled actuator
\item[]{\it torque}: additional constant torque added to spring-damper, acting between the two bodies
\item[]{\it useGlobalFrame}: if False, the position and axis vectors are defined in the local coordinate system of body0, otherwise in global (reference) coordinates
\item[]springTorqueUserFunction : a user function springTorqueUserFunction(mbs, t, itemNumber, rotation, angularVelocity, stiffness, damping, offset)->float ; this function replaces the internal connector torque computation
\item[]{\it unlimitedRotations}: if True, an additional generic data node is added to enable measurement of rotations beyond +/- pi; this also allows the spring to cope with multiple turns.
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it drawSize}: general drawing size of connector
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of newly created object
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  #coming later
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateTorsionalSpringDamper see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1100}{CreateRevoluteJoint}{}}}\label{sec:mainsystemextensions:CreateRevoluteJoint}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it position}= [], {\it axis}= [], {\it useGlobalFrame}= True, {\it show}= True, {\it axisRadius}= 0.1, {\it axisLength}= 0.4, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create revolute joint between two bodies; definition of joint position and axis in global coordinates (alternatively in body0 local coordinates) for reference configuration of bodies; all markers, markerRotation and other quantities are automatically computed
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateRevoluteJoint.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of object numbers for body0 and body1; must be rigid body or ground object
\item[]{\it position}: a 3D vector as list or np.array: if useGlobalFrame=True it describes the global position of the joint in reference configuration; else: local position in body0
\item[]{\it axis}: a 3D vector as list or np.array containing the joint axis either in local body0 coordinates (useGlobalFrame=False), or in global reference configuration (useGlobalFrame=True)
\item[]{\it useGlobalFrame}: if False, the position and axis vectors are defined in the local coordinate system of body0, otherwise in global (reference) coordinates
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it axisRadius}: radius of axis for connector graphical representation
\item[]{\it axisLength}: length of axis for connector graphical representation
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
                                                   sideLengths=[1,0.1,0.1]),
                           referencePosition = [3,0,0],
                           gravity = [0,-9.81,0],
                           graphicsDataList = [exu.graphics.Brick(size=[1,0.1,0.1],
                                                                        color=exu.graphics.color.steelblue)])
  oGround = mbs.AddObject(ObjectGround())
  mbs.CreateRevoluteJoint(bodyNumbers=[oGround, b0], position=[2.5,0,0], axis=[0,0,1],
                          useGlobalFrame=True, axisRadius=0.02, axisLength=0.14)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateRevoluteJoint see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/addRevoluteJoint.py}{\texttt{addRevoluteJoint.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/bicycleIftommBenchmark.py}{\texttt{bicycleIftommBenchmark.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate.py}{\texttt{chatGPTupdate.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate2.py}{\texttt{chatGPTupdate2.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/involuteGearGraphics.py}{\texttt{involuteGearGraphics.py}} (Ex), 
 ...
, 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/bricardMechanism.py}{\texttt{bricardMechanism.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createRollingDiscPenaltyTest.py}{\texttt{createRollingDiscPenaltyTest.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1201}{CreatePrismaticJoint}{}}}\label{sec:mainsystemextensions:CreatePrismaticJoint}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it position}= [], {\it axis}= [], {\it useGlobalFrame}= True, {\it show}= True, {\it axisRadius}= 0.1, {\it axisLength}= 0.4, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create prismatic joint between two bodies; definition of joint position and axis in global coordinates (alternatively in body0 local coordinates) for reference configuration of bodies; all markers, markerRotation and other quantities are automatically computed
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreatePrismaticJoint.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of object numbers for body0 and body1; must be rigid body or ground object
\item[]{\it position}: a 3D vector as list or np.array: if useGlobalFrame=True it describes the global position of the joint in reference configuration; else: local position in body0
\item[]{\it axis}: a 3D vector as list or np.array containing the joint axis either in local body0 coordinates (useGlobalFrame=False), or in global reference configuration (useGlobalFrame=True)
\item[]{\it useGlobalFrame}: if False, the position and axis vectors are defined in the local coordinate system of body0, otherwise in global (reference) coordinates
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it axisRadius}: radius of axis for connector graphical representation
\item[]{\it axisLength}: length of axis for connector graphical representation
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
                                                   sideLengths=[1,0.1,0.1]),
                           referencePosition = [4,0,0],
                           initialVelocity = [0,4,0],
                           gravity = [0,-9.81,0],
                           graphicsDataList = [exu.graphics.Brick(size=[1,0.1,0.1],
                                                                        color=exu.graphics.color.steelblue)])
  oGround = mbs.AddObject(ObjectGround())
  mbs.CreatePrismaticJoint(bodyNumbers=[oGround, b0], position=[3.5,0,0], axis=[0,1,0],
                           useGlobalFrame=True, axisRadius=0.02, axisLength=1)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreatePrismaticJoint see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/addPrismaticJoint.py}{\texttt{addPrismaticJoint.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate.py}{\texttt{chatGPTupdate.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate2.py}{\texttt{chatGPTupdate2.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/involuteGearGraphics.py}{\texttt{involuteGearGraphics.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/mainSystemExtensionsTests.py}{\texttt{mainSystemExtensionsTests.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/pickleCopyMbs.py}{\texttt{pickleCopyMbs.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/relativeRotationTranslationMechanism.py}{\texttt{relativeRotationTranslationMechanism.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1296}{CreateSphericalJoint}{}}}\label{sec:mainsystemextensions:CreateSphericalJoint}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it position}= [], {\it constrainedAxes}= [1,1,1], {\it useGlobalFrame}= True, {\it show}= True, {\it jointRadius}= 0.1, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create spherical joint between two bodies; definition of joint position in global coordinates (alternatively in body0 local coordinates) for reference configuration of bodies; all markers are automatically computed
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateSphericalJoint.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of object numbers for body0 and body1; must be mass point, rigid body or ground object
\item[]{\it position}: a 3D vector as list or np.array: if useGlobalFrame=True it describes the global position of the joint in reference configuration; else: local position in body0
\item[]{\it constrainedAxes}: flags, which determines which (global) translation axes are constrained; each entry may only be 0 (=free) axis or 1 (=constrained axis)
\item[]{\it useGlobalFrame}: if False, the point and axis vectors are defined in the local coordinate system of body0
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it jointRadius}: radius of sphere for connector graphical representation
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
                                                   sideLengths=[1,0.1,0.1]),
                           referencePosition = [5,0,0],
                           initialAngularVelocity = [5,0,0],
                           gravity = [0,-9.81,0],
                           graphicsDataList = [exu.graphics.Brick(size=[1,0.1,0.1],
                                                                        color=exu.graphics.color.orange)])
  oGround = mbs.AddObject(ObjectGround())
  mbs.CreateSphericalJoint(bodyNumbers=[oGround, b0], position=[5.5,0,0],
                           useGlobalFrame=True, jointRadius=0.06)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateSphericalJoint see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/newtonsCradle.py}{\texttt{newtonsCradle.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/driveTrainTest.py}{\texttt{driveTrainTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/mainSystemExtensionsTests.py}{\texttt{mainSystemExtensionsTests.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1386}{CreateGenericJoint}{}}}\label{sec:mainsystemextensions:CreateGenericJoint}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it position}= [], {\it rotationMatrixAxes}= np.eye(3), {\it constrainedAxes}= [1,1,1, 1,1,1], {\it useGlobalFrame}= True, {\it offsetUserFunction}= 0, {\it offsetUserFunction\_t}= 0, {\it show}= True, {\it axesRadius}= 0.1, {\it axesLength}= 0.4, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create generic joint between two bodies; definition of joint position (position) and axes (rotationMatrixAxes) in global coordinates (useGlobalFrame=True) or in local coordinates of body0 (useGlobalFrame=False), where rotationMatrixAxes is an additional rotation to body0; all markers, markerRotation and other quantities are automatically computed
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateGenericJoint.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumber0}: a object number for body0, must be rigid body or ground object
\item[]{\it bodyNumber1}: a object number for body1, must be rigid body or ground object
\item[]{\it position}: a 3D vector as list or np.array: if useGlobalFrame=True it describes the global position of the joint in reference configuration; else: local position in body0
\item[]{\it rotationMatrixAxes}: rotation matrix which defines orientation of constrainedAxes; if useGlobalFrame, this rotation matrix is global, else the rotation matrix is post-multiplied with the rotation of body0, identical with rotationMarker0 in the joint
\item[]{\it constrainedAxes}: flag, which determines which translation (0,1,2) and rotation (3,4,5) axes are constrained; each entry may only be 0 (=free) axis or 1 (=constrained axis); ALL constrained Axes are defined relative to reference rotation of body0 times rotation0
\item[]{\it useGlobalFrame}: if False, the position is defined in the local coordinate system of body0, otherwise it is defined in global coordinates
\item[]{\it offsetUserFunction}: a user function offsetUserFunction(mbs, t, itemNumber, offsetUserFunctionParameters)->float ; this function replaces the internal (constant) by a user-defined offset. This allows to realize rheonomic joints and allows kinematic simulation
\item[]{\it offsetUserFunction\_t}: a user function offsetUserFunction\_t(mbs, t, itemNumber, offsetUserFunctionParameters)->float ; this function replaces the internal (constant) by a user-defined offset velocity; this function is used instead of offsetUserFunction, if velocityLevel (index2) time integration
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it axesRadius}: radius of axes for connector graphical representation
\item[]{\it axesLength}: length of axes for connector graphical representation
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
                                                   sideLengths=[1,0.1,0.1]),
                           referencePosition = [6,0,0],
                           initialAngularVelocity = [0,8,0],
                           gravity = [0,-9.81,0],
                           graphicsDataList = [exu.graphics.Brick(size=[1,0.1,0.1],
                                                                        color=exu.graphics.color.orange)])
  oGround = mbs.AddObject(ObjectGround())
  mbs.CreateGenericJoint(bodyNumbers=[oGround, b0], position=[5.5,0,0],
                         constrainedAxes=[1,1,1, 1,0,0],
                         rotationMatrixAxes=RotationMatrixX(0.125*pi), #tilt axes
                         useGlobalFrame=True, axesRadius=0.02, axesLength=0.2)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateGenericJoint see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/bungeeJump.py}{\texttt{bungeeJump.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/pistonEngine.py}{\texttt{pistonEngine.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/universalJoint.py}{\texttt{universalJoint.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/bricardMechanism.py}{\texttt{bricardMechanism.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/complexEigenvaluesTest.py}{\texttt{complexEigenvaluesTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/computeODE2AEeigenvaluesTest.py}{\texttt{computeODE2AEeigenvaluesTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereQuadContact2.py}{\texttt{createSphereQuadContact2.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/driveTrainTest.py}{\texttt{driveTrainTest.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1500}{CreateDistanceConstraint}{}}}\label{sec:mainsystemextensions:CreateDistanceConstraint}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it localPosition0}= [0.,0.,0.], {\it localPosition1}= [0.,0.,0.], {\it distance}= None, {\it bodyOrNodeList}= [None, None], {\it bodyList}= [None, None], {\it show}= True, {\it drawSize}= -1., {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create distance joint between two bodies; definition of joint positions in local coordinates of bodies or nodes; if distance=None, it is computed automatically from reference length; all markers are automatically computed
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateDistanceConstraint.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of two body numbers (ObjectIndex) to be constrained
\item[]{\it localPosition0}: local position (as 3D list or numpy array) on body0, if not a node number
\item[]{\it localPosition1}: local position (as 3D list or numpy array) on body1, if not a node number
\item[]{\it distance}: if None, distance is computed from reference position of bodies or nodes; if not None, this distance is prescribed between the two positions; if distance = 0, it will create a SphericalJoint as this case is not possible with a DistanceConstraint
\item[]{\it bodyOrNodeList}: alternative to bodyNumbers; a list of object numbers (with specific localPosition0/1) or node numbers; may alse be mixed types; to use this case, set bodyNumbers = [None,None]
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it drawSize}: general drawing size of node
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
                                                    sideLengths=[1,0.1,0.1]),
                            referencePosition = [6,0,0],
                            gravity = [0,-9.81,0],
                            graphicsDataList = [exu.graphics.Brick(size=[1,0.1,0.1],
                                                                        color=exu.graphics.color.orange)])
  m1 = mbs.CreateMassPoint(referencePosition=[5.5,-1,0],
                           physicsMass=1, drawSize = 0.2)
  n1 = mbs.GetObject(m1)['nodeNumber']
  oGround = mbs.AddObject(ObjectGround())
  mbs.CreateDistanceConstraint(bodyNumbers=[oGround, b0],
                               localPosition0 = [6.5,1,0],
                               localPosition1 = [0.5,0,0],
                               distance=None, #automatically computed
                               drawSize=0.06)
  mbs.CreateDistanceConstraint(bodyOrNodeList=[b0, n1],
                               localPosition0 = [-0.5,0,0],
                               localPosition1 = [0.,0.,0.], #must be [0,0,0] for Node
                               distance=None, #automatically computed
                               drawSize=0.06)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateDistanceConstraint see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate.py}{\texttt{chatGPTupdate.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate2.py}{\texttt{chatGPTupdate2.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/newtonsCradle.py}{\texttt{newtonsCradle.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/deleteItemsTest.py}{\texttt{deleteItemsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/mainSystemExtensionsTests.py}{\texttt{mainSystemExtensionsTests.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/taskmanagerTest.py}{\texttt{taskmanagerTest.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1635}{CreateCoordinateConstraint}{}}}\label{sec:mainsystemextensions:CreateCoordinateConstraint}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it coordinates}= [None, None], {\it offset}= 0., {\it factorValue1}= 1., {\it velocityLevel}= False, {\it offsetUserFunction}= 0, {\it offsetUserFunction\_t}= 0, {\it show}= True, {\it drawSize}= -1., {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create coordinate constraint for two bodies, or body on ground; markers and NodePointGround are automatically created when needed
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateCoordinateConstraint.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of two body numbers (ObjectIndex) to be constrained
\item[]{\it coordinates}: a list of two coordinates for the respective bodies (in case of ground, it shall be None)
\item[]{\it offset}: an fixed offset between the two coordinate values
\item[]{\it factorValue1}: an additional factor multiplied with coordinate value1 used in algebraic equation, to enable (e.g. gear) ratio between coordinates
\item[]{\it velocityLevel}: If true: connector constrains velocities (only works for ODE2 coordinates!); offset is used between velocities; if True, the offsetUserFunction\_t is considered and offsetUserFunction is ignored
\item[]{\it offsetUserFunction}: a Python function which defines the time-dependent offset; see description in CoordinateConstraint
\item[]{\it offsetUserFunction\_t}: time derivative of offsetUserFunction; needed for velocity level constraints; see description in CoordinateConstraint
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it drawSize}: general drawing size of node
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
                                                    sideLengths=[1,0.1,0.1]),
                            referencePosition = [6,0,0],
                            gravity = [0,-9.81,0],
                            graphicsDataList = [exu.graphics.Brick(size=[1,0.1,0.1],
                                                                        color=exu.graphics.color.orange)])
  m1 = mbs.CreateMassPoint(referencePosition=[5.5,-1,0],
                           physicsMass=1, drawSize = 0.2)
  mbs.CreateCoordinateConstraint(bodyNumbers=[None, b0],
                                 coordinates=[None, 0]) #constraints X-coordinate
  #constrain Y-coordinate of b0 to Z-coordinate of m1:
  mbs.CreateCoordinateConstraint(bodyNumbers=[b0, m1],
                                 coordinates=[1, 2])
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateCoordinateConstraint see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/ballBearningModel.py}{\texttt{ballBearningModel.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/camFollowerExample.py}{\texttt{camFollowerExample.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/involuteGearGraphics.py}{\texttt{involuteGearGraphics.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/ballBearingTest.py}{\texttt{ballBearingTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/contactCurveExample.py}{\texttt{contactCurveExample.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1777}{CreateRollingDisc}{}}}\label{sec:mainsystemextensions:CreateRollingDisc}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it axisPosition}= [], {\it axisVector}= [1,0,0], {\it discRadius}= 0., {\it planePosition}= [0,0,0], {\it planeNormal}= [0,0,1], {\it constrainedAxes}= [1,1,1], {\it activeConnector}= True, {\it show}= True, {\it discWidth}= 0.1, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create an ideal rolling disc joint between wheel rigid body and ground; the disc is infinitely thin and the ground is a perfectly flat plane; the wheel may lift off; definition of joint position and axis in global coordinates (alternatively in wheel (body1) local coordinates) for reference configuration of bodies; all markers and other quantities are automatically computed; some constraint conditions may be deactivated, e.g. to resolve redundancy of constraints for multi-wheel vehicles
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateRollingDisc.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of object numbers for body0=ground and body1=wheel; must be rigid body or ground object
\item[]{\it axisPosition}: a 3D vector as list or np.array: position of wheel axis in local body1=wheel coordinates
\item[]{\it axisVector}: a 3D vector as list or np.array containing the joint (=wheel) axis in local body1=wheel coordinates
\item[]{\it discRadius}: radius of the disc
\item[]{\it planePosition}: any 3D position vector of plane in ground object; given as local coordinates in ground object
\item[]{\it planeNormal}: 3D normal vector of the rolling (contact) plane on ground; given as local coordinates in ground object
\item[]{\it constrainedAxes}: [j0,j1,j2] flags, which determine which constraints are active, in which j0 represents the constraint for lateral motion, j1 longitudinal (forward/backward) motion and j2 represents the normal (contact) direction
\item[]{\it activeConnector}: flag to activate or deactivate the joint
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it discWidth}: disc with, only used for drawing
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  r = 0.2
  oDisc = mbs.CreateRigidBody(inertia = InertiaCylinder(density=5000, length=0.1, outerRadius=r, axis=0),
                            referencePosition = [1,0,r],
                            initialAngularVelocity = [-3*2*pi,0,0],
                            initialVelocity = [0,r*3*2*pi,0],
                            gravity = [0,0,-9.81],
                            graphicsDataList = [exu.graphics.Cylinder(pAxis = [-0.05,0,0], vAxis = [0.1,0,0], radius = r*0.99,
                                                                      color=exu.graphics.color.blue),
                                                exu.graphics.Basis(length=2*r)])
  oGround = mbs.CreateGround(graphicsDataList=[exu.graphics.CheckerBoard(size=4)])
  mbs.CreateRollingDisc(bodyNumbers=[oGround, oDisc],
                        axisPosition=[0,0,0], axisVector=[1,0,0], #on local wheel frame
                        planePosition = [0,0,0], planeNormal = [0,0,1],  #in ground frame
                        discRadius = r,
                        discWidth=0.01, color=exu.graphics.color.steelblue)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings()
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateRollingDisc see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createRollingDiscTest.py}{\texttt{createRollingDiscTest.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1887}{CreateRollingDiscPenalty}{}}}\label{sec:mainsystemextensions:CreateRollingDiscPenalty}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it axisPosition}= [], {\it axisVector}= [1,0,0], {\it discRadius}= 0., {\it planePosition}= [0,0,0], {\it planeNormal}= [0,0,1], {\it contactStiffness}= 0., {\it contactDamping}= 0., {\it dryFriction}= [0,0], {\it dryFrictionAngle}= 0., {\it dryFrictionProportionalZone}= 0., {\it viscousFriction}= [0,0], {\it rollingFrictionViscous}= 0., {\it useLinearProportionalZone}= False, {\it activeConnector}= True, {\it show}= True, {\it discWidth}= 0.1, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create penalty-based rolling disc joint between wheel rigid body and ground; the disc is infinitely thin and the ground is a perfectly flat plane; the wheel may lift off; definition of joint position and axis in global coordinates (alternatively in wheel (body1) local coordinates) for reference configuration of bodies; all markers and other quantities are automatically computed
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateRollingDiscPenalty.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of object numbers for body0=ground and body1=wheel; must be rigid body or ground object
\item[]{\it axisPosition}: a 3D vector as list or np.array: position of wheel axis in local body1=wheel coordinates
\item[]{\it axisVector}: a 3D vector as list or np.array containing the joint (=wheel) axis in local body1=wheel coordinates
\item[]{\it discRadius}: radius of the disc
\item[]{\it planePosition}: any 3D position vector of plane in ground object; given as local coordinates in ground object
\item[]{\it planeNormal}: 3D normal vector of the rolling (contact) plane on ground; given as local coordinates in ground object
\item[]{\it dryFrictionAngle}: angle (radiant) which defines a rotation of the local tangential coordinates dry friction; this allows to model Mecanum wheels with specified roll angle
\item[]{\it contactStiffness}: normal contact stiffness
\item[]{\it contactDamping}: normal contact damping
\item[]{\it dryFriction}: 2D list of friction parameters; dry friction coefficients in local wheel coordinates, where for dryFrictionAngle=0, the first parameter refers to forward direction and the second parameter to lateral direction
\item[]{\it viscousFriction}: 2D list of viscous friction coefficients [SI:1/(m/s)] in local wheel coordinates; proportional to slipping velocity, leading to increasing slipping friction force for increasing slipping velocity; directions are same as in dryFriction
\item[]{\it dryFrictionProportionalZone}: limit velocity [m/s] up to which the friction is proportional to velocity (for regularization / avoid numerical oscillations)
\item[]{\it rollingFrictionViscous}: rolling friction [SI:1], which acts against the velocity of the trail on ground and leads to a force proportional to the contact normal force;
\item[]{\it useLinearProportionalZone}: if True, a linear proportional zone is used; the linear zone performs better in implicit time integration as the Jacobian has a constant tangent in the sticking case
\item[]{\it activeConnector}: flag to activate or deactivate the connector
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it discWidth}: disc with, only used for drawing
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  r = 0.2
  oDisc = mbs.CreateRigidBody(inertia = InertiaCylinder(density=5000, length=0.1, outerRadius=r, axis=0),
                            referencePosition = [1,0,r],
                            initialAngularVelocity = [-3*2*pi,0,0],
                            initialVelocity = [0,r*3*2*pi,0],
                            gravity = [0,0,-9.81],
                            graphicsDataList = [exu.graphics.Cylinder(pAxis = [-0.05,0,0], vAxis = [0.1,0,0], radius = r*0.99,
                                                                      color=exu.graphics.color.blue),
                                                exu.graphics.Basis(length=2*r)])
  oGround = mbs.CreateGround(graphicsDataList=[exu.graphics.CheckerBoard(size=4)])
  mbs.CreateRollingDiscPenalty(bodyNumbers=[oGround, oDisc], axisPosition=[0,0,0], axisVector=[1,0,0],
                                discRadius = r, planePosition = [0,0,0], planeNormal = [0,0,1],
                                dryFriction = [0.2,0.2],
                                contactStiffness = 1e5, contactDamping = 2e3,
                                discWidth=0.01, color=exu.graphics.color.steelblue)
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings()
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateRollingDiscPenalty see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createRollingDiscPenaltyTest.py}{\texttt{createRollingDiscPenaltyTest.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L1993}{CreateSphereSphereContact}{}}}\label{sec:mainsystemextensions:CreateSphereSphereContact}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it localPosition0}= [0.,0.,0.], {\it localPosition1}= [0.,0.,0.], {\it spheresRadii}= [-1,-1], {\it isHollowSphere1}= False, {\it dynamicFriction}= 0., {\it frictionProportionalZone}= 1e-3, {\it contactStiffness}= 0., {\it contactDamping}= 0., {\it contactStiffnessExponent}= 1, {\it constantPullOffForce}= 0, {\it contactPlasticityRatio}= 0, {\it adhesionCoefficient}= 0, {\it adhesionExponent}= 1, {\it restitutionCoefficient}= 1, {\it minimumImpactVelocity}= 0, {\it impactModel}= 0, {\it dataInitialCoordinates}= [0,0,0,0], {\it activeConnector}= True, {\it bodyOrNodeList}= [None, None], {\it show}= False, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create penalty-based sphere-sphere contact between two rigid bodies, mass points or according nodes; the contact is based on ObjectContactSphereSphere; note that this approach is only intended to be used for small number of contact objects, while GeneralContact shall be used for large scale systems
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateSphereSphereContact.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of object numbers for sphere0 and sphere1; Note that if body is a mass point, friction due to rolling is not accounted for!
\item[]{\it localPosition0}: local position (as 3D list or numpy array) of sphere0 on body0, if not a node number
\item[]{\it localPosition1}: local position (as 3D list or numpy array) of sphere1 on body1, if not a node number
\item[]{\it spheresRadii}: list containing radius of sphere 0 and radius of sphere 1 [SI:m].
\item[]{\it isHollowSphere1}: flag, which determines, if sphere attached to marker 1 (radius 1) is a hollow sphere.
\item[]{\it dynamicFriction}: dynamic friction coefficient for friction model, see StribeckFunction in exudyn.physics, Section Module: physics
\item[]{\it frictionProportionalZone}: limit velocity [m/s] up to which the friction is proportional to velocity (for regularization / avoid numerical oscillations), see StribeckFunction in exudyn.physics (named regVel there!), Section Module: physics
\item[]{\it contactStiffness}: normal contact stiffness
\item[]{\it contactDamping}: linear normal contact damping [SI:N/(m s)]; this damping should be used (!=0) if the restitution coefficient is < 1, as it changes its behavior.
\item[]{\it contactStiffnessExponent}: exponent in normal contact model [SI:1]
\item[]{\it constantPullOffForce}: constant adhesion force [SI:N]; Edinburgh Adhesive Elasto-Plastic Model
\item[]{\it contactPlasticityRatio}: ratio of contact stiffness for first loading and unloading/reloading [SI:1]; Edinburgh Adhesive Elasto-Plastic Model; see ObjectContactSphereSphere
\item[]{\it adhesionCoefficient}: coefficient for adhesion [SI:N/m]; Edinburgh Adhesive Elasto-Plastic Model; set to 0 to deactivate adhesion model
\item[]{\it adhesionExponent}: exponent for adhesion coefficient [SI:1]; Edinburgh Adhesive Elasto-Plastic Model
\item[]{\it restitutionCoefficient}: coefficient of restitution [SI:1]; used in particular for impact mechanics; different models available within parameter impactModel; the coefficient must be > 0, but can become arbitrarily small to emulate plastic impact (however very small values may lead to numerical problems)
\item[]{\it minimumImpactVelocity}: minimal impact velocity for coefficient of restitution [SI:1]; this value adds a lower bound for impact velocities for calculation of viscous impact force; it can be used to apply a larger damping behavior for low impact velocities (or permanent contact)
\item[]{\it impactModel}: number of impact model: 0) linear model (only linear damping is used); 1) Hunt-Crossley model; 2) Gonthier/EtAl-Carvalho/Martins mixed model; model 2 is much more accurate regarding the coefficient of restitution, in the full range [0,1] except for 0; NOTE: in all models, the linear contactDamping is added, if not set to zero!
\item[]{\it dataInitialCoordinates}: a list of four values for initialization of the data node, used for discontinuous iteration (friction and contact); data variables contain values from last PostNewton iteration: data[0] is the gap, data[1] is the norm of the tangential velocity (and thus contains information if it is stick or slip); data[2] is the impact velocity; data[3] is unused
\item[]{\it activeConnector}: flag to activate or deactivate the connector
\item[]{\it bodyOrNodeList}: alternative to bodyNumbers; a list of object numbers (with specific localPosition0/1) or node numbers; may alse be mixed types; to use this case, set bodyNumbers = [None,None]
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateSphereSphereContact see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereQuadContact.py}{\texttt{createSphereQuadContact.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereQuadContact2.py}{\texttt{createSphereQuadContact2.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereTriangleContact.py}{\texttt{createSphereTriangleContact.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L2128}{CreateSphereQuadContact}{}}}\label{sec:mainsystemextensions:CreateSphereQuadContact}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it localPosition0}= [0.,0.,0.], {\it radiusSphere}= 0, {\it quadPoints}= exudyn.Vector3DList([[0,0,0],[1,0,0],[1,1,0],[0,1,0]]), {\it includeEdges}= 15, {\it dynamicFriction}= 0., {\it frictionProportionalZone}= 1e-3, {\it contactStiffness}= 0., {\it contactDamping}= 0., {\it contactStiffnessExponent}= 1, {\it restitutionCoefficient}= 1, {\it minimumImpactVelocity}= 0, {\it impactModel}= 0, {\it dataInitialCoordinates}= [0,0,0,0], {\it activeConnector}= True, {\it bodyOrNodeList}= [None, None], {\it localPosition1}= [0.,0.,0.], {\it show}= False, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create penalty-based sphere-quad contact between two rigid bodies, mass points or according nodes; the contact is based on two ObjectContactSphereTriangle; note that this approach is only intended to be used for small number of contact objects, while GeneralContact shall be used for large scale systems
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateSphereQuadContact.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of object numbers for sphere (0) and quad (1); Note that if body is a mass point, friction due to rolling is not accounted for!
\item[]{\it localPosition0}: local position (as 3D list or numpy array) of sphere0 on body0, if not a node number
\item[]{\it radiusSphere}: radius of sphere 0 [SI:m].
\item[]{\it quadPoints}: 4 points as Vector3DList to define the quad, defined in body1 local coordinates; note that the quad is split into two triangles with point indices [0,1,3] and [1,2,3]
\item[]{\it includeEdges}: binary flag, where 1 defines contact with edges 0, 2 with edge 1, 4 with edge 2 and 8 with edge 3; 15 means that contact with all edges is included; edge 0 is the edge between node 0 and node 1, etc.
\item[]{\it dynamicFriction}: dynamic friction coefficient for friction model, see StribeckFunction in exudyn.physics, Section Module: physics
\item[]{\it frictionProportionalZone}: limit velocity [m/s] up to which the friction is proportional to velocity (for regularization / avoid numerical oscillations), see StribeckFunction in exudyn.physics (named regVel there!), Section Module: physics
\item[]{\it contactStiffness}: normal contact stiffness
\item[]{\it contactDamping}: linear normal contact damping [SI:N/(m s)]; this damping should be used (!=0) if the restitution coefficient is < 1, as it changes its behavior.
\item[]{\it contactStiffnessExponent}: exponent in normal contact model [SI:1]
\item[]{\it restitutionCoefficient}: coefficient of restitution [SI:1]; used in particular for impact mechanics; different models available within parameter impactModel; the coefficient must be > 0, but can become arbitrarily small to emulate plastic impact (however very small values may lead to numerical problems)
\item[]{\it minimumImpactVelocity}: minimal impact velocity for coefficient of restitution [SI:1]; this value adds a lower bound for impact velocities for calculation of viscous impact force; it can be used to apply a larger damping behavior for low impact velocities (or permanent contact)
\item[]{\it impactModel}: number of impact model: 0) linear model (only linear damping is used); 1) Hunt-Crossley model; 2) Gonthier/EtAl-Carvalho/Martins mixed model; model 2 is much more accurate regarding the coefficient of restitution, in the full range [0,1] except for 0; NOTE: in all models, the linear contactDamping is added, if not set to zero!
\item[]{\it dataInitialCoordinates}: a list of four values for initialization of the data node, used for discontinuous iteration (friction and contact); data variables contain values from last PostNewton iteration: data[0] is the gap, data[1] is the norm of the tangential velocity (and thus contains information if it is stick or slip); data[2] is the impact velocity; data[3] is unused
\item[]{\it activeConnector}: flag to activate or deactivate the connector
\item[]{\it bodyOrNodeList}: alternative to bodyNumbers; a list of object numbers (with specific localPosition0/1) or node numbers; may alse be mixed types; to use this case, set bodyNumbers = [None,None]
\item[]{\it localPosition1}: local position (as 3D list or numpy array) of quad1 on body1; this is usually not needed and adds simply an offset to the quad coordinates
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: dict containing oContact0 and oContact1 with ObjectIndex of each contact object
\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateSphereQuadContact see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereQuadContact.py}{\texttt{createSphereQuadContact.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereQuadContact2.py}{\texttt{createSphereQuadContact2.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereTriangleContact.py}{\texttt{createSphereTriangleContact.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L2261}{CreateSphereTriangleContact}{}}}\label{sec:mainsystemextensions:CreateSphereTriangleContact}
({\it name}= '', {\it bodyNumbers}= [None, None], {\it localPosition0}= [0.,0.,0.], {\it radiusSphere}= 0, {\it trianglePoints}= exudyn.Vector3DList([[0,0,0],[1,0,0],[0,1,0]]), {\it includeEdges}= 7, {\it dynamicFriction}= 0., {\it frictionProportionalZone}= 1e-3, {\it contactStiffness}= 0., {\it contactDamping}= 0., {\it contactStiffnessExponent}= 1, {\it restitutionCoefficient}= 1, {\it minimumImpactVelocity}= 0, {\it impactModel}= 0, {\it dataInitialCoordinates}= [0,0,0,0], {\it activeConnector}= True, {\it bodyOrNodeList}= [None, None], {\it localPosition1}= [0.,0.,0.], {\it show}= False, {\it color}= exudyn.graphics.color.default)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]Create penalty-based sphere-triangle contact between two rigid bodies, mass points or according nodes; the contact is based on ObjectContactSphereTriangle; note that this approach is only intended to be used for small number of contact objects, while GeneralContact shall be used for large scale systems
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateSphereTriangleContact.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for joint; markers get Marker0:name and Marker1:name
\item[]{\it bodyNumbers}: a list of object numbers for sphere (0) and triangle (1); Note that if body is a mass point, friction due to rolling is not accounted for!
\item[]{\it localPosition0}: local position (as 3D list or numpy array) of sphere0 on body0, if not a node number
\item[]{\it radiusSphere}: radius of sphere 0 [SI:m].
\item[]{\it trianglePoints}: triangle points as Vector3DList, defined in body1 local coordinates
\item[]{\it includeEdges}: binary flag, where 1 defines contact with edges 0, 2 with edge 1 and 4 with edge 2; 7 means that contact with all edges is included; edge 0 is the edge between node 0 and node 1, etc.
\item[]{\it dynamicFriction}: dynamic friction coefficient for friction model, see StribeckFunction in exudyn.physics, Section Module: physics
\item[]{\it frictionProportionalZone}: limit velocity [m/s] up to which the friction is proportional to velocity (for regularization / avoid numerical oscillations), see StribeckFunction in exudyn.physics (named regVel there!), Section Module: physics
\item[]{\it contactStiffness}: normal contact stiffness
\item[]{\it contactDamping}: linear normal contact damping [SI:N/(m s)]; this damping should be used (!=0) if the restitution coefficient is < 1, as it changes its behavior.
\item[]{\it contactStiffnessExponent}: exponent in normal contact model [SI:1]
\item[]{\it restitutionCoefficient}: coefficient of restitution [SI:1]; used in particular for impact mechanics; different models available within parameter impactModel; the coefficient must be > 0, but can become arbitrarily small to emulate plastic impact (however very small values may lead to numerical problems)
\item[]{\it minimumImpactVelocity}: minimal impact velocity for coefficient of restitution [SI:1]; this value adds a lower bound for impact velocities for calculation of viscous impact force; it can be used to apply a larger damping behavior for low impact velocities (or permanent contact)
\item[]{\it impactModel}: number of impact model: 0) linear model (only linear damping is used); 1) Hunt-Crossley model; 2) Gonthier/EtAl-Carvalho/Martins mixed model; model 2 is much more accurate regarding the coefficient of restitution, in the full range [0,1] except for 0; NOTE: in all models, the linear contactDamping is added, if not set to zero!
\item[]{\it dataInitialCoordinates}: a list of four values for initialization of the data node, used for discontinuous iteration (friction and contact); data variables contain values from last PostNewton iteration: data[0] is the gap, data[1] is the norm of the tangential velocity (and thus contains information if it is stick or slip); data[2] is the impact velocity; data[3] is unused
\item[]{\it activeConnector}: flag to activate or deactivate the connector
\item[]{\it bodyOrNodeList}: alternative to bodyNumbers; a list of object numbers (with specific localPosition0/1) or node numbers; may alse be mixed types; to use this case, set bodyNumbers = [None,None]
\item[]{\it localPosition1}: local position (as 3D list or numpy array) of triangle1 on body1; this is usually not needed and adds simply an offset to the triangle coordinates
\item[]{\it show}: if True, connector visualization is drawn
\item[]{\it color}: color of connector
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns index of created joint
\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateSphereTriangleContact see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereQuadContact.py}{\texttt{createSphereQuadContact.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createSphereTriangleContact.py}{\texttt{createSphereTriangleContact.py}} (TM)
\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L2389}{CreateKinematicTree}{}}}\label{sec:mainsystemextensions:CreateKinematicTree}
({\it name}= '', {\it listOfTreeLinks}= [], {\it referenceCoordinates}= None, {\it initialCoordinates}= None, {\it initialCoordinates\_t}= None, {\it gravity}= [0.,0.,0.], {\it baseOffset}= [0.,0.,0.], {\it linkForces}= None, {\it linkTorques}= None, {\it jointForceVector}= None, {\it jointPositionOffsetVector}= None, {\it jointVelocityOffsetVector}= None, {\it forceUserFunction}= 0, {\it jointRadius}= 0.05, {\it jointWidth}= 0.12, {\it colors}= exudyn.graphics.color.default, {\it colorsJoints}= exudyn.graphics.color.default, {\it baseGraphicsDataList}= None, {\it linkRoundness}= 0.2, {\it show}= True)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create 2D or 3D mass point object and node, using arguments as in NodePoint and MassPoint; uses TreeLink as defined in exudyn.rigidBodyUtilities
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateKinematicTree.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for object, node is 'Node:'+name
\item[]{\it listOfTreeLinks}: list of TreeLink (from exudyn.rigidBodyUtilities) which characterize the KinematicTree
\item[]{\it referenceCoordinates}: reference coordinates all kinematic tree coordinates (configuration when current coordinates are zero)
\item[]{\it initialCoordinates}: initial deviation from reference coordinates
\item[]{\it initialVelocities}: initial velocities for point node (always a 3D vector, no matter if 2D or 3D mass)
\item[]{\it gravity}: gravity vevtor applied to kinematic tree (always a 3D vector, no matter if 2D or 3D mass)
\item[]{\it baseOffset}: constant 3D vector representing the origin of the kinematic tree
\item[]{\it linkForces}: Vector3DList of forces per link (at joint origin) or None
\item[]{\it linkTorques}: Vector3DList of torques per link or None
\item[]{\it jointForceVector}: a list or numpy array of scalar forces per joint, representing joint forces (prismatic joint) or joint torques (revolute joint)
\item[]{\it jointPositionOffsetVector}: a list or numpy array of scalar set coordinates per joint; use PreStepUserFunction to change values over time
\item[]{\it jointVelocityOffsetVector}: a list or numpy array of scalar set velocities per joint; use PreStepUserFunction to change values over time
\item[]{\it forceUserFunction}: A Python user function which computes the generalized force vector on RHS with identical action as jointForceVector; for description see ObjectKinematicTree
\item[]{\it show}: show kinematic tree
\item[]{\it showLinks}: set true, if links shall be shown; if graphicsDataList is empty, a standard drawing for links is used (drawing a cylinder from previous joint or base to next joint; size relative to frame size in KinematicTree visualization settings); else graphicsDataList are used per link; NOTE visualization of joint and COM frames can be modified via visualizationSettings.bodies.kinematicTree
\item[]{\it showJoints}: set true, if joints shall be shown; if graphicsDataList is empty, a standard drawing for joints is used (drawing a cylinder for revolute joints; size relative to frame size in KinematicTree visualization settings)
\item[]{\it jointRadius}: for generic visualization of joints and links
\item[]{\it jointWidth}: for generic visualization of joints and links
\item[]{\it colors}: either one general color for kinematic tree, or list with one color per link
\item[]{\it colorsJoints}: either one color for all joints or list with one color per joint
\item[]{\it baseGraphicsDataList}: graphics for base; if None, it is computed automatically; otherwise a list of graphicsData or empty list
\item[]{\it linkRoundness}: for automatic generation of graphics for links, roundness=0 give brick-shape, roundness<1 give transition of brick to ellipsoid and roundness=1 give cylinders
\item[]{\it show}: show kinematic tree
\end{itemize}
\item[--]
{\bf output}: ObjectIndex; returns kinematic tree object index
\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateKinematicTree see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/humanRobotInteraction.py}{\texttt{humanRobotInteraction.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/kinematicTreeAndMBS.py}{\texttt{kinematicTreeAndMBS.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/kinematicTreePendulum.py}{\texttt{kinematicTreePendulum.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/openAIgymNLinkAdvanced.py}{\texttt{openAIgymNLinkAdvanced.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/openAIgymNLinkContinuous.py}{\texttt{openAIgymNLinkContinuous.py}} (Ex), 
 ...
, 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createKinematicTreeTest.py}{\texttt{createKinematicTreeTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/kinematicTreeAndMBStest.py}{\texttt{kinematicTreeAndMBStest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/kinematicTreeConstraintTest.py}{\texttt{kinematicTreeConstraintTest.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L2699}{CreateForce}{}}}\label{sec:mainsystemextensions:CreateForce}
({\it name}= '', {\it bodyNumber}= None, {\it loadVector}= [0.,0.,0.], {\it localPosition}= [0.,0.,0.], {\it bodyFixed}= False, {\it loadVectorUserFunction}= 0, {\it show}= True)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create force applied to given body
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateForce.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for object
\item[]{\it bodyNumber}: body number (ObjectIndex) at which the force is applied to
\item[]{\it loadVector}: force vector (as 3D list or numpy array)
\item[]{\it localPosition}: local position (as 3D list or numpy array) where force is applied
\item[]{\it bodyFixed}: if True, the force is corotated with the body; else, the force is global
\item[]{\it loadVectorUserFunction}: A Python function f(mbs, t, load)->loadVector which defines the time-dependent load and replaces loadVector in every time step; the arg load is the static loadVector
\item[]{\it show}: if True, load is drawn
\end{itemize}
\item[--]
{\bf output}: LoadIndex; returns load index
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0=mbs.CreateMassPoint(referencePosition = [0,0,0],
                         initialVelocity = [2,5,0],
                         physicsMass = 1, gravity = [0,-9.81,0],
                         drawSize = 0.5, color=exu.graphics.color.blue)
  f0=mbs.CreateForce(bodyNumber=b0, loadVector=[100,0,0],
                     localPosition=[0,0,0])
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateForce see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/ballBearningModel.py}{\texttt{ballBearningModel.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/cartesianSpringDamper.py}{\texttt{cartesianSpringDamper.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/cartesianSpringDamperUserFunction.py}{\texttt{cartesianSpringDamperUserFunction.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate.py}{\texttt{chatGPTupdate.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate2.py}{\texttt{chatGPTupdate2.py}} (Ex), 
 ...
, 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/ballBearingTest.py}{\texttt{ballBearingTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/loadUserFunctionTest.py}{\texttt{loadUserFunctionTest.py}} (TM), 
 ...

\ei

%
\begin{flushleft}
\noindent {def {\bf \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/exudyn/mainSystemExtensions.py\#L2777}{CreateTorque}{}}}\label{sec:mainsystemextensions:CreateTorque}
({\it name}= '', {\it bodyNumber}= None, {\it loadVector}= [0.,0.,0.], {\it localPosition}= [0.,0.,0.], {\it bodyFixed}= False, {\it loadVectorUserFunction}= 0, {\it show}= True)
\end{flushleft}
\setlength{\itemindent}{0.7cm}
\begin{itemize}[leftmargin=0.7cm]
\item[--]
{\bf function description}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]helper function to create torque applied to given body
\item[]- NOTE that this function is added to MainSystem via Python function MainSystemCreateTorque.
\end{itemize}
\item[--]
{\bf input}: \vspace{-6pt}
\begin{itemize}[leftmargin=1.2cm]
\setlength{\itemindent}{-0.7cm}
\item[]{\it name}: name string for object
\item[]{\it bodyNumber}: body number (ObjectIndex) at which the torque is applied to
\item[]{\it loadVector}: torque vector (as 3D list or numpy array)
\item[]{\it localPosition}: local position (as 3D list or numpy array) where torque is applied
\item[]{\it bodyFixed}: if True, the torque is corotated with the body; else, the torque is global
\item[]{\it loadVectorUserFunction}: A Python function f(mbs, t, load)->loadVector which defines the time-dependent load and replaces loadVector in every time step; the arg load is the static loadVector
\item[]{\it show}: if True, load is drawn
\end{itemize}
\item[--]
{\bf output}: LoadIndex; returns load index
\item[--]
{\bf example}: \vspace{-12pt}\ei\begin{lstlisting}[language=Python, xleftmargin=36pt]
  import exudyn as exu
  from exudyn.utilities import * #includes itemInterface and rigidBodyUtilities
  import numpy as np
  SC = exu.SystemContainer()
  mbs = SC.AddSystem()
  b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
                                                   sideLengths=[1,0.1,0.1]),
                           referencePosition = [1,3,0],
                           gravity = [0,-9.81,0],
                           graphicsDataList = [exu.graphics.Brick(size=[1,0.1,0.1],
                                                                        color=exu.graphics.color.red)])
  f0=mbs.CreateTorque(bodyNumber=b0, loadVector=[0,100,0])
  mbs.Assemble()
  simulationSettings = exu.SimulationSettings() #takes currently set values or default values
  simulationSettings.timeIntegration.numberOfSteps = 1000
  simulationSettings.timeIntegration.endTime = 2
  mbs.SolveDynamic(simulationSettings = simulationSettings)
\end{lstlisting}\vspace{-24pt}\bi\item[]\vspace{-24pt}\vspace{12pt}\end{itemize}
%

%
\noindent For examples on CreateTorque see Relevant Examples (Ex) and TestModels (TM) with weblink to github:
\bi
 \item \footnotesize \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/ballBearningModel.py}{\texttt{ballBearningModel.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate.py}{\texttt{chatGPTupdate.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/chatGPTupdate2.py}{\texttt{chatGPTupdate2.py}} (Ex), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/Examples/rigidBodyTutorial3.py}{\texttt{rigidBodyTutorial3.py}} (Ex), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/ballBearingTest.py}{\texttt{ballBearingTest.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/createFunctionsTest.py}{\texttt{createFunctionsTest.py}} (TM), 
\\ \exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/mainSystemExtensionsTests.py}{\texttt{mainSystemExtensionsTests.py}} (TM), 
\exuUrl{https://github.com/jgerstmayr/EXUDYN/blob/master/main/pythonDev/TestModels/pickleCopyMbs.py}{\texttt{pickleCopyMbs.py}} (TM), 
 ...

\ei

%