mainSystemExtensionsTests.py

You can view and download this file on Github: mainSystemExtensionsTests.py

  1#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2# This is an EXUDYN example
  3#
  4# Details:  Test models for mainSystemExtensions; tests for functions except PlotSensor or SolutionViewer,
  5#           which are tested already in other functions or cannot be tested with test suite;
  6#           all tests are self-contained and are included as examples for docu
  7#
  8# Author:   Johannes Gerstmayr
  9# Date:     2023-05-19
 10#
 11# Copyright:This file is part of Exudyn. Exudyn is free software. You can redistribute it and/or modify it under the terms of the Exudyn license. See 'LICENSE.txt' for more details.
 12#
 13#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 14
 15import exudyn as exu
 16from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
 17import numpy as np
 18
 19useGraphics = True #without test
 20#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 21#you can erase the following lines and all exudynTestGlobals related operations if this is not intended to be used as TestModel:
 22try: #only if called from test suite
 23    from modelUnitTests import exudynTestGlobals #for globally storing test results
 24    useGraphics = exudynTestGlobals.useGraphics
 25except:
 26    class ExudynTestGlobals:
 27        pass
 28    exudynTestGlobals = ExudynTestGlobals()
 29#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 30
 31testErrorTotal = 0
 32
 33#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
 34#create single mass point:
 35import exudyn as exu
 36from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
 37import numpy as np
 38SC = exu.SystemContainer()
 39mbs = SC.AddSystem()
 40
 41b0=mbs.CreateMassPoint(referencePosition = [0,0,0],
 42                       initialVelocity = [2,5,0],
 43                       physicsMass = 1, gravity = [0,-9.81,0],
 44                       drawSize = 0.5, color=color4blue)
 45
 46mbs.Assemble()
 47simulationSettings = exu.SimulationSettings() #takes currently set values or default values
 48simulationSettings.timeIntegration.numberOfSteps = 1000
 49simulationSettings.timeIntegration.endTime = 2
 50mbs.SolveDynamic(simulationSettings = simulationSettings)
 51
 52#mbs.SolutionViewer()
 53testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
 54exu.Print('solution of mainSystemExtensions test MP=',testError)
 55testErrorTotal += testError
 56
 57#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
 58#create single rigid body:
 59import exudyn as exu
 60from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
 61import numpy as np
 62SC = exu.SystemContainer()
 63mbs = SC.AddSystem()
 64
 65b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
 66                                                 sideLengths=[1,0.1,0.1]),
 67                         referencePosition = [1,0,0],
 68                         initialVelocity = [2,5,0],
 69                         initialAngularVelocity = [5,0.5,0.7],
 70                         gravity = [0,-9.81,0],
 71                         graphicsDataList = [GraphicsDataOrthoCubePoint(size=[1,0.1,0.1],
 72                                                                      color=color4red)])
 73
 74mbs.Assemble()
 75simulationSettings = exu.SimulationSettings() #takes currently set values or default values
 76simulationSettings.timeIntegration.numberOfSteps = 1000
 77simulationSettings.timeIntegration.endTime = 2
 78
 79mbs.SolveDynamic(simulationSettings = simulationSettings)
 80
 81testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
 82exu.Print('solution of mainSystemExtensions test RB=',testError)
 83testErrorTotal += testError
 84
 85#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
 86#create spring-damper:
 87import exudyn as exu
 88from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
 89import numpy as np
 90SC = exu.SystemContainer()
 91mbs = SC.AddSystem()
 92
 93b0 = mbs.CreateMassPoint(referencePosition = [2,0,0],
 94                         initialVelocity = [2,5,0],
 95                         physicsMass = 1, gravity = [0,-9.81,0],
 96                         drawSize = 0.5, color=color4blue)
 97
 98oGround = mbs.AddObject(ObjectGround())
 99#add vertical spring
