def TestExudyn(x): #create an environment for mini example SC = exu.SystemContainer() mbs = SC.AddSystem() oGround = mbs.AddObject(ObjectGround(referencePosition=[0, 0, 0])) nGround = mbs.AddNode(NodePointGround(referenceCoordinates=[0, 0, 0])) testError = 1 #set default error, if failed exu.Print("start mini example for class ObjectMass1D") node = mbs.AddNode( Node1D(referenceCoordinates=[0], initialCoordinates=[0.], initialVelocities=[1 * x])) mass = mbs.AddObject(Mass1D(nodeNumber=node, physicsMass=1)) #assemble and solve system for default parameters mbs.Assemble() #exu.SolveDynamic(mbs, exu.SimulationSettings()) h = 1e-6 tEnd = 10 simulationSettings = exu.SimulationSettings() simulationSettings.timeIntegration.numberOfSteps = int(tEnd / h) simulationSettings.timeIntegration.endTime = tEnd simulationSettings.solutionSettings.coordinatesSolutionFileName = "coordinatesSolution" + str( int(x)) + ".txt" simulationSettings.solutionSettings.writeSolutionToFile = True #no concurrent writing to files ...! #exu.StartRenderer() #don't do this in parallelization: will crash exu.SolveDynamic(mbs, simulationSettings) #exu.StopRenderer() #don't do this in parallelization: will crash #check result, get current mass position at local position [0,0,0] result = mbs.GetObjectOutputBody(mass, exu.OutputVariableType.Position, [0, 0, 0])[0] print("result ", x, "=", result) return result
# # 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. # #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++import sys import sys sys.path.append( '../TestModels' ) #for modelUnitTest as this example may be used also as a unit test import exudyn as exu from exudyn.itemInterface import * from exudyn.utilities import * from modelUnitTests import ExudynTestStructure, exudynTestGlobals SC = exu.SystemContainer() mbs = SC.AddSystem() ################################################################################################################################################################## def AddBodyWithSlidingJoints(mbs, xPositionOfFirstNodes=0, referencePositionOfBodyAlongCable=0, gravityFieldConstant=0): a = 0.8 * 2 #y-dim/2 of Body b = 0.02 #x-dim/2 of Body massRigid = 5000 #moving mass inertiaRigid = massRigid / 12 * (2 * a)**2 #rigid body which slides: graphicsRigid1 = GraphicsDataRectangle(-b, -a, b,
def ParameterFunction(parameterSet): SC = exu.SystemContainer() mbs = SC.AddSystem() #default values mass = 1.6 #mass in kg spring = 4000 #stiffness of spring-damper in N/m damper = 8 #damping constant in N/(m/s) u0=-0.08 #initial displacement v0=1 #initial velocity f =80 #force applied to mass #process parameters if 'mass' in parameterSet: mass = parameterSet['mass'] if 'spring' in parameterSet: spring = parameterSet['spring'] iCalc = 'Ref' #needed for parallel computation ==> output files are different for every computation if 'computationIndex' in parameterSet: iCalc = str(parameterSet['computationIndex']) #mass-spring-damper system L=0.5 #spring length (for drawing) x0=f/spring #static displacement # print('resonance frequency = '+str(np.sqrt(spring/mass))) # print('static displacement = '+str(x0)) #node for 3D mass point: n1=mbs.AddNode(Point(referenceCoordinates = [L,0,0], initialCoordinates = [u0,0,0], initialVelocities= [v0,0,0])) #ground node nGround=mbs.AddNode(NodePointGround(referenceCoordinates = [0,0,0])) #add mass point (this is a 3D object with 3 coordinates): massPoint = mbs.AddObject(MassPoint(physicsMass = mass, nodeNumber = n1)) #marker for ground (=fixed): groundMarker=mbs.AddMarker(MarkerNodeCoordinate(nodeNumber= nGround, coordinate = 0)) #marker for springDamper for first (x-)coordinate: nodeMarker =mbs.AddMarker(MarkerNodeCoordinate(nodeNumber= n1, coordinate = 0)) #spring-damper between two marker coordinates nC = mbs.AddObject(CoordinateSpringDamper(markerNumbers = [groundMarker, nodeMarker], stiffness = spring, damping = damper)) #add load: mbs.AddLoad(LoadCoordinate(markerNumber = nodeMarker, load = f)) #add sensor: fileName = 'solution/paramVarDisplacement'+iCalc+'.txt' mbs.AddSensor(SensorObject(objectNumber=nC, fileName=fileName, outputVariableType=exu.OutputVariableType.Force)) #print(mbs) mbs.Assemble() steps = 1000 #number of steps to show solution tEnd = 1 #end time of simulation simulationSettings = exu.SimulationSettings() #simulationSettings.solutionSettings.solutionWritePeriod = 5e-3 #output interval general simulationSettings.solutionSettings.writeSolutionToFile = False simulationSettings.solutionSettings.sensorsWritePeriod = 5e-3 #output interval of sensors simulationSettings.timeIntegration.numberOfSteps = steps simulationSettings.timeIntegration.endTime = tEnd simulationSettings.timeIntegration.generalizedAlpha.spectralRadius = 1 #no damping #exu.StartRenderer() #start graphics visualization #mbs.WaitForUserToContinue() #wait for pressing SPACE bar to continue #start solver: exu.SolveDynamic(mbs, simulationSettings) #SC.WaitForRenderEngineStopFlag()#wait for pressing 'Q' to quit #exu.StopRenderer() #safely close rendering window! # #evaluate final (=current) output values # u = mbs.GetNodeOutput(n1, exu.OutputVariableType.Position) # print('displacement=',u) #+++++++++++++++++++++++++++++++++++++++++++++++++++++ #evaluate difference between reference and optimized solution #reference solution: dataRef = np.loadtxt('solution/paramVarDisplacementRef.txt', comments='#', delimiter=',') data = np.loadtxt(fileName, comments='#', delimiter=',') diff = data[:,1]-dataRef[:,1] errorNorm = np.sqrt(np.dot(diff,diff))/steps*tEnd #+++++++++++++++++++++++++++++++++++++++++++++++++++++ #compute exact solution: if False: from matplotlib import plt plt.close('all') plt.plot(data[:,0], data[:,1], 'b-', label='displacement (m)') ax=plt.gca() # get current axes ax.grid(True, 'major', 'both') ax.xaxis.set_major_locator(ticker.MaxNLocator(10)) ax.yaxis.set_major_locator(ticker.MaxNLocator(10)) plt.legend() #show labels as legend plt.tight_layout() plt.show() import os if iCalc != 'Ref': os.remove(fileName) #remove files in order to clean up del mbs del SC return errorNorm
def ParameterFunction(parameterSet): SC = exu.SystemContainer() mbs = SC.AddSystem() #default values mass = 1.6 #mass in kg spring = 4000 #stiffness of spring-damper in N/m damper = 8 #old: 8; damping constant in N/(m/s) u0 = -0.08 #initial displacement v0 = 1 #initial velocity force = 80 #force applied to mass #process parameters if 'mass' in parameterSet: mass = parameterSet['mass'] if 'spring' in parameterSet: spring = parameterSet['spring'] if 'force' in parameterSet: force = parameterSet['force'] iCalc = 'Ref' #needed for parallel computation ==> output files are different for every computation if 'computationIndex' in parameterSet: iCalc = str(parameterSet['computationIndex']) #print("computation index=",iCalc, flush=True) L = 0.5 #spring length (for drawing) n1 = mbs.AddNode( Point(referenceCoordinates=[L, 0, 0], initialCoordinates=[u0, 0, 0], initialVelocities=[v0, 0, 0])) #ground node nGround = mbs.AddNode(NodePointGround(referenceCoordinates=[0, 0, 0])) #add mass point (this is a 3D object with 3 coordinates): massPoint = mbs.AddObject(MassPoint(physicsMass=mass, nodeNumber=n1)) #marker for ground (=fixed): groundMarker = mbs.AddMarker( MarkerNodeCoordinate(nodeNumber=nGround, coordinate=0)) #marker for springDamper for first (x-)coordinate: nodeMarker = mbs.AddMarker( MarkerNodeCoordinate(nodeNumber=n1, coordinate=0)) #spring-damper between two marker coordinates nC = mbs.AddObject( CoordinateSpringDamper(markerNumbers=[groundMarker, nodeMarker], stiffness=spring, damping=damper)) #add load: mbs.AddLoad(LoadCoordinate(markerNumber=nodeMarker, load=force)) #add sensor: sensorFileName = 'solution/paramVarDisplacement' + iCalc + '.txt' mbs.AddSensor( SensorObject(objectNumber=nC, fileName=sensorFileName, outputVariableType=exu.OutputVariableType.Displacement)) #print("sensorFileName",sensorFileName) #print(mbs) mbs.Assemble() steps = 100 #number of steps to show solution tEnd = 1 #end time of simulation simulationSettings = exu.SimulationSettings() #simulationSettings.solutionSettings.solutionWritePeriod = 5e-3 #output interval general simulationSettings.solutionSettings.writeSolutionToFile = False simulationSettings.solutionSettings.sensorsWritePeriod = 2e-3 #output interval of sensors simulationSettings.timeIntegration.numberOfSteps = steps simulationSettings.timeIntegration.endTime = tEnd simulationSettings.timeIntegration.generalizedAlpha.spectralRadius = 1 #no damping exu.SolveDynamic(mbs, simulationSettings) #+++++++++++++++++++++++++++++++++++++++++++++++++++++ #evaluate difference between reference and optimized solution #reference solution: dataRef = np.loadtxt('solution/paramVarDisplacementRef.txt', comments='#', delimiter=',') data = np.loadtxt(sensorFileName, comments='#', delimiter=',') diff = data[:, 1] - dataRef[:, 1] errorNorm = np.sqrt(np.dot(diff, diff)) / steps * tEnd if True: #delete files; does not work for parallel, consecutive operation if iCalc != 'Ref': os.remove(sensorFileName) #remove files in order to clean up while (os.path.exists(sensorFileName) ): #wait until file is really deleted -> usually some delay sleep(0.001) #not nice, but there is no other way than that del mbs del SC return errorNorm
import exudyn as exu #EXUDYN package including C++ core part from exudyn.itemInterface import * #conversion of data to exudyn dictionaries SC = exu.SystemContainer() #container of systems mbs = SC.AddSystem() #add a new system to work with nMP = mbs.AddNode(NodePoint2D(referenceCoordinates=[0, 0])) mbs.AddObject(ObjectMassPoint2D(physicsMass=10, nodeNumber=nMP)) mMP = mbs.AddMarker(MarkerNodePosition(nodeNumber=nMP)) mbs.AddLoad(Force(markerNumber=mMP, loadVector=[0.001, 0, 0])) mbs.Assemble() #assemble system and solve simulationSettings = exu.SimulationSettings() simulationSettings.timeIntegration.verboseMode = 1 #provide some output SC.TimeIntegrationSolve(mbs, 'GeneralizedAlpha', simulationSettings)
def ParameterFunction(parameterSet): SC = exu.SystemContainer() mbs = SC.AddSystem() #default values mass = 1.6 #mass in kg spring = 4000 #stiffness of spring-damper in N/m damper = 8 #old: 8; damping constant in N/(m/s) u0 = -0.08 #initial displacement v0 = 1 #initial velocity force = 80 #force applied to mass #process parameters if 'mass' in parameterSet: mass = parameterSet['mass'] if 'spring' in parameterSet: spring = parameterSet['spring'] if 'force' in parameterSet: force = parameterSet['force'] iCalc = 'Ref' #needed for parallel computation ==> output files are different for every computation if 'computationIndex' in parameterSet: iCalc = str(parameterSet['computationIndex']) #print("computation index=",iCalc, flush=True) # else: # print("***********************\nfailed: computationIndex\n***********************\n") #mass-spring-damper system L = 0.5 #spring length (for drawing) # x0=force/spring #static displacement # print('resonance frequency = '+str(np.sqrt(spring/mass))) # print('static displacement = '+str(x0)) #node for 3D mass point: n1 = mbs.AddNode( Point(referenceCoordinates=[L, 0, 0], initialCoordinates=[u0, 0, 0], initialVelocities=[v0, 0, 0])) #ground node nGround = mbs.AddNode(NodePointGround(referenceCoordinates=[0, 0, 0])) #add mass point (this is a 3D object with 3 coordinates): massPoint = mbs.AddObject(MassPoint(physicsMass=mass, nodeNumber=n1)) #marker for ground (=fixed): groundMarker = mbs.AddMarker( MarkerNodeCoordinate(nodeNumber=nGround, coordinate=0)) #marker for springDamper for first (x-)coordinate: nodeMarker = mbs.AddMarker( MarkerNodeCoordinate(nodeNumber=n1, coordinate=0)) #spring-damper between two marker coordinates nC = mbs.AddObject( CoordinateSpringDamper(markerNumbers=[groundMarker, nodeMarker], stiffness=spring, damping=damper)) #add load: mbs.AddLoad(LoadCoordinate(markerNumber=nodeMarker, load=force)) #add sensor: sensorFileName = 'solution/paramVarDisplacement' + iCalc + '.txt' mbs.AddSensor( SensorObject(objectNumber=nC, fileName=sensorFileName, outputVariableType=exu.OutputVariableType.Displacement)) #print("sensorFileName",sensorFileName) #print(mbs) mbs.Assemble() steps = 1000 #number of steps to show solution tEnd = 1 #end time of simulation simulationSettings = exu.SimulationSettings() #simulationSettings.solutionSettings.solutionWritePeriod = 5e-3 #output interval general simulationSettings.solutionSettings.writeSolutionToFile = False simulationSettings.solutionSettings.sensorsWritePeriod = 2e-3 #output interval of sensors simulationSettings.timeIntegration.numberOfSteps = steps simulationSettings.timeIntegration.endTime = tEnd simulationSettings.timeIntegration.generalizedAlpha.spectralRadius = 1 #no damping #exu.StartRenderer() #start graphics visualization #mbs.WaitForUserToContinue() #wait for pressing SPACE bar to continue #start solver: exu.SolveDynamic(mbs, simulationSettings) #SC.WaitForRenderEngineStopFlag()#wait for pressing 'Q' to quit #exu.StopRenderer() #safely close rendering window! # #evaluate final (=current) output values # u = mbs.GetNodeOutput(n1, exu.OutputVariableType.Position) # print('displacement=',u) #+++++++++++++++++++++++++++++++++++++++++++++++++++++ #evaluate difference between reference and optimized solution #reference solution: dataRef = np.loadtxt('solution/paramVarDisplacementRef.txt', comments='#', delimiter=',') data = np.loadtxt(sensorFileName, comments='#', delimiter=',') # s = 50 #shift, for testing what happens if signal has phase-shift # dataRef[0:-s] = dataRef[s:] if not useFFTfitness: diff = data[:, 1] - dataRef[:, 1] errorNorm = np.sqrt(np.dot(diff, diff)) / steps * tEnd #+++++++++++++++++++++++++++++++++++++++++++++++++++++ #draw solution (not during optimization!): if False: import matplotlib.pyplot as plt from matplotlib import ticker #plt.close('all') plt.plot(data[:, 0], data[:, 1], 'b-', label='displacement (m)') ax = plt.gca() # get current axes ax.grid(True, 'major', 'both') ax.xaxis.set_major_locator(ticker.MaxNLocator(10)) ax.yaxis.set_major_locator(ticker.MaxNLocator(10)) plt.legend() #show labels as legend plt.tight_layout() plt.show() else: from exudyn.signal import ComputeFFT tvec = data[:, 0] uvec = data[:, 1] tvecRef = dataRef[:, 0] uvecRef = dataRef[:, 1] [freq, mag, phase] = ComputeFFT(tvec, uvec) [freqRef, magRef, phaseRef] = ComputeFFT(tvecRef, uvecRef) diff = mag - magRef #diff = np.log(abs(mag)) - np.log(abs(magRef)) #does not improve convergence nMag = len(mag) fRange = freq[-1] - freq[ 0] #use frequency range for better reference value # avrgLength = 51 # def runningMeanFast(x, N): # return np.convolve(x, np.ones((N,))/N)[(N-1):] # mag = runningMeanFast(mag, avrgLength) # magRef = runningMeanFast(magRef, avrgLength) errorNorm = np.sqrt(np.dot(diff, diff)) / nMag * fRange # sumV = 0 # p = 2 #higher coefficient has no effect # for v in diff: # sumV += v**p # errorNorm = (sumV**(1/p))/nMag*fRange #higher weight to peaks # #convolution does not work well: # sumV = 0 # for i in range(20,len(mag)-5): # #sumV += -mag[i]*magRef[i] # sumV += -np.log(abs(mag[i])) * np.log(abs(magRef[i])) # errorNorm = sumV/nMag*fRange #higher weight to peaks #+++++++++++++++++++++++++++++++++++++++++++++++++++++ #draw solution (not during optimization!): if False: from exudyn.plot import PlotFFT PlotFFT(freq, mag, label='freq') #, logScaleY=False) PlotFFT(freqRef, magRef, label='freqRef') #, logScaleY=False) if True: #delete files; does not work for parallel, consecutive operation if iCalc != 'Ref': os.remove(sensorFileName) #remove files in order to clean up while (os.path.exists(sensorFileName) ): #wait until file is really deleted -> usually some delay sleep(0.001) #not nice, but there is no other way than that del mbs del SC return errorNorm
def ParameterFunction(parameterSet): s1=L1*0.5 s2=L2*0.5 if False: s1 = s1opt s2 = s2opt if 's1' in parameterSet: s1 = parameterSet['s1'] h=0.002 if 'h' in parameterSet: h = parameterSet['h'] if 's2' in parameterSet: s2 = parameterSet['s2'] iCalc = 'Ref' #needed for parallel computation ==> output files are different for every computation if 'computationIndex' in parameterSet: iCalc = str(parameterSet['computationIndex']) #print("computation index=",iCalc, flush=True) SC = exu.SystemContainer() mbs = SC.AddSystem() testCases = 1 #floating body nGround = mbs.AddNode(NodePointGround(referenceCoordinates=[0,0,0])) #ground node for coordinate constraint mGround = mbs.AddMarker(MarkerNodeCoordinate(nodeNumber = nGround, coordinate=0)) #Ground node ==> no action #++++++++++++++++++++++++++++++++ #floating body to mount slider-crank mechanism constrainGroundBody = (testCases == 0) #use this flag to fix ground body #graphics for floating frame: gFloating = GraphicsDataOrthoCube(-0.25, -0.25, -0.1, 0.8, 0.25, -0.05, color=[0.3,0.3,0.3,1.]) if constrainGroundBody: floatingRB = mbs.AddObject(ObjectGround(referencePosition=[0,0,0], visualization=VObjectGround(graphicsData=[gFloating]))) mFloatingN = mbs.AddMarker(MarkerBodyPosition(bodyNumber = floatingRB, localPosition=[0,0,0])) else: nFloating = mbs.AddNode(Rigid2D(referenceCoordinates=[0,0,0], initialVelocities=[0,0,0])); mFloatingN = mbs.AddMarker(MarkerNodePosition(nodeNumber=nFloating)) floatingRB = mbs.AddObject(RigidBody2D(physicsMass=2, physicsInertia=1, nodeNumber=nFloating, visualization=VObjectRigidBody2D(graphicsData=[gFloating]))) mRB0 = mbs.AddMarker(MarkerNodeCoordinate(nodeNumber = nFloating, coordinate=0)) mRB1 = mbs.AddMarker(MarkerNodeCoordinate(nodeNumber = nFloating, coordinate=1)) mRB2 = mbs.AddMarker(MarkerNodeCoordinate(nodeNumber = nFloating, coordinate=2)) #add spring dampers for reference frame: k=5000 #stiffness of floating body d=k*0.01 mbs.AddObject(CoordinateSpringDamper(markerNumbers=[mGround,mRB0], stiffness=k, damping=d)) mbs.AddObject(CoordinateSpringDamper(markerNumbers=[mGround,mRB1], stiffness=k, damping=d)) mbs.AddObject(CoordinateSpringDamper(markerNumbers=[mGround,mRB2], stiffness=k, damping=d)) mbs.AddObject(CoordinateConstraint(markerNumbers=[mGround,mRB2])) #++++++++++++++++++++++++++++++++ #nodes and bodies omega=2*pi/60*300 #3000 rpm M=0.1 #torque (default: 0.1) s1L=-s1 s1R=L1-s1 s2L=-s2 s2R=L2-s2 #lambda=L1/L2 J1=(m1/12.)*L1**2 #inertia w.r.t. center of mass J2=(m2/12.)*L2**2 #inertia w.r.t. center of mass ty = 0.05 #thickness tz = 0.05 #thickness graphics1 = GraphicsDataRigidLink(p0=[s1L,0,-0.5*tz],p1=[s1R,0,-0.5*tz], axis0=[0,0,1], axis1=[0,0,1],radius=[0.5*ty,0.5*ty], thickness=0.8*ty, width=[tz,tz], color=color4steelblue,nTiles=16) graphics2 = GraphicsDataRigidLink(p0=[s2L,0,0.5*tz],p1=[s2R,0,0.5*tz], axis0=[0,0,1], axis1=[0,0,1],radius=[0.5*ty,0.5*ty], thickness=0.8*ty, width=[tz,tz], color=color4lightred,nTiles=16) #crank: nRigid1 = mbs.AddNode(Rigid2D(referenceCoordinates=[s1,0,0], initialVelocities=[0,0,0])); oRigid1 = mbs.AddObject(RigidBody2D(physicsMass=m1, physicsInertia=J1, nodeNumber=nRigid1, visualization=VObjectRigidBody2D(graphicsData= [graphics1]))) #connecting rod: nRigid2 = mbs.AddNode(Rigid2D(referenceCoordinates=[L1+s2,0,0], initialVelocities=[0,0,0])); oRigid2 = mbs.AddObject(RigidBody2D(physicsMass=m2, physicsInertia=J2, nodeNumber=nRigid2, visualization=VObjectRigidBody2D(graphicsData= [graphics2]))) #++++++++++++++++++++++++++++++++ #slider: c=0.025 #dimension of mass graphics3 = GraphicsDataOrthoCube(-c,-c,-c*2,c,c,0,color4grey) #nMass = mbs.AddNode(Point2D(referenceCoordinates=[L1+L2,0])) #oMass = mbs.AddObject(MassPoint2D(physicsMass=m3, nodeNumber=nMass,visualization=VObjectMassPoint2D(graphicsData= [graphics3]))) nMass = mbs.AddNode(Rigid2D(referenceCoordinates=[L1+L2,0,0])) oMass = mbs.AddObject(RigidBody2D(physicsMass=m3, physicsInertia=0.001*m3, nodeNumber=nMass,visualization=VObjectRigidBody2D(graphicsData= [graphics3]))) #++++++++++++++++++++++++++++++++ #markers for joints: mR1Left = mbs.AddMarker(MarkerBodyRigid(bodyNumber=oRigid1, localPosition= [s1L,0.,0.])) #support point # MUST be a rigidBodyMarker, because a torque is applied mR1Right = mbs.AddMarker(MarkerBodyPosition(bodyNumber=oRigid1, localPosition=[s1R,0.,0.])) #end point; connection to connecting rod mR2Left = mbs.AddMarker(MarkerBodyPosition(bodyNumber=oRigid2, localPosition= [s2L,0.,0.])) #connection to crank mR2Right = mbs.AddMarker(MarkerBodyPosition(bodyNumber=oRigid2, localPosition=[s2R,0.,0.])) #end point; connection to slider mMass = mbs.AddMarker(MarkerBodyPosition(bodyNumber=oMass, localPosition=[ 0.,0.,0.])) mG0 = mFloatingN #++++++++++++++++++++++++++++++++ #joints: mbs.AddObject(RevoluteJoint2D(markerNumbers=[mG0,mR1Left])) mbs.AddObject(RevoluteJoint2D(markerNumbers=[mR1Right,mR2Left])) mbs.AddObject(RevoluteJoint2D(markerNumbers=[mR2Right,mMass])) #prismatic joint: mRigidGround = mbs.AddMarker(MarkerBodyRigid(bodyNumber = floatingRB, localPosition = [L1+L2,0,0])) mRigidSlider = mbs.AddMarker(MarkerBodyRigid(bodyNumber = oMass, localPosition = [0,0,0])) mbs.AddObject(PrismaticJoint2D(markerNumbers=[mRigidGround,mRigidSlider], constrainRotation=True)) #user function for load; switch off load after 1 second userLoadOn = True def userLoad(mbs, t, load): setLoad = 0 if userLoadOn: setLoad = load omega = mbs.GetNodeOutput(nRigid1,variableType = exu.OutputVariableType.AngularVelocity)[2] if omega > 2*pi*2: #print("t=",t) userLoadOn = False return setLoad #loads and driving forces: mRigid1CoordinateTheta = mbs.AddMarker(MarkerNodeCoordinate(nodeNumber = nRigid1, coordinate=2)) #angle coordinate is constrained #mbs.AddLoad(LoadCoordinate(markerNumber=mRigid1CoordinateTheta, load = M, loadUserFunction=userLoad)) #torque at crank mbs.AddLoad(LoadCoordinate(markerNumber=mRigid1CoordinateTheta, load = M)) #torque at crank #write motion of support frame: sensorFileName = 'solution/floatingPos'+iCalc+'.txt' sFloating = mbs.AddSensor(SensorNode(nodeNumber=nFloating, fileName=sensorFileName, outputVariableType=exu.OutputVariableType.Position)) #++++++++++++++++++++++++++++++++ #assemble, adjust settings and start time integration mbs.Assemble() simulationSettings = exu.SimulationSettings() #takes currently set values or default values tEnd = 3 simulationSettings.timeIntegration.numberOfSteps = int(tEnd/h) simulationSettings.timeIntegration.endTime = tEnd #simulationSettings.timeIntegration.newton.relativeTolerance = 1e-8 #10000 #simulationSettings.timeIntegration.verboseMode = 1 #10000 simulationSettings.solutionSettings.solutionWritePeriod = 2e-3 simulationSettings.solutionSettings.writeSolutionToFile = useGraphics simulationSettings.timeIntegration.newton.useModifiedNewton = True simulationSettings.timeIntegration.newton.relativeTolerance = 1e-8 simulationSettings.timeIntegration.newton.absoluteTolerance = 1e-8 #++++++++++++++++++++++++++++++++++++++++++ #solve index 2 / trapezoidal rule: simulationSettings.timeIntegration.generalizedAlpha.useNewmark = True simulationSettings.timeIntegration.generalizedAlpha.useIndex2Constraints = True dSize = 0.02 SC.visualizationSettings.nodes.defaultSize = dSize SC.visualizationSettings.markers.defaultSize = dSize SC.visualizationSettings.bodies.defaultSize = [dSize, dSize, dSize] SC.visualizationSettings.connectors.defaultSize = dSize #data obtained from SC.GetRenderState(); use np.round(d['modelRotation'],4) SC.visualizationSettings.openGL.initialModelRotation = [[ 0.87758, 0.04786, -0.47703], [ 0. , 0.995 , 0.09983], [ 0.47943, -0.08761, 0.8732]] SC.visualizationSettings.openGL.initialZoom = 0.47 SC.visualizationSettings.openGL.initialCenterPoint = [0.192, -0.0039,-0.075] SC.visualizationSettings.openGL.initialMaxSceneSize = 0.4 SC.visualizationSettings.general.autoFitScene = False #mbs.WaitForUserToContinue() if useGraphics: exu.StartRenderer() exu.SolveDynamic(mbs, simulationSettings) if useGraphics: #+++++++++++++++++++++++++++++++++++++ #animate solution # mbs.WaitForUserToContinue # fileName = 'coordinatesSolution.txt' # solution = LoadSolutionFile('coordinatesSolution.txt') # AnimateSolution(mbs, solution, 10, 0.025, True) #+++++++++++++++++++++++++++++++++++++ SC.WaitForRenderEngineStopFlag() exu.StopRenderer() #safely close rendering window! #++++++++++++++++++++++++++++++++++++++++++ #evaluate error: data = np.loadtxt(sensorFileName, comments='#', delimiter=',') errorNorm = max(abs(data[:,1])) + max(abs(data[:,2])) #max displacement in x and y direction #++++++++++++++++++++++++++++++++++++++++++ #clean up optimization if True: #delete files; does not work for parallel, consecutive operation if iCalc != 'Ref': os.remove(sensorFileName) #remove files in order to clean up while(os.path.exists(sensorFileName)): #wait until file is really deleted -> usually some delay sleep(0.001) #not nice, but there is no other way than that if useGraphics: print("max. oszillation=", errorNorm) from exudyn.plot import PlotSensor PlotSensor(mbs, sensorNumbers=[sFloating,sFloating], components=[0,1]) del mbs del SC return errorNorm