def test_LagrangianLinearTIDS(): ball = K.LagrangianLinearTIDS(q, v, mass) assert np.allclose(ball.q(), q, rtol=tol, atol=tol) assert np.allclose(ball.velocity(), v, rtol=tol, atol=tol) assert np.allclose(ball.mass(), mass, rtol=tol, atol=tol) ball.setFExtPtr(weight) assert np.allclose(ball.fExt(), weight, rtol=tol, atol=tol)
def test_lagrangian_tids(): """Build and test lagrangian linear and time-invariant ds """ q0[...] = [1, 2, 3] v0[...] = [4, 5, 6] mass = np.asarray(np.diag([1, 2, 3]), dtype=np.float64) stiffness = np.zeros((ndof, ndof), dtype=np.float64) stiffness.flat[...] = np.arange(9) damping = np.zeros_like(stiffness) damping.flat[...] = np.arange(9, 18) ds = sk.LagrangianLinearTIDS(q0, v0, mass, stiffness, damping) ec = ds.computeKineticEnergy() assert ec == 87. assert ds.dimension() == ndof assert np.allclose(ds.mass(), mass) assert np.allclose(ds.K(), stiffness) assert np.allclose(ds.C(), damping) q = ds.q() v = ds.velocity() fref = -np.dot(stiffness, q) fref -= np.dot(damping, v) time = 0.3 ds.computeForces(time, q, v) assert np.allclose(fref, ds.forces()) ds.computeJacobianqForces(time) assert np.allclose(stiffness, ds.jacobianqForces()) ds.computeJacobianqDotForces(time) assert np.allclose(damping, ds.jacobianqDotForces())
def test_bouncing_ball4(): """Run a complete simulation (Bouncing ball example) LagrangianDS, plugged Fext. """ t0 = 0 # start time r = 0.1 # ball radius g = 9.81 # gravity m = 1 # ball mass # # 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) stiffness = np.eye(3, dtype=np.float64) ball.setKPtr(stiffness) weight = np.zeros(ball.dimension()) weight[0] = -m * g #ball.setFExtPtr(weight) # a ball with its own computeFExt class Ball(sk.LagrangianLinearTIDS): def __init__(self, x, v, mass, stiffness): sk.LagrangianLinearTIDS.__init__(self, x, v, mass) self.setKPtr(stiffness) 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, stiffness) ball_d.computeFExt(t0) run_simulation_with_two_ds(ball, ball_d, t0)
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()
# From getfem, we have Mass, Stiffness and RHS # saved in object sico. # H-Matrix fillH(pidbot, sico, mfu.nbdof(), BOTTOM) # ======================================= # Create the siconos Dynamical System # # Mass.ddot q + Kq = fExt # # q: dof vector (displacements) # ======================================= # Initial displacement and velocity v0 = np.zeros(sico.nbdof) block = kernel.LagrangianLinearTIDS(sico.initial_displacement, v0, sico.Mass) # set fExt and K block.setFExtPtr(sico.RHS) block.setKPtr(sico.Stiff) # ======================================= # The interactions # A contact is defined for each node at # the bottom of the block # ======================================= # Create one relation/interaction for each point # in the bottom surface # Each interaction is of size three with a # relation between local coordinates at contact and global coordinates given by: # y = Hq + b # y = [ normal component, first tangent component, second tangent component]
e = 0.9 # restitution coeficient mu=0.3 # Friction coefficient theta = 0.5 # theta scheme with_friction = False sico = gts.SiconosFem() fem_model = gts.import_fem(sico) # ======================================= # Create the siconos Dynamical System # ======================================= # Initial position and velocity v0 = np.zeros(sico.nbdof) block = kernel.LagrangianLinearTIDS(sico.pos,v0,sico.Mass.full()) F = sico.RHS + sico.K0 block.setFExtPtr(F) block.setKPtr(sico.Stiff.full()) # ======================================= # The interaction # ======================================= 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)
mu = 0.3 # Friction coefficient theta = 0.5 # theta scheme m = 1 # ======================================= # Create the siconos Dynamical System # ======================================= # Initial position and velocity v0 = np.zeros(ndof) q0 = np.zeros(ndof) Mass = np.eye(ndof) K = np.eye(ndof) weight = np.zeros(ndof) weight[0:ndof - 1:3] = -m * g block = kernel.LagrangianLinearTIDS(q0, v0, Mass) block.setFExtPtr(weight) block.setKPtr(K) diminter = 4 H = np.zeros((diminter, ndof)) H[0, 2] = 1.0 H[1, 5] = 1.0 H[2, 8] = 1.0 H[3, 11] = 1.0 dist = 3.0 b = np.repeat([dist], diminter) nslaw = kernel.NewtonImpactNSL(e) relation = kernel.LagrangianLinearTIR(H, b) inter = kernel.Interaction(diminter, nslaw, relation)