100oSD = mbs.CreateSpringDamper(bodyList=[oGround, b0],
101                             localPosition0=[2,1,0],
102                             localPosition1=[0,0,0],
103                             stiffness=1e4, damping=1e2,
104                             drawSize=0.2)
105
106mbs.Assemble()
107simulationSettings = exu.SimulationSettings() #takes currently set values or default values
108simulationSettings.timeIntegration.numberOfSteps = 1000
109simulationSettings.timeIntegration.endTime = 2
110SC.visualizationSettings.nodes.drawNodesAsPoint=False
111mbs.SolveDynamic(simulationSettings = simulationSettings)
112
113#mbs.SolutionViewer()
114testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
115exu.Print('solution of mainSystemExtensions test SD=',testError)
116testErrorTotal += testError
117
118
119#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
120#create mass point with cartesian spring damper:
121import exudyn as exu
122from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
123import numpy as np
124SC = exu.SystemContainer()
125mbs = SC.AddSystem()
126
127b0 = mbs.CreateMassPoint(referencePosition = [7,0,0],
128                          physicsMass = 1, gravity = [0,-9.81,0],
129                          drawSize = 0.5, color=color4blue)
130
131oGround = mbs.AddObject(ObjectGround())
132
133oSD = mbs.CreateCartesianSpringDamper(bodyList=[oGround, b0],
134                              localPosition0=[7.5,1,0],
135                              localPosition1=[0,0,0],
136                              stiffness=[200,2000,0], damping=[2,20,0],
137                              drawSize=0.2)
138
139mbs.Assemble()
140simulationSettings = exu.SimulationSettings() #takes currently set values or default values
141simulationSettings.timeIntegration.numberOfSteps = 1000
142simulationSettings.timeIntegration.endTime = 2
143SC.visualizationSettings.nodes.drawNodesAsPoint=False
144
145mbs.SolveDynamic(simulationSettings = simulationSettings)
146
147# mbs.SolutionViewer()
148testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
149exu.Print('solution of mainSystemExtensions test CSD=',testError)
150testErrorTotal += testError
151
152#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
153#create rigid body with revolute joint:
154import exudyn as exu
155from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
156import numpy as np
157SC = exu.SystemContainer()
158mbs = SC.AddSystem()
159
160b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
161                                                 sideLengths=[1,0.1,0.1]),
162                         referencePosition = [3,0,0],
163                         gravity = [0,-9.81,0],
164                         graphicsDataList = [GraphicsDataOrthoCubePoint(size=[1,0.1,0.1],
165                                                                      color=color4steelblue)])
166oGround = mbs.AddObject(ObjectGround())
167mbs.CreateRevoluteJoint(bodyNumbers=[oGround, b0], position=[2.5,0,0], axis=[0,0,1],
168                        useGlobalFrame=True, axisRadius=0.02, axisLength=0.14)
169
170mbs.Assemble()
171simulationSettings = exu.SimulationSettings() #takes currently set values or default values
172simulationSettings.timeIntegration.numberOfSteps = 1000
173simulationSettings.timeIntegration.endTime = 2
174
175mbs.SolveDynamic(simulationSettings = simulationSettings)
176
177testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
178exu.Print('solution of mainSystemExtensions test RJ=',testError)
179testErrorTotal += testError
180
181#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
182#create rigid body with prismatic joint:
183import exudyn as exu
184from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
185import numpy as np
186SC = exu.SystemContainer()
187mbs = SC.AddSystem()
188
189b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
190                                                 sideLengths=[1,0.1,0.1]),
191                         referencePosition = [4,0,0],
192                         initialVelocity = [0,4,0],
193                         gravity = [0,-9.81,0],
194                         graphicsDataList = [GraphicsDataOrthoCubePoint(size=[1,0.1,0.1],
195                                                                      color=color4steelblue)])
196
197oGround = mbs.AddObject(ObjectGround())
198mbs.CreatePrismaticJoint(bodyNumbers=[oGround, b0], position=[3.5,0,0], axis=[0,1,0],
199                         useGlobalFrame=True, axisRadius=0.02, axisLength=1)
200
201mbs.Assemble()
202simulationSettings = exu.SimulationSettings() #takes currently set values or default values
203simulationSettings.timeIntegration.numberOfSteps = 1000
204simulationSettings.timeIntegration.endTime = 2
205
206mbs.SolveDynamic(simulationSettings = simulationSettings)
207
208testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
209exu.Print('solution of mainSystemExtensions test PJ=',testError)
210testErrorTotal += testError
211
212
213#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
214#create rigid body with spherical joint:
215import exudyn as exu
216from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
217import numpy as np
218SC = exu.SystemContainer()
219mbs = SC.AddSystem()
220
221b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
222                                                 sideLengths=[1,0.1,0.1]),
223                         referencePosition = [5,0,0],
224                         initialAngularVelocity = [5,0,0],
225                         gravity = [0,-9.81,0],
226                         graphicsDataList = [GraphicsDataOrthoCubePoint(size=[1,0.1,0.1],
227                                                                      color=color4orange)])
228oGround = mbs.AddObject(ObjectGround())
229mbs.CreateSphericalJoint(bodyNumbers=[oGround, b0], position=[5.5,0,0],
230                         useGlobalFrame=True, jointRadius=0.06)
231
232mbs.Assemble()
233simulationSettings = exu.SimulationSettings() #takes currently set values or default values
234simulationSettings.timeIntegration.numberOfSteps = 1000
235simulationSettings.timeIntegration.endTime = 2
236
237mbs.SolveDynamic(simulationSettings = simulationSettings)
238
239testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
240testErrorTotal += testError
241exu.Print('solution of mainSystemExtensions test SJ=',testError)
242
243#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
244#create rigid body with generic joint, universal joint case with axes tilted by 0.125*pi around X:
245import exudyn as exu
246from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
247import numpy as np
248SC = exu.SystemContainer()
249mbs = SC.AddSystem()
250
251b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
252                                                 sideLengths=[1,0.1,0.1]),
253                         referencePosition = [6,0,0],
254                         initialAngularVelocity = [0,8,0],
255                         gravity = [0,-9.81,0],
256                         graphicsDataList = [GraphicsDataOrthoCubePoint(size=[1,0.1,0.1],
257                                                                      color=color4orange)])
258oGround = mbs.AddObject(ObjectGround())
259mbs.CreateGenericJoint(bodyNumbers=[oGround, b0], position=[5.5,0,0],
260                       constrainedAxes=[1,1,1, 1,0,0],
261                       rotationMatrixAxes=RotationMatrixX(0.125*pi), #tilt axes
262                       useGlobalFrame=True, axesRadius=0.02, axesLength=0.2)
263
264#add global force:
265f0 = mbs.CreateForce(bodyNumber=b0, loadVector=[0.,20.,0.], localPosition=[0.5,0,0])
266
267#define user function for torque
268def UFtorque(mbs, t, load):
269    val = 1
270    if t < 1:
271        val = t*t
272    #print('load type=',type(load))
273    # return val*load
274    return val*np.array(load)
275
276#add torque applied in body coordinates:
277t0 = mbs.CreateTorque(bodyNumber=b0, loadVector=[0.,0.,10.], bodyFixed=True,
278                      loadVectorUserFunction=UFtorque)
279
280mbs.Assemble()
281simulationSettings = exu.SimulationSettings() #takes currently set values or default values
282simulationSettings.timeIntegration.numberOfSteps = 1000
283simulationSettings.timeIntegration.endTime = 2
284
285mbs.SolveDynamic(simulationSettings = simulationSettings)
286# mbs.SolutionViewer()
287
288testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
289testErrorTotal += testError
290exu.Print('solution of mainSystemExtensions test GJ=',testError)
291
292#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
293#create single mass point and compute linearized system and eigenvalues:
294import exudyn as exu
295from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
296import numpy as np
297SC = exu.SystemContainer()
298mbs = SC.AddSystem()
299
300b0 = mbs.CreateMassPoint(referencePosition = [2,0,0],
301                         initialVelocity = [2*0,5,0],
302                         physicsMass = 1, gravity = [0,-9.81,0],
303                         drawSize = 0.5, color=color4blue)
304
305oGround = mbs.AddObject(ObjectGround())
306#add vertical spring
307oSD = mbs.CreateSpringDamper(bodyList=[oGround, b0],
308                             localPosition0=[2,1,0],
309                             localPosition1=[0,0,0],
310                             stiffness=1e4, damping=1e2,
311                             drawSize=0.2)
312
313mbs.Assemble()
314[M,K,D] = mbs.ComputeLinearizedSystem()
315# exu.Print('M=\n',M,'\nK=\n',K,'\nD=\n',D) #check if K makes sense?
316
317[eigenvalues, eigenvectors] = mbs.ComputeODE2Eigenvalues()
318# exu.Print('eigenvalues=\n',eigenvalues)
319# exu.Print('eigenvectors=\n',eigenvectors)
320
321testError = 1e-3*np.linalg.norm(eigenvalues)
322exu.Print('solution of mainSystemExtensions test LinEig=',testError)
323testErrorTotal += testError
324
325#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
326#create rigid body with generic joint: compute system DOF
327import exudyn as exu
328from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
329import numpy as np
330SC = exu.SystemContainer()
331mbs = SC.AddSystem()
332
333b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
334                                                 sideLengths=[1,0.1,0.1]),
335                         referencePosition = [6,0,0],
336                         initialAngularVelocity = [0,8,0],
337                         gravity = [0,-9.81,0],
338                         graphicsDataList = [GraphicsDataOrthoCubePoint(size=[1,0.1,0.1],
339                                                                      color=color4orange)])
340oGround = mbs.AddObject(ObjectGround())
341mbs.CreateGenericJoint(bodyNumbers=[oGround, b0], position=[5.5,0,0],
342                       constrainedAxes=[1,1,1, 1,0,0],
343                       rotationMatrixAxes=RotationMatrixX(0.125*pi), #tilt axes
344                       useGlobalFrame=True, axesRadius=0.02, axesLength=0.2)
345
346mbs.Assemble()
347res = mbs.ComputeSystemDegreeOfFreedom(verbose=0)
348
349
350testDrawSystemGraph = False
351try:
352    #all imports are part of anaconda (e.g. anaconda 5.2.0, python 3.6.5)
353    import numpy as np
354    import networkx as nx #for generating graphs and graph arrangement
355    import matplotlib.pyplot as plt #for drawing
356    testDrawSystemGraph = True
357except:
358    exu.Print("numpy, networkx and matplotlib required for DrawSystemGraph(...); skipping test")
359
360if testDrawSystemGraph:
361    mbs.DrawSystemGraph(useItemTypes=True, tightLayout=False)
362    if not useGraphics:
363        import matplotlib.pyplot as plt
364        plt.close('all')
365
366testError = np.sum(list(res.values())[0:3])
367exu.Print('solution of mainSystemExtensions test DOF=',testError)
368testErrorTotal += testError
369
370
371#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
372#create rigid body and mass point with distance constraint
373import exudyn as exu
374from exudyn.utilities import * #includes itemInterface, graphicsDataUtilities and rigidBodyUtilities
375import numpy as np
376SC = exu.SystemContainer()
377mbs = SC.AddSystem()
378
379b0 = mbs.CreateRigidBody(inertia = InertiaCuboid(density=5000,
380                                                  sideLengths=[1,0.1,0.1]),
381                          referencePosition = [6,0,0],
382                          gravity = [0,-9.81,0],
383                          graphicsDataList = [GraphicsDataOrthoCubePoint(size=[1,0.1,0.1],
384                                                                      color=color4orange)])
385m1 = mbs.CreateMassPoint(referencePosition=[5.5,-1,0],
386                         physicsMass=1, drawSize = 0.2)
387n1 = mbs.GetObject(m1)['nodeNumber']
388
389oGround = mbs.AddObject(ObjectGround())
390mbs.CreateDistanceConstraint(bodyList=[oGround, b0],
391                             localPosition0 = [6.5,1,0],
392                             localPosition1 = [0.5,0,0],
393                             distance=None, #automatically computed
394                             drawSize=0.06)
395
396mbs.CreateDistanceConstraint(bodyOrNodeList=[b0, n1],
397                             localPosition0 = [-0.5,0,0],
398                             localPosition1 = [0.,0.,0.], #must be [0,0,0] for Node
399                             distance=None, #automatically computed
400                             drawSize=0.06)
401
402mbs.Assemble()
403simulationSettings = exu.SimulationSettings() #takes currently set values or default values
404simulationSettings.timeIntegration.numberOfSteps = 1000
405simulationSettings.timeIntegration.endTime = 2
406
407mbs.SolveDynamic(simulationSettings = simulationSettings)
408
409SC.visualizationSettings.nodes.drawNodesAsPoint=False
410#mbs.SolutionViewer()
411
412testError = np.linalg.norm(mbs.systemData.GetODE2Coordinates())
413testErrorTotal += testError
414exu.Print('solution of mainSystemExtensions test DC=',testError)
415
416#%%++++++++++++++++++++++++++++++++++++++++++++++++++++
417
418exu.Print('solution of mainSystemExtensions TOTAL=',testErrorTotal)
419exudynTestGlobals.testError = testErrorTotal - (57.64639446941554)   #up to 2023-11-19:57.96750245606998 (added force/torque) #2023-05-19: 51.699269012604674
420exudynTestGlobals.testResult = testErrorTotal