def compute_dt_matrices(A, B, h, TV=False): # variable declaration t0 = 0.0 # start time T = 1 # end time n, m = B.shape # Matrix declaration x0 = np.random.random(n) Csurface = np.random.random((m, n)) # Declaration of the Dynamical System if TV: process_ds = SK.FirstOrderLinearDS(x0, A) else: process_ds = SK.FirstOrderLinearTIDS(x0, A) # Model process = SK.Model(t0, T) process.nonSmoothDynamicalSystem().insertDynamicalSystem(process_ds) # time discretisation process_time_discretisation = SK.TimeDiscretisation(t0, h) # Creation of the Simulation process_simu = SK.TimeStepping(process_time_discretisation, 0) process_simu.setName("plant simulation") # Declaration of the integrator process_integrator = SK.ZeroOrderHoldOSI() process_integrator.insertDynamicalSystem(process_ds) process_simu.insertIntegrator(process_integrator) rel = SK.FirstOrderLinearTIR(Csurface, B) nslaw = SK.RelayNSL(m) inter = SK.Interaction(m, nslaw, rel) #process.nonSmoothDynamicalSystem().insertInteraction(inter, True) process.nonSmoothDynamicalSystem().link(inter, process_ds) process.nonSmoothDynamicalSystem().setControlProperty(inter, True) # Initialization process.initialize(process_simu) # Main loop process_simu.computeOneStep() Ad = SK.getMatrix(process_integrator.Ad(process_ds)).copy() Bd = SK.getMatrix(process_integrator.Bd(process_ds)).copy() return (Ad, Bd)
def test_bouncing_ball1(): """Run a complete simulation (Bouncing ball example) LagrangianLinearTIDS, no plugins. """ t0 = 0. # start time tend = 10. # end time h = 0.005 # time step r = 0.1 # ball radius g = 9.81 # gravity m = 1 # ball mass e = 0.9 # restitution coeficient theta = 0.5 # theta scheme # # dynamical system # x = np.zeros(3, dtype=np.float64) x[0] = 1. v = np.zeros_like(x) # mass matrix mass = np.eye(3, dtype=np.float64) mass[2, 2] = 3. / 5 * r * r # the dynamical system ball = sk.LagrangianLinearTIDS(x, v, mass) # set external forces weight = np.zeros_like(x) weight[0] = -m * g ball.setFExtPtr(weight) # # Interactions # # ball-floor H = np.zeros((1, 3), dtype=np.float64) H[0, 0] = 1. nslaw = sk.NewtonImpactNSL(e) relation = sk.LagrangianLinearTIR(H) inter = sk.Interaction(nslaw, relation) # # NSDS # bouncing_ball = sk.NonSmoothDynamicalSystem(t0, tend) # add the dynamical system to the non smooth dynamical system bouncing_ball.insertDynamicalSystem(ball) # link the interaction and the dynamical system bouncing_ball.link(inter, ball) # # Simulation # # (1) OneStepIntegrators OSI = sk.MoreauJeanOSI(theta) # (2) Time discretisation -- t = sk.TimeDiscretisation(t0, h) # (3) one step non smooth problem osnspb = sk.LCP() # (4) Simulation setup with (1) (2) (3) s = sk.TimeStepping(bouncing_ball,t, OSI, osnspb) # end of model definition # # computation # # # save and load data from xml and .dat # try: from siconos.io import save save(bouncing_ball, "bouncingBall.xml") save(bouncing_ball, "bouncingBall.bin") except: print("Warning : could not import save from siconos.io") # the number of time steps nb_time_steps = int((tend - t0) / h + 1) # Get the values to be plotted # ->saved in a matrix dataPlot data = np.empty((nb_time_steps, 5)) # # numpy pointers on dense Siconos vectors # q = ball.q() v = ball.velocity() p = ball.p(1) lambda_ = inter.lambda_(1) # # initial data # data[0, 0] = t0 data[0, 1] = q[0] data[0, 2] = v[0] data[0, 3] = p[0] data[0, 4] = lambda_[0] k = 1 # time loop while(s.hasNextEvent()): s.computeOneStep() data[k, 0] = s.nextTime() data[k, 1] = q[0] data[k, 2] = v[0] data[k, 3] = p[0] data[k, 4] = lambda_[0] k += 1 #print(s.nextTime()) s.nextStep() # # comparison with the reference file # ref = sk.getMatrix(sk.SimpleMatrix( os.path.join(working_dir, "data/result.ref"))) assert (np.linalg.norm(data - ref) < 1e-12)
def test_bouncing_ball2(): """Run a complete simulation (Bouncing ball example) LagrangianLinearTIDS, plugged Fext. """ t0 = 0 # start time T = 5 # end time h = 0.005 # time step r = 0.1 # ball radius g = 9.81 # gravity m = 1 # ball mass e = 0.9 # restitution coeficient theta = 0.5 # theta scheme # # dynamical system # x = np.zeros(3, dtype=np.float64) x[0] = 1. v = np.zeros_like(x) # mass matrix mass = np.eye(3, dtype=np.float64) mass[2, 2] = 3. / 5 * r * r # the dynamical system ball = sk.LagrangianLinearTIDS(x, v, mass) weight = np.zeros(ball.dimension()) weight[0] = -m * g ball.setFExtPtr(weight) # a ball with its own computeFExt class Ball(sk.LagrangianLinearTIDS): def computeFExt(self, t): """External forces operator computation """ print("computing FExt at t=", t) #self._fExt[0] = -m * g weight = np.zeros(self.dimension()) weight[0] = -m * g self.setFExtPtr(weight) ball_d = Ball(x.copy(), v.copy(), mass) ball_d.computeFExt(t0) # Interactions # # ball-floor H = np.zeros((1, 3), dtype=np.float64) H[0, 0] = 1. nslaw = sk.NewtonImpactNSL(e) nslaw_d = sk.NewtonImpactNSL(e) relation = sk.LagrangianLinearTIR(H) relation_d = sk.LagrangianLinearTIR(H) inter = sk.Interaction(nslaw, relation) inter_d = sk.Interaction(nslaw_d, relation_d) # # NSDS # bouncing_ball = sk.NonSmoothDynamicalSystem(t0, T) bouncing_ball_d = sk.NonSmoothDynamicalSystem(t0, T) # add the dynamical system to the non smooth dynamical system bouncing_ball.insertDynamicalSystem(ball) bouncing_ball_d.insertDynamicalSystem(ball_d) # link the interaction and the dynamical system bouncing_ball.link(inter, ball) bouncing_ball_d.link(inter_d, ball_d) # # Simulation # # (1) OneStepIntegrators OSI = sk.MoreauJeanOSI(theta) OSI_d = sk.MoreauJeanOSI(theta) # (2) Time discretisation -- t = sk.TimeDiscretisation(t0, h) t_d = sk.TimeDiscretisation(t0, h) # (3) one step non smooth problem osnspb = sk.LCP() osnspb_d = sk.LCP() # (4) Simulation setup with (1) (2) (3) s = sk.TimeStepping(bouncing_ball,t, OSI, osnspb) s_d = sk.TimeStepping(bouncing_ball_d,t_d, OSI_d, osnspb_d) # end of model definition # # computation # # the number of time steps nb_time_steps = int((T - t0) / h + 1) # Get the values to be plotted # ->saved in a matrix data s_d.computeOneStep() data = np.empty((nb_time_steps + 1, 5)) data_d = np.empty((nb_time_steps + 1, 5)) data[0, 0] = t0 data[0, 1] = ball.q()[0] data[0, 2] = ball.velocity()[0] data[0, 3] = ball.p(1)[0] data[0, 4] = inter.lambda_(1) data_d[0, 0] = t0 data_d[0, 1] = ball_d.q()[0] data_d[0, 2] = ball_d.velocity()[0] data_d[0, 3] = ball_d.p(1)[0] data_d[0, 4] = inter_d.lambda_(1) k = 1 # time loop while(s.hasNextEvent()): s.computeOneStep() s_d.computeOneStep() data[k, 0] = s.nextTime() data[k, 1] = ball.q()[0] data[k, 2] = ball.velocity()[0] data[k, 3] = ball.p(1)[0] data[k, 4] = inter.lambda_(1)[0] data_d[k, 0] = s_d.nextTime() data_d[k, 1] = ball_d.q()[0] data_d[k, 2] = ball_d.velocity()[0] data_d[k, 3] = ball_d.p(1)[0] data_d[k, 4] = inter_d.lambda_(1)[0] assert np.allclose(data[k, 1], data_d[k, 1]) #print(s.nextTime()) k += 1 s.nextStep() s_d.nextStep()
def test_lagrangian_and_osis(): """Tests osi/lagrangian combinations """ # --- The dynamical systems --- # dimension ndof = 3 # initial conditons q0 = np.zeros(ndof, dtype=np.float64) v0 = np.zeros_like(q0) q0[0] = 1. # mass, stiffness and damping matrices # (diagonal values only) mass_diag = np.ones(ndof, dtype=np.float64) k_diag = np.zeros_like(mass_diag) c_diag = np.zeros_like(mass_diag) sigma = 0.2 omega2 = 1.2 k_diag[...] = omega2 c_diag[...] = sigma ds_list = {} # - LagrangianLinearTIDS - ds_list['LTIDS+MJ'] = sk.LagrangianLinearTIDS(q0, v0, np.diag(mass_diag), np.diag(k_diag), np.diag(c_diag)) # - LagrangianLinearDiagonalDS - ds_list['LLDDS+MJ'] = sk.LagrangianLinearDiagonalDS( q0, v0, k_diag, c_diag, mass_diag) ds_list['LLDDS+MJB'] = sk.LagrangianLinearDiagonalDS( q0, v0, k_diag, c_diag, mass_diag) # no mass (i.e. implicitely equal to Id) ds_list['LLDDS+MJB2'] = sk.LagrangianLinearDiagonalDS( q0, v0, k_diag, c_diag) nb_ds = len(ds_list) for ds in ds_list.values(): ds.computeForces(0., q0, v0) assert np.allclose(ds_list['LTIDS+MJ'].forces(), ds_list['LTIDS+MJ'].forces()) # --- Interactions --- cor = 0.9 nslaw = sk.NewtonImpactNSL(cor) hmat = np.zeros((1, ndof), dtype=np.float64) hmat[0, 0] = 1. relation = sk.LagrangianLinearTIR(hmat) interactions = [] for k in range(nb_ds): interactions.append(sk.Interaction(nslaw, relation)) # --- NSDS --- tinit = 0. tend = 3. nsds = sk.NonSmoothDynamicalSystem(tinit, tend) # - insert ds into the model and link them with their interaction - ninter = 0 for ds in ds_list.values(): nsds.insertDynamicalSystem(ds) nsds.link(interactions[ninter], ds) ninter += 1 # --- Simulation --- # - (1) OneStepIntegrators -- theta = 0.5000001 standard = sk.MoreauJeanOSI(theta) bilbao = sk.MoreauJeanBilbaoOSI() #-- (2) Time discretisation -- time_step = 1e-4 td = sk.TimeDiscretisation(tinit, time_step) # -- (3) one step non smooth problem lcp = sk.LCP() # -- (4) Simulation setup with (1) (2) (3) simu = sk.TimeStepping(nsds, td, standard, lcp) # extra osi must be explicitely inserted into simu and linked to ds simu.associate(standard, ds_list['LTIDS+MJ']) simu.associate(standard, ds_list['LLDDS+MJ']) simu.associate(bilbao, ds_list['LLDDS+MJB']) simu.associate(bilbao, ds_list['LLDDS+MJB2']) positions = [] velocities = [] for ds in ds_list.values(): positions.append(ds.q()) velocities.append(ds.velocity()) # number of time steps and buffer used to save results nb_steps = int((tend - tinit) / time_step) + 1 data = np.zeros((nb_steps, 1 + 2 * len(ds_list)), dtype=np.float64) data[0, 0] = tinit for k in range(nb_ds): data[0, k * 2 + 1] = positions[k][0] data[0, k * 2 + 2] = velocities[k][0] current_iter = 1 # --- Time loop --- while simu.hasNextEvent(): simu.computeOneStep() data[current_iter, 0] = simu.nextTime() for k in range(nb_ds): data[current_iter, k * 2 + 1] = positions[k][0] data[current_iter, k * 2 + 2] = velocities[k][0] simu.nextStep() current_iter += 1 # -- check results ref_pos = data[:, 1] ref_vel = data[:, 2] for k in range(1, nb_ds): assert np.allclose(ref_pos, data[:, k * 2 + 1], atol=time_step) assert np.allclose(ref_vel, data[:, k * 2 + 2], atol=time_step)
def test_bouncing_ball2(): import siconos.kernel as K from numpy import array, eye, empty t0 = 0 # start time T = 5 # end time h = 0.005 # time step r = 0.1 # ball radius g = 9.81 # gravity m = 1 # ball mass e = 0.9 # restitution coeficient theta = 0.5 # theta scheme # # dynamical system # x = array([1, 0, 0]) # initial position v = array([0, 0, 0]) # initial velocity mass = eye(3) # mass matrix mass[2, 2] = 3./5 * r * r # the dynamical system ball = K.LagrangianLinearTIDS(x, v, mass) # set external forces weight = array([-m * g, 0, 0]) ball.setFExtPtr(weight) # a ball with its own computeFExt class Ball(K.LagrangianLinearTIDS): def computeFExt(self, t): #print("computing FExt at t=", t) weight = array([-m * g, 0, 0]) self.setFExtPtr(weight) ball_d = Ball(array([1, 0, 0]), array([0, 0, 0]), mass) ball_d.setFExtPtr(array([0, 0, 0])) # # Interactions # # ball-floor H = array([[1, 0, 0]]) nslaw = K.NewtonImpactNSL(e) nslaw_d = K.NewtonImpactNSL(e) relation = K.LagrangianLinearTIR(H) relation_d = K.LagrangianLinearTIR(H) inter = K.Interaction(1, nslaw, relation) inter_d = K.Interaction(1, nslaw_d, relation_d) # # Model # bouncingBall = K.Model(t0, T) bouncingBall_d = K.Model(t0, T) # add the dynamical system to the non smooth dynamical system bouncingBall.nonSmoothDynamicalSystem().insertDynamicalSystem(ball) bouncingBall_d.nonSmoothDynamicalSystem().insertDynamicalSystem(ball_d) # link the interaction and the dynamical system bouncingBall.nonSmoothDynamicalSystem().link(inter, ball) bouncingBall_d.nonSmoothDynamicalSystem().link(inter_d, ball_d) # # Simulation # # (1) OneStepIntegrators OSI = K.MoreauJeanOSI(theta) OSI.insertDynamicalSystem(ball) OSI_d = K.MoreauJeanOSI(theta) OSI_d.insertDynamicalSystem(ball_d) # (2) Time discretisation -- t = K.TimeDiscretisation(t0, h) t_d = K.TimeDiscretisation(t0, h) # (3) one step non smooth problem osnspb = K.LCP() osnspb_d = K.LCP() # (4) Simulation setup with (1) (2) (3) s = K.TimeStepping(t) s.insertIntegrator(OSI) s.insertNonSmoothProblem(osnspb) s_d = K.TimeStepping(t_d) s_d.insertIntegrator(OSI_d) s_d.insertNonSmoothProblem(osnspb_d) # end of model definition # # computation # # simulation initialization bouncingBall.initialize(s) bouncingBall_d.initialize(s_d) # the number of time steps N = (T-t0)/h+1 # Get the values to be plotted # ->saved in a matrix dataPlot s_d.computeOneStep() dataPlot = empty((N+1, 5)) dataPlot_d = empty((N+1, 5)) dataPlot[0, 0] = t0 dataPlot[0, 1] = ball.q()[0] dataPlot[0, 2] = ball.velocity()[0] dataPlot[0, 3] = ball.p(1)[0] dataPlot[0, 4] = inter.lambda_(1) dataPlot_d[0, 0] = t0 dataPlot_d[0, 1] = ball_d.q()[0] dataPlot_d[0, 2] = ball_d.velocity()[0] dataPlot_d[0, 3] = ball_d.p(1)[0] dataPlot_d[0, 4] = inter_d.lambda_(1) k = 1 # time loop while(s.hasNextEvent()): s.computeOneStep() s_d.computeOneStep() dataPlot[k, 0] = s.nextTime() dataPlot[k, 1] = ball.q()[0] dataPlot[k, 2] = ball.velocity()[0] dataPlot[k, 3] = ball.p(1)[0] dataPlot[k, 4] = inter.lambda_(1)[0] dataPlot_d[k, 0] = s_d.nextTime() dataPlot_d[k, 1] = ball_d.q()[0] dataPlot_d[k, 2] = ball_d.velocity()[0] dataPlot_d[k, 3] = ball_d.p(1)[0] dataPlot_d[k, 4] = inter_d.lambda_(1)[0] assert dataPlot[k, 1] == dataPlot_d[k, 1] #print(s.nextTime()) k += 1 s.nextStep() s_d.nextStep()
ball = sk.NewtonEulerDS(x, v, m, inertia) # set external forces weight = [-m * g, 0, 0] ball.setFExtPtr(weight) # # Interactions # # ball-floor e = 0.9 # restitution coeficient nslaw = sk.NewtonImpactNSL(e) relation = BouncingBallR(r) inter = sk.Interaction(nslaw, relation) # # Model # t0 = 0 # start time T = 10.0 # end time bouncingBall = sk.NonSmoothDynamicalSystem(t0, T) # add the dynamical system to the non smooth dynamical system bouncingBall.insertDynamicalSystem(ball) # link the interaction and the dynamical system bouncingBall.link(inter, ball) #
diminter = 1 hh = np.zeros((diminter, sico.nbdof)) b = np.zeros(diminter) b[0] = 1.0 k = 0 relation = [] inter = [] hh = np.zeros((diminter, sico.nbdof)) nbInter = pidbot.shape[0] for i in range(nbInter): # hh is a submatrix of sico.H with 1 row. hh[:, :] = sico.H[k, :] k += 3 relation.append(kernel.LagrangianLinearTIR(hh, b)) inter.append(kernel.Interaction(diminter, nslaw, relation[i])) nbInter = len(inter) # ======================================= # The Model # ======================================= blockModel = kernel.Model(t0, T) # add the dynamical system to the non smooth dynamical system blockModel.nonSmoothDynamicalSystem().insertDynamicalSystem(block) # link the interactions and the dynamical system for i in range(nbInter): blockModel.nonSmoothDynamicalSystem().link(inter[i], block)
# # Interactions # C = [[-1., 0.]] D = [[Rvalue]] B = [[-1. / Cvalue], [0.]] LTIRCircuitRLCD = sk.FirstOrderLinearTIR(C, B) LTIRCircuitRLCD.setDPtr(D) nslaw = sk.ComplementarityConditionNSL(1) InterCircuitRLCD = sk.Interaction(nslaw, LTIRCircuitRLCD) # # Model # CircuitRLCD = sk.NonSmoothDynamicalSystem(t0, T) CircuitRLCD.setTitle("CircuitRLCD") # add the dynamical system in the non smooth dynamical system CircuitRLCD.insertDynamicalSystem(LSCircuitRLCD) # link the interaction and the dynamical system CircuitRLCD.link(InterCircuitRLCD, LSCircuitRLCD) # # Simulation
A = np.zeros((2, 2)) x0 = np.array([Vinit, -Vinit]) B = 2.0 * np.eye(2) C = np.eye(2) D = np.zeros((2, 2)) process = sk.FirstOrderLinearDS(x0, A) process.setComputebFunction('plugins', 'computeB') # Interactions myNslaw = sk.RelayNSL(2) myProcessRelation = sk.FirstOrderLinearR(C, B) myProcessRelation.setComputeEFunction('plugins', 'computeE') # myProcessRelation.setDPtr(D) myProcessInteraction = sk.Interaction(myNslaw, myProcessRelation) # NSDS simplerelay = sk.NonSmoothDynamicalSystem(t0, T) simplerelay.insertDynamicalSystem(process) simplerelay.link(myProcessInteraction, process) # myProcessRelation.computeJachx(0, x0, x0 , x0, C) # Simulation s = sk.TimeStepping(simplerelay, sk.TimeDiscretisation(t0, h), sk.EulerMoreauOSI(theta), sk.Relay()) # s.setComputeResiduY(True) # s.setComputeResiduR(True) # matrix to save data
dist = 3.0 dimH = sico.H.shape[0] if(with_friction): diminter = dimH nslaw = kernel.NewtonImpactFrictionNSL(e,e,mu,3) relation = kernel.LagrangianLinearTIR(sico.H) else: diminter = dimH/3 Hnofric = np.zeros((diminter, sico.nbdof)) b = np.repeat([dist], diminter) Hnofric = sico.H[0:dimH-1:3,:] nslaw = kernel.NewtonImpactNSL(e) relation = kernel.LagrangianLinearTIR(Hnofric,b) inter = kernel.Interaction(diminter, nslaw, relation) # ======================================= # The Model # ======================================= blockModel = kernel.Model(t0,T) # add the dynamical system to the non smooth dynamical system blockModel.nonSmoothDynamicalSystem().insertDynamicalSystem(block) # link the interaction and the dynamical system blockModel.nonSmoothDynamicalSystem().link(inter,block); # ======================================= # The Simulation # =======================================
# # Interactions # C = [[0., 0.], [0, 0.], [-1., 0.], [1., 0.]] D = [[1. / Rvalue, 1. / Rvalue, -1., 0.], [1. / Rvalue, 1. / Rvalue, 0., -1.], [1., 0., 0., 0.], [0., 1., 0., 0.]] B = [[0., 0., -1. / Cvalue, 1. / Cvalue], [0., 0., 0., 0.]] LTIRDiodeBridge = sk.FirstOrderLinearTIR(C, B) LTIRDiodeBridge.setDPtr(D) nslaw = sk.ComplementarityConditionNSL(4) InterDiodeBridge = sk.Interaction(nslaw, LTIRDiodeBridge) # # Model # DiodeBridge = sk.Model(t0, T, Modeltitle) # add the dynamical system in the non smooth dynamical system DiodeBridge.nonSmoothDynamicalSystem().insertDynamicalSystem(LSDiodeBridge) # link the interaction and the dynamical system DiodeBridge.nonSmoothDynamicalSystem().link(InterDiodeBridge, LSDiodeBridge) # # Simulation #
def run_simulation_with_two_ds(ball, ball_d, t0): T = 5 # end time h = 0.005 # time step e = 0.9 # restitution coeficient theta = 0.5 # theta scheme # ball-floor H = np.zeros((1, 3), dtype=np.float64) H[0, 0] = 1. nslaw = sk.NewtonImpactNSL(e) nslaw_d = sk.NewtonImpactNSL(e) relation = sk.LagrangianLinearTIR(H) relation_d = sk.LagrangianLinearTIR(H) inter = sk.Interaction(nslaw, relation) inter_d = sk.Interaction(nslaw_d, relation_d) # # NSDS # bouncing_ball = sk.NonSmoothDynamicalSystem(t0, T) bouncing_ball_d = sk.NonSmoothDynamicalSystem(t0, T) # add the dynamical system to the non smooth dynamical system bouncing_ball.insertDynamicalSystem(ball) bouncing_ball_d.insertDynamicalSystem(ball_d) # link the interaction and the dynamical system bouncing_ball.link(inter, ball) bouncing_ball_d.link(inter_d, ball_d) # # Simulation # # (1) OneStepIntegrators OSI = sk.MoreauJeanOSI(theta) OSI_d = sk.MoreauJeanOSI(theta) # (2) Time discretisation -- t = sk.TimeDiscretisation(t0, h) t_d = sk.TimeDiscretisation(t0, h) # (3) one step non smooth problem osnspb = sk.LCP() osnspb_d = sk.LCP() # (4) Simulation setup with (1) (2) (3) s = sk.TimeStepping(bouncing_ball, t, OSI, osnspb) s_d = sk.TimeStepping(bouncing_ball_d, t_d, OSI_d, osnspb_d) # end of model definition # # computation # # the number of time steps nb_time_steps = int((T - t0) / h + 1) # Get the values to be plotted # ->saved in a matrix data s_d.computeOneStep() data = np.empty((nb_time_steps + 1, 5)) data_d = np.empty((nb_time_steps + 1, 5)) data[0, 0] = t0 data[0, 1] = ball.q()[0] data[0, 2] = ball.velocity()[0] data[0, 3] = ball.p(1)[0] data[0, 4] = inter.lambda_(1) data_d[0, 0] = t0 data_d[0, 1] = ball_d.q()[0] data_d[0, 2] = ball_d.velocity()[0] data_d[0, 3] = ball_d.p(1)[0] data_d[0, 4] = inter_d.lambda_(1) k = 1 # time loop while (s.hasNextEvent()): s.computeOneStep() s_d.computeOneStep() data[k, 0] = s.nextTime() data[k, 1] = ball.q()[0] data[k, 2] = ball.velocity()[0] data[k, 3] = ball.p(1)[0] data[k, 4] = inter.lambda_(1)[0] data_d[k, 0] = s_d.nextTime() data_d[k, 1] = ball_d.q()[0] data_d[k, 2] = ball_d.velocity()[0] data_d[k, 3] = ball_d.p(1)[0] data_d[k, 4] = inter_d.lambda_(1)[0] assert np.allclose(data[k, 1], data_d[k, 1]) #print(s.nextTime()) k += 1 s.nextStep() s_d.nextStep() data.resize(k, 5) view = False if view: import matplotlib.pyplot as plt fig_size = [14, 14] plt.rcParams["figure.figsize"] = fig_size plt.subplot(411) plt.title('displacement') plt.plot(data[:, 0], data[:, 1]) plt.grid() plt.subplot(412) plt.title('velocity') plt.plot(data[:, 0], data[:, 2]) plt.grid() plt.subplot(413) plt.plot(data[:, 0], data[:, 3]) plt.title('reaction') plt.grid() plt.subplot(414) plt.plot(data[:, 0], data[:, 4]) plt.title('lambda') plt.grid() plt.show()
B = np.zeros((ndof, ninter), dtype=np.float64) B[0, 0] = -alpha * 0.5 B[0, 1] = 1 + alpha * 0.5 B[1, 0] = -B[0, 1] B[1, 1] = B[0, 0] B[2, 0] = gamma * 0.5 B[2, 1] = gamma * 0.5 C = np.zeros((ninter, ndof), dtype=np.float64) C[0, 0] = C[1, 1] = -1. particle_relation = sk.FirstOrderLinearR(C, B) nslaw = sk.RelayNSL(ninter) particle_interaction = sk.Interaction(nslaw, particle_relation) # -- The Model -- filippov = sk.Model(t0, T) nsds = filippov.nonSmoothDynamicalSystem() nsds.insertDynamicalSystem(particle) nsds.link(particle_interaction, particle) # -- Simulation -- td = sk.TimeDiscretisation(t0, h) simu = sk.TimeStepping(td) # osi theta = 0.5 myIntegrator = sk.EulerMoreauOSI(theta) simu.insertIntegrator(myIntegrator)
ninter = number_of_cars B = np.zeros((ndof, ninter), dtype=np.float64) np.fill_diagonal(B[number_of_cars:, :number_of_cars], -1. / D) M = np.zeros((ninter, ninter), dtype=np.float64) np.fill_diagonal(M[:number_of_cars, :number_of_cars], S) N = np.zeros((ninter, ndof), dtype=np.float64) np.fill_diagonal(N[:number_of_cars, number_of_cars:], -1.) relation = sk.FirstOrderLinearTIR(N, B) relation.setDPtr(M) nslaw = sk.ComplementarityConditionNSL(ninter) interaction = sk.Interaction(ninter, nslaw, relation) # -- The Model -- circuit = sk.Model(t0, T, 'train') nsds = circuit.nonSmoothDynamicalSystem() nsds.insertDynamicalSystem(RC) nsds.link(interaction, RC) # -- Simulation -- td = sk.TimeDiscretisation(t0, tau) simu = sk.TimeStepping(td) # osi theta = 0.50000000000001 osi = sk.EulerMoreauOSI(theta) osi.insertDynamicalSystem(RC) simu.insertIntegrator(osi)