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