def __init__( self , force , p_set , dt , x_constraint=None , v_constraint=None ): super(StormerVerletSolverConstrained,self).__init__( force , p_set , dt , x_constraint=None , v_constraint=None ) self.__pset_m1 = ps.ParticlesSet( p_set.size , p_set.dim , mass=False , velocity=False ) self.__pset_tmp = ps.ParticlesSet( p_set.size , p_set.dim , mass=False , velocity=False ) if x_constraint != None : self.x_constraint = x_constraint
def __init__(self, force, p_set, dt): super(StormerVerletSolver, self).__init__(force, p_set, dt) self.__pset_m1 = ps.ParticlesSet(p_set.size, p_set.dim, mass=False, velocity=False) self.__pset_tmp = ps.ParticlesSet(p_set.size, p_set.dim, mass=False, velocity=False)
def gravity_cluster(): if not test_pyopencl(): print("") print("Attention !!! ") print( " This demo works only with PyOpenCL: \n http://mathema.tician.de/software/pyopencl \n http://www.khronos.org/opencl/ \n " ) print(" Please install the package: python-pyopencl for continuing") print("") return G = 0.000001 steps = 100000000 n = 3000 dt = 0.04 pset = ps.ParticlesSet(n, dtype=np.float32) cs = clu.RandGalaxyCluster() print("Building initial galaxy .... ") cs.insert3(pset.X, M=pset.M, V=pset.V, G=G) try: occx = occ.OpenCLcontext( pset.size, pset.dim, (occ.OCLC_X | occ.OCLC_V | occ.OCLC_A | occ.OCLC_M)) except: print("") print("ERROR !!! ") print(" Please verify your opencl installation ") print(" Probably you must install your GPU OpenCL drivers") print("") return grav = gr.GravityOCL(pset.size, Consts=G, ocl_context=occx) grav.set_masses(pset.M) grav.update_force(pset) solver = els.EulerSolverOCL(grav, pset, dt, ocl_context=occx) a = aogl.AnimatedGl() a.draw_particles.set_draw_model(a.draw_particles.DRAW_MODEL_VECTOR) a.ode_solver = solver a.pset = pset a.steps = steps a.build_animation() a.start() return
def bubble(): """ Pseudo bubble simulation """ steps = 1000000 dt = 0.01 r_min = 1.5 rand_c = rc.RandCluster() pset = ps.ParticlesSet(1000) rand_c.insert3(X=pset.X, M=pset.M, start_indx=0, n=pset.size, radius=5.0, mass_rng=(0.5, 0.8), r_min=0.0) bubble = pb.PseudoBubble(pset.size, pset.dim, Consts=(r_min, 10)) constf = cf.ConstForce(pset.size, dim=pset.dim, u_force=[0, 0, -10]) drag = dr.Drag(pset.size, pset.dim, Consts=0.01) multif = mf.MultipleForce(pset.size, pset.dim) multif.append_force(bubble) multif.append_force(constf) multif.append_force(drag) multif.set_masses(pset.M) #solver = els.EulerSolver( multif , pset , dt ) #solver = lps.LeapfrogSolver( lennard_jones , pset , dt ) solver = svs.StormerVerletSolver(multif, pset, dt) #solver = rks.RungeKuttaSolver( lennard_jones , pset , dt ) #solver = mds.MidpointSolver( lennard_jones , pset , dt ) bound = rb.ReboundBoundary(bound=(-5.0, 5.0)) pset.set_boundary(bound) a = aogl.AnimatedGl() a.ode_solver = solver a.pset = pset a.steps = steps a.build_animation() a.start() return
def __init__(self, force, p_set, dt, x_constraint=None, v_constraint=None): super(MidpointSolverConstrained, self).__init__(force, p_set, dt, x_constraint=None, v_constraint=None) self.__mid_pset = ps.ParticlesSet(p_set.size, p_set.dim) if x_constraint != None: self.x_constraint = x_constraint
def gas_lj(): """ Gas simulation based on the Lennard Jones force """ steps = 1000000 dt = 0.001 omicron = 0.05 epsilon = 1.0 rand_c = rc.RandCluster() pset = ps.ParticlesSet(1000) r_min = 2.0**(1. / 6.) * omicron rand_c.insert3(X=pset.X, M=pset.M, start_indx=0, n=pset.size, radius=5.0, mass_rng=(0.1, 0.3), r_min=r_min) lennard_jones = lj.LenardJones(pset.size, pset.dim, pset.M, Consts=(epsilon, omicron)) solver = els.EulerSolver(lennard_jones, pset, dt) #solver = lps.LeapfrogSolver( lennard_jones , pset , dt ) #solver = svs.StormerVerletSolver( lennard_jones , pset , dt ) #solver = rks.RungeKuttaSolver( lennard_jones , pset , dt ) #solver = mds.MidpointSolver( lennard_jones , pset , dt ) bound = pb.PeriodicBoundary(bound=(-6.0, 6.0)) pset.set_boundary(bound) a = aogl.AnimatedGl() a.ode_solver = solver a.pset = pset a.steps = steps a.build_animation() a.start() return
def __init__( self , force , p_set , dt ): super(RungeKuttaSolver,self).__init__( force , p_set , dt ) self.__Kv1 = np.zeros( self.force.A.shape ) self.__Kv2 = np.zeros( self.force.A.shape ) self.__Kv3 = np.zeros( self.force.A.shape ) self.__Kv4 = np.zeros( self.force.A.shape ) self.__Kx1 = np.zeros( self.force.A.shape ) self.__Kx2 = np.zeros( self.force.A.shape ) self.__Kx3 = np.zeros( self.force.A.shape ) self.__Kx4 = np.zeros( self.force.A.shape ) self.__tmp_pset = ps.ParticlesSet( p_set.size , p_set.dim )
def fountain(): """ Fountain demo """ steps = 10000000 dt = 0.01 pcnt = 250000 pset = ps.ParticlesSet(pcnt) pset.M[:] = 0.1 pset.X[:, 2] = 0.7 * np.random.rand(pset.size) grav = cf.ConstForce(pset.size, dim=pset.dim, u_force=(0.0, 0.0, -10.0)) drag = dr.Drag(pset.size, dim=pset.dim, Consts=0.01) multi = mf.MultipleForce(pset.size, dim=pset.dim) multi.append_force(grav) multi.append_force(drag) multi.set_masses(pset.M) solver = mds.MidpointSolver(multi, pset, dt) solver.update_force() default_pos.sim_time = solver.get_sim_time() bd = (-100.0, 100.0, -100.0, 100.0, 0.0, 100.0) bound = db.DefaultBoundary(bd, dim=3, defualt_pos=default_pos) pset.set_boundary(bound) a = aogl.AnimatedGl() a.ode_solver = solver a.pset = pset a.steps = steps a.draw_particles.set_draw_model(a.draw_particles.DRAW_MODEL_VECTOR) a.init_rotation(-80, [0.7, 0.05, 0]) a.build_animation() a.start() return
def build_animation(self): self.steps = 6000 dt = 0.004 self.ip = 1 self.pset = ps.ParticlesSet(2, 3) self.pset.M[:] = 1.0 self.pset.V[:] = 0.0 self.pset.X[0, :] = 0.0 self.pset.X[1, :] = 1.0 / np.sqrt(3) ci = np.array([0]) cx = np.array([0.0, 0.0, 0.0]) costrs = csx.ConstrainedX(self.pset) costrs.add_x_constraint(ci, cx) self.t = np.zeros((self.steps)) self.x = np.zeros((self.steps, self.pset.dim)) self.xn = np.zeros((self.steps, self.pset.dim)) spring = ls.LinearSpring(self.pset.size, self.pset.dim, Consts=1.0) damp = da.Damping(self.pset.size, self.pset.dim, Consts=0.5) multi = mf.MultipleForce(self.pset.size) multi.append_force(spring) multi.append_force(damp) multi.set_masses(self.pset.M) self.odes = dict() self.odes["Euler "] = els.EulerSolverConstrained( multi, self.pset, dt, costrs) self.odes["Runge Kutta"] = rks.RungeKuttaSolverConstrained( multi, self.pset, dt, costrs) self.odes["Leap Frog "] = lps.LeapfrogSolverConstrained( multi, self.pset, dt, costrs) self.odes["MidPoint "] = mps.MidpointSolverConstrained( multi, self.pset, dt, costrs) self.odes["Verlet "] = svs.StormerVerletSolverConstrained( multi, self.pset, dt, costrs)
def __init__( self , force , p_set , dt , x_constraint=None , v_constraint=None ): super(RungeKuttaSolverConstrained,self).__init__( force , p_set , dt , x_constraint=None , v_constraint=None ) if x_constraint != None : self.x_constraint = x_constraint self.__Kv1 = np.zeros( self.force.A.shape ) self.__Kv2 = np.zeros( self.force.A.shape ) self.__Kv3 = np.zeros( self.force.A.shape ) self.__Kv4 = np.zeros( self.force.A.shape ) self.__Kx1 = np.zeros( self.force.A.shape ) self.__Kx2 = np.zeros( self.force.A.shape ) self.__Kx3 = np.zeros( self.force.A.shape ) self.__Kx4 = np.zeros( self.force.A.shape ) self.__tmp_pset = ps.ParticlesSet( p_set.size , p_set.dim )
def build_animation(self): self.steps = 6000 dt = 0.004 self.ip = 1 self.pset = ps.ParticlesSet(2, 3) self.pset.M[:] = 1.0 self.pset.V[:] = 0.0 self.pset.X[0, :] = 0.0 self.pset.X[1, :] = 1.0 / np.sqrt(3) ci = np.array([0]) cx = np.array([0.0, 0.0, 0.0]) costrs = csx.ConstrainedX(self.pset) costrs.add_x_constraint(ci, cx) self.t = np.zeros((self.steps)) self.x = np.zeros((self.steps, self.pset.dim)) self.xn = np.zeros((self.steps, self.pset.dim)) spring = ls.LinearSpring(self.pset.size, self.pset.dim, Consts=1.0) spring.set_masses(self.pset.M) self.odes = dict() self.odes["Euler "] = asc.EulerSolverConstrained( spring, self.pset, dt, costrs) self.odes["Runge Kutta"] = rkc.RungeKuttaSolverConstrained( spring, self.pset, dt, costrs) self.odes["Leap Frog "] = lpc.LeapfrogSolverConstrained( spring, self.pset, dt, costrs) self.odes["MidPoint "] = mdc.MidpointSolverConstrained( spring, self.pset, dt, costrs) self.odes["Verlet "] = svc.StormerVerletSolverConstrained( spring, self.pset, dt, costrs)
def build_animation(self): self.steps = 3000 self.pset = ps.ParticlesSet(1, 3) self.ip = 0 self.pset.M[:] = 1.0 self.pset.V[:] = 0.0 self.t = np.zeros((self.steps)) self.x = np.zeros((self.steps, self.pset.dim)) self.xn = np.zeros((self.steps, self.pset.dim)) constf = cf.ConstForce(self.pset.size, u_force=[0, 0, -10.0], dim=self.pset.dim) drag = dr.Drag(self.pset.size, Consts=1.0) multi = mf.MultipleForce(self.pset.size) multi.append_force(constf) multi.append_force(drag) multi.set_masses(self.pset.M) dt = 0.001 self.odes = dict() self.odes["Euler "] = els.EulerSolver(multi, self.pset, dt) self.odes["Runge Kutta"] = rks.RungeKuttaSolver(multi, self.pset, dt) self.odes["Leap Frog "] = lps.LeapfrogSolver(multi, self.pset, dt) self.odes["MidPoint "] = mps.MidpointSolver(multi, self.pset, dt) self.odes["Verlet "] = svs.StormerVerletSolver( multi, self.pset, dt)
def bubble(): """ Pseudo bubble simulation """ ocl_ok = test_pyopencl() if ocl_ok: pcnt = 9000 r_min = 0.5 occx = occ.OpenCLcontext(pcnt, 3) else: pcnt = 700 r_min = 1.5 steps = 1000000 dt = 0.01 rand_c = rc.RandCluster() pset = ps.ParticlesSet(pcnt, dtype=np.float32) rand_c.insert3(X=pset.X, M=pset.M, start_indx=0, n=pset.size, radius=3.0, mass_rng=(0.5, 0.8), r_min=0.0) if ocl_ok: bubble = pb.PseudoBubbleOCL(pset.size, pset.dim, Consts=(r_min, 10)) drag = dr.DragOCL(pset.size, pset.dim, Consts=0.01) else: bubble = pb.PseudoBubble(pset.size, pset.dim, Consts=(r_min, 10)) drag = dr.Drag(pset.size, pset.dim, Consts=0.01) constf = cf.ConstForce(pset.size, dim=pset.dim, u_force=[0, 0, -10.0]) multif = mf.MultipleForce(pset.size, pset.dim) multif.append_force(bubble) multif.append_force(constf) multif.append_force(drag) multif.set_masses(pset.M) #solver = els.EulerSolver( multif , pset , dt ) #solver = lps.LeapfrogSolver( multif , pset , dt ) solver = svs.StormerVerletSolver(multif, pset, dt) #solver = rks.RungeKuttaSolver( lennard_jones , pset , dt ) #solver = mds.MidpointSolver( lennard_jones , pset , dt ) bound = rb.ReboundBoundary(bound=(-5.0, 5.0)) pset.set_boundary(bound) a = aogl.AnimatedGl() a.ode_solver = solver a.pset = pset a.steps = steps if ocl_ok: a.draw_particles.set_draw_model(a.draw_particles.DRAW_MODEL_VECTOR) a.init_rotation(-80, [0.7, 0.05, 0]) a.build_animation() a.start() return
def my_test() : pset = ps.ParticlesSet( 10 ) lo = log.Logger( pset , 10 ) for i in range( 105 ) : pset.X[:] = float(i) lo.log() print( lo.get_particles_log( 3 ) ) exit() t = tr.Transformations() t.set_points_tuple_size(1) t.rotate( np.radians(90) , 1 , 0 , 0 ) #t.rotX( np.radians(90) ) t.append_point( list( [1,0,0] ) ) t.append_point( np.array( [1,1,0] ) ) t.append_point( np.array( [1,1,1] ) ) t.append_point( np.array( [0,1,1] ) ) t.push_matrix() t.identity() t.translation( 10 , 2 , 2 ) #t.rotate( np.radians(20) , 1 , 1 , 1 ) t.append_point( [1,1,1] ) t.append_point( np.matrix( [0,1,1] ).T ) t.pop_matrix() t.append_point( np.array( [1,0,0] ) ) t.append_point( [1,1,0] ) t.append_point( np.array( [1,1,1] ) ) t.append_point( [0,1,1] ) #print( t.transform(pt[0] , pt[1] , pt[2] ) ) print("") for (p) in t : print( p ) exit() n = 10 dt = 0.005 #dt = 0.0023453 steps = 1000000 G = 0.001 #G = 6.67384e-11 FLOOR = -10 CEILING = 10 #ff = fc.FileCluster() #ff.open( options.path_name ) pset = ps.ParticlesSet( n , label=True ) pset.label[8] = "tttt" pset.label[9] = "tzzzttt" pset.add_property_by_name("ciao",dim=1 , model="list") pset.get_by_name("ciao")[3] = 100 pset.get_by_name("X")[3,:] = 101 sz = 15 pset.resize( sz ) tree = ot.OcTree() pset.get_by_name("X")[:] = np.random.rand(sz,3) pset.get_by_name("M")[:] = 1.0 pset.update_centre_of_mass() print(" C O M pset") print( pset.centre_of_mass() ) print("") csrt = ct.ConstrainedX( pset ) cfit = cfi.ConstrainedForceInteractions( pset ) cfit.add_connections( [[12,3],[4,4],[6,8],[1,1]] ) cfit.remove_connections( [[12,3]] ) print( cfit.dense ) print( cfit.sparse ) print( cfit.items ) cc = np.array( [[1,2,3],[3,3,3]] ) cc = np.array( [[1,2,3],[3,3,5]] ) csrt.add_x_constraint( [2,5] , cc ) csrt.add_x_constraint( [7,10] , cc ) print( csrt.get_cx_indicies() ) print( csrt.cX ) csrt.remove_x_constraint( [2,10] ) print( csrt.get_cx_indicies() ) print( csrt.cX ) exit() tree.set_global_boundary() a = time.time() tree.build_tree( pset ) b = time.time() print( "Tot time: % f" %(b-a) ) C = np.array([0.5,0.4,0.3]) R = 0.05 a = time.time() for ix in range( pset.size ): nl = tree.search_neighbour( pset.X[ix,:] , R ) b = time.time() print( "Tot time octree : % f" %(b-a) ) nl = np.sort( nl ) print("") print("nl:") print( nl ) print("") print("dd:") a = time.time() for ix in range( pset.size ): dd = np.sqrt( np.sum( (pset.X[ix,:] - pset.X)**2 , 1 ) ) din, = np.where( dd <= R ) b = time.time() print( "Tot time numpy : % f" %(b-a) ) print( din ) print(" C O M") print( tree.centre_of_mass ) print("") print ( np.all( nl == din ) ) #tree.print_tree() #print( pset.get_by_name( "ciao" ) ) #print( pset.get_by_name( "X" ) ) #print("") #print( pset.X ) #print( pset.label ) exit() return #ff.insert3( pset ) #ff.close() #pset.unit = 149597870700.0 #pset.mass_unit = 5.9736e24 cs = clu.RandCluster() cs.insert3( pset.X , M=pset.M , V=pset.V , n = n/2 , centre=(-1.5,1,0.5) , mass_rng=(0.5,5.0) , vel_rng=(0,0) , vel_mdl="bomb" ) cs.insert3( pset.X , M=pset.M , V=pset.V , start_indx=int(n/2) , n = int(n/2) , centre=(1.5,-0.5,0.5) , vel_rng=(0.2,0.4) , vel_mdl="const" , vel_dir=[-1.0,0.0,0.0] ) # grav = gr.Gravity( pset.size , Consts=G ) #grav = cf.ConstForce(n , u_force=[0,0,-1.0] ) #grav = MyField( pset.size , dim=3 ) #grav = ls.LinearSpring( pset.size , Consts=10e8 ) grav.set_masses( pset.M ) bound = None #bound = pb.PeriodicBoundary( (-50.0 , 50.0) ) #bound = rb.ReboundBoundary( (-10.0 , 10.0) ) pset.set_boundary( bound ) grav.update_force( pset ) solver = els.EulerSolver( grav , pset , dt ) #solver = lps.LeapfrogSolver( grav , pset , dt ) #solver = svs.StormerVerletSolver( grav , pset , dt ) #solver = rks.RungeKuttaSolver( grav , pset , dt ) a = aogl.AnimatedGl() # a = anim.AnimatedScatter() a.xlim = ( FLOOR , CEILING ) a.ylim = ( FLOOR , CEILING ) a.zlim = ( FLOOR , CEILING ) a.ode_solver = solver a.pset = pset a.steps = steps a.build_animation() a.start() return
def __init__(self, force, p_set, dt): super(MidpointSolver, self).__init__(force, p_set, dt) self.__mid_pset = ps.ParticlesSet(p_set.size, p_set.dim)
def springs(): """ Springs demo """ dt = 0.02 steps = 1000000 G = 0.5 pset = ps.ParticlesSet(3, 3, label=True) pset.label[0] = "1" pset.label[1] = "2" pset.label[2] = "3" pset.X[:] = np.array([ [2.0, 4.0, 1.0], # 1 [-2.0, -2.0, 1.0], # 2 [3.0, -3.0, 2.0] # 3 ]) pset.M[:] = np.array([[1.0], [1.0], [1.5]]) pset.V[:] = np.array([[0., 0., 0.], [0., 0, 0.], [0., 0, 0.]]) springs = ls.LinearSpring(pset.size, Consts=G) constf = cf.ConstForce(pset.size, u_force=[0, 0, -1.5]) drag = dr.Drag(pset.size, Consts=0.2) mlf = mf.MultipleForce(pset.size, 3) mlf.append_force(springs) #mlf.append_force( constf ) #mlf.append_force( drag ) pot = epe.ElasticPotentialEnergy(pset, springs) ken = ke.KineticEnergy(pset, springs) tot = te.TotalEnergy(ken, pot) # pot.update_measure() ken.update_measure() tot.update_measure() # #print( "Potential = %f " % pot.value() ) #print( "Kinetic = %f " % ken.value() ) #P = mm.MomentumParticles( pset , subset=np.array([1,2]) , model="part_by_part") # #P.update_measure() # #print( P.value() ) bound = rb.ReboundBoundary(bound=(-10, 10)) pset.set_boundary(bound) mlf.set_masses(pset.M) springs.set_masses(pset.M) springs.update_force(pset) mlf.update_force(pset) #solver = rks.RungeKuttaSolver( springs , pset , dt ) solver = rks.RungeKuttaSolver(mlf, pset, dt) pset.enable_log(True, log_max_size=1000) a = aogl.AnimatedGl() a.trajectory = True a.trajectory_step = 1 a.ode_solver = solver a.pset = pset a.steps = steps a.add_measure(ken) a.add_measure(pot) a.add_measure(tot) a.build_animation() a.start() return
def fountain(): """ Fountain demo """ steps = 10000000 dt = 0.005 pcnt = 100000 fl = True if test_pyopencl(): print("OpenCL is installed and enabled ") print(" Try, at least, 200000 particles ") while fl: try: print(" ") pcnt = int(raw_input('How many particles: ')) except: print("Please insert a number! ") else: fl = False pset = ps.ParticlesSet(pcnt, dtype=np.float32) pset.M[:] = 0.1 pset.X[:, 2] = 0.7 * np.random.rand(pset.size) grav = cf.ConstForce(pset.size, dim=pset.dim, u_force=(0.0, 0.0, -10.0)) occx = None if test_pyopencl(): occx = occ.OpenCLcontext( pset.size, pset.dim, (occ.OCLC_X | occ.OCLC_V | occ.OCLC_A | occ.OCLC_M)) drag = dr.DragOCL(pset.size, dim=pset.dim, Consts=0.01, ocl_context=occx) else: drag = dr.Drag(pset.size, dim=pset.dim, Consts=0.01) multi = mf.MultipleForce(pset.size, dim=pset.dim) multi.append_force(grav) multi.append_force(drag) multi.set_masses(pset.M) #solver = mds.MidpointSolver( multi , pset , dt ) if test_pyopencl(): solver = els.EulerSolverOCL(multi, pset, dt, ocl_context=occx) else: solver = els.EulerSolver(multi, pset, dt) solver.update_force() default_pos.sim_time = solver.get_sim_time() bd = (-100.0, 100.0, -100.0, 100.0, 0.0, 100.0) bound = db.DefaultBoundary(bd, dim=3, defualt_pos=default_pos) pset.set_boundary(bound) a = aogl.AnimatedGl() a.ode_solver = solver a.pset = pset a.steps = steps a.draw_particles.set_draw_model(a.draw_particles.DRAW_MODEL_VECTOR) a.init_rotation(-80, [0.7, 0.05, 0]) a.build_animation() a.start() return
def electromag_field(): """ Electrimagnetic field demo """ steps = 1000000 size = 25000 dt = 1e-4 qe = 1.60217646e-19 me = 9.10938188e-31 mp = 1.67262158e-18 pset = ps.ParticlesSet(size, charge=True) pset.X[:] = 10.0e-3 * ((2.0 * np.random.rand(size, 3) - 1.0)) pset.Q[:] = qe * np.sign(np.random.rand(size, 1) - 0.5) pset.V[:] = 0.5 * ((np.random.rand(size, 3) - 0.5) / 2.0) pset.M[:] = mp elmag = elmf.ElectromagneticField(pset.size, dim=pset.dim, m=pset.M, q=pset.Q) elmag.append_electric_field(electric_field) elmag.append_magnetic_field(magnetic_field) #solver = els.EulerSolver( elmag , pset , dt ) #solver = lps.LeapfrogSolver( elmag , pset , dt ) #solver = svs.StormerVerletSolver( elmag , pset , dt ) #solver = rks.RungeKuttaSolver( elmag , pset , dt ) solver = mds.MidpointSolver(elmag, pset, dt) pset.unit = 2e-3 pset.mass_unit = 1e-3 bound = db.DefaultBoundary((-pset.unit * 5.0, pset.unit * 5.0), dim=3, defualt_pos=default_pos) pset.set_boundary(bound) pset.enable_log(True, log_max_size=200) solver.update_force() a = aogl.AnimatedGl() a.ode_solver = solver a.trajectory = False a.xlim = (-pset.unit * 5.0, pset.unit * 5.0) a.ylim = (-pset.unit * 5.0, pset.unit * 5.0) a.zlim = (-pset.unit * 5.0, pset.unit * 5.0) a.add_vector_field_fun(magnetic_field, 2000.0, pset.unit, color_fun=magf_color) a.add_vector_field_fun(electric_field, 50.0, pset.unit, color_fun=elf_color) a.draw_vector_field = False a.pset = pset a.steps = steps a.draw_particles.color_fun = drp.charged_particles_color a.draw_particles.vect_color_fun = drp.charged_particles_vect_color a.draw_particles.set_draw_model(a.draw_particles.DRAW_MODEL_VECTOR) a.build_animation() a.start() return
def spring_constr(): """ Constrained catenary springs demo """ dt = 0.01 steps = 1000000 K = 60 x = list([]) m = list([]) #v = list([]) d = 0.1 ar = np.arange(-4.0, 4.0 + d, d) for i in ar: x.append(list([i, i, 3.0])) m.append(list([1.0 / float(len(ar))])) #v.append( list([0.0]) ) pset = ps.ParticlesSet(len(ar), 3) pset.X[:] = np.array(x, np.float64) pset.M[:] = np.array(m, np.float64) pset.V[:] = 0.0 pset.X[10:12, 2] = 4 pset.X[15:20, 1] = 4 #pset.X[10:15,1] = 6 ci = np.array([0, len(ar) - 1]) cx = np.array([[-4.0, -4.0, 3.0], [4.0, 4.0, 3.0]]) f_conn = list([]) for i in range(len(ar) - 1): f_conn.append(list([i, i + 1])) f_conn = np.array(f_conn, np.float64) costrs = csx.ConstrainedX(pset) costrs.add_x_constraint(ci, cx) fi = cfi.ConstrainedForceInteractions(pset) fi.add_connections(f_conn) spring = lsc.LinearSpringConstrained(pset.size, pset.dim, pset.M, Consts=K, f_inter=fi) constf = cf.ConstForce(pset.size, dim=pset.dim, u_force=[0, 0, -10]) drag = dr.Drag(pset.size, pset.dim, Consts=0.003) #damp = da.Damping( pset.size , pset.dim , Consts=0.003 ) multif = mf.MultipleForce(pset.size, pset.dim) multif.append_force(spring) multif.append_force(constf) multif.append_force(drag) multif.set_masses(pset.M) solver = els.EulerSolverConstrained(multif, pset, dt, costrs) #solver = lpc.LeapfrogSolverConstrained( multif , pset , dt , costrs ) #solver = svc.StormerVerletSolverConstrained( multif , pset , dt , costrs ) #solver = rkc.RungeKuttaSolverConstrained( multif , pset , dt , costrs ) #solver = mdc.MidpointSolverConstrained( multif , pset , dt , costrs ) a = aogl.AnimatedGl() pset.enable_log(True, log_max_size=1000) a.trajectory = False a.trajectory_step = 1 a.ode_solver = solver a.pset = pset a.steps = steps a.init_rotation(-80, [0.7, 0.05, 0]) a.build_animation() a.start() return
def solar_system(): """ Solar system demo """ dt = 3.0 * 3600.0 steps = 1000000 G = 6.67384e-11 FLOOR = -10 CEILING = 10 pset = ps.ParticlesSet(12, 3, label=True) pset.label[0] = "Sun" pset.label[1] = "Earth" pset.label[2] = "Jupiter" pset.label[3] = "Mars" pset.label[4] = "Mercury" pset.label[5] = "Neptune" pset.label[6] = "Pluto" pset.label[7] = "Saturn" pset.label[8] = "Uranus" pset.label[9] = "Venus" pset.label[10] = "Ceres" pset.label[11] = "Moon" # Coordinates pset.X[:] = np.array([ [0.00000000e+00, 0.00000000e+00, 0.00000000e+00], # Sun [1.49597871e+11, 0.00000000e+00, 0.00000000e+00], # Earth [7.78357721e+11, 0.00000000e+00, 0.00000000e+00], # Jupiter [2.27987155e+11, 0.00000000e+00, 0.00000000e+00], # Mars [5.83431696e+10, 0.00000000e+00, 0.00000000e+00], # Mercury [4.49691199e+12, 0.00000000e+00, 0.00000000e+00], # Neptune [5.91360383e+12, 0.00000000e+00, 0.00000000e+00], # Pluto [1.42701409e+12, 0.00000000e+00, 0.00000000e+00], # Saturn [2.86928716e+12, 0.00000000e+00, 0.00000000e+00], # Uranus [1.04718509e+11, 0.00000000e+00, 0.00000000e+00], # Venus [4.138325875e+11, 0.00000000e+00, 0.00000000e+00], # Ceres [1.499604410e+11, 0.00000000e+00, 0.00000000e+00] # Moon ]) # Mass pset.M[:] = np.array([[1.98910000e+30], [5.98000000e+24], [1.90000000e+27], [6.42000000e+23], [3.30000000e+23], [1.02000000e+26], [1.29000000e+22], [5.69000000e+26], [8.68000000e+25], [4.87000000e+24], [9.43000000e+20], [7.34770000e+22]]) # Speed pset.V[:] = np.array([[0., 0., 0.], [0., 29800., 0.], [0., 13100., 0.], [0., 24100., 0.], [0., 47900., 0.], [0., 5400., 0.], [0., 4700., 0.], [0., 9600., 0.], [0., 6800., 0.], [0., 35000., 0.], [0, 17882., 0.], [0, 30822., 0.]]) # Inclination incl = np.array([ 0.0, 0.0, 1.305, 1.850, 7.005, 1.767975, 17.151, 2.485, 0.772, 3.394, 10.587, 0.0, ]) # Longitude of the ascending node lan = np.array([ 0.0, 348.73936, 100.492, 49.562, 48.331, 131.794310, 110.286, 113.642, 73.989, 76.678, 80.3932, 348.73936 ]) incl[:] = incl * 2.0 * np.pi / 360.0 lan[:] = lan * 2.0 * np.pi / 360.0 pset.V[:, 2] = np.sin(incl) * pset.V[:, 1] pset.V[:, 1] = np.cos(incl) * pset.V[:, 1] for i in range(pset.V.shape[0]): x = pset.V[i, 0] y = pset.V[i, 1] pset.V[i, 0] = x * np.cos(lan[i]) - y * np.sin(lan[i]) pset.V[i, 1] = x * np.sin(lan[i]) + y * np.cos(lan[i]) for i in range(pset.X.shape[0]): x = pset.X[i, 0] y = pset.X[i, 1] pset.X[i, 0] = x * np.cos(lan[i]) - y * np.sin(lan[i]) pset.X[i, 1] = x * np.sin(lan[i]) + y * np.cos(lan[i]) #outf = fc.FileCluster() #outf.open( "solar_system.csv" , "wb" ) #outf.write_out( pset ) pset.unit = 149597870700.0 pset.mass_unit = 5.9736e24 grav = gr.Gravity(pset.size, Consts=G) grav.set_masses(pset.M) bound = None pset.set_boundary(bound) pset.enable_log(True, log_max_size=1000) grav.update_force(pset) #solver = els.EulerSolver( grav , pset , dt ) #solver = lps.LeapfrogSolver( grav , pset , dt ) #solver = svs.StormerVerletSolver( grav , pset , dt ) #solver = rks.RungeKuttaSolver( grav , pset , dt ) solver = mds.MidpointSolver(grav, pset, dt) ken = ke.KineticEnergy(pset, grav) ken.set_str_format("%e") # ken.update_measure() a = aogl.AnimatedGl() # a = anim.AnimatedScatter() a.trajectory = True a.trajectory_step = 1 a.xlim = (FLOOR, CEILING) a.ylim = (FLOOR, CEILING) a.zlim = (FLOOR, CEILING) a.ode_solver = solver a.pset = pset a.steps = steps a.add_measure(ken) a.build_animation() a.start() return
def get_particle_set(self): """ Build and return a set of particles (class: particles_set) """ print("") self.pset = ps.ParticlesSet() if self.media_origin == "from_file": ff = fc.FileCluster() ff.open(self.pset_file_name) ff.insert3(self.pset) ff.close() print(" setup - particles set - file name: %s " % self.pset_file_name) elif self.media_origin == "rand": self.pset.realloc(self.rand_part_nr, dim=3) self.__get_rand_clusters() else: print( " !! Error - particles set - media origin: %s don't exist " % self.media_origin) print(" setup - particles set - size: %d " % self.pset.size) print(" setup - particles set - dim: %d " % self.pset.dim) self.pset.unit = self.len_unit self.pset.mass_unit = self.mass_unit print(" setup - particles set - len unit: %e " % self.pset.unit) print(" setup - particles set - len mass unit: %e " % self.pset.mass_unit) if self.boudary == "open": self.pset.boundary = None print(" setup - particles set - Boundary: open ") elif self.boudary == "periodic": bound = read_str_list(self.boudary_lim) self.pset.boundary = pb.PeriodicBoundary(bound=bound, dim=self.pset.dim) print(" setup - particles set - Boundary: periodic ") print(" setup - particles set - Boundary size : %s " % (bound, )) elif self.boudary == "rebound": bound = read_str_list(self.boudary_lim) self.pset.boundary = rb.ReboundBoundary(bound=bound, dim=self.pset.dim) print(" setup - particles set - Boundary: rebound ") print(" setup - particles set - Boundary size : %s " % (bound, )) if self.sim_log > 0: self.pset.enable_log(log_X=self.sim_log_X, log_V=self.sim_log_V, log_max_size=self.sim_log) print(" setup - particles set - Simulation log size %d " % self.sim_log) print( " setup - particles set - Simulation log : X = %r ; V = %r " % (self.sim_log_X, self.sim_log_V)) #print( self.pset.X ) #print( self.pset.M ) #print( self.pset.V ) return self.pset
def insert3(self, X, M, V, G, start_indx=0, n=-1, centre=(0.0, 0.0, 0.0), radius=1.0, mass_rng=(0.7, 1), std=(3.0, 0.6, 0.2), black_hole_mass=5000.0): if n <= 0: n = X.shape[0] - start_indx si = int(start_indx) ei = int(start_indx + n) rng = slice(si, ei) std_x = std[0] std_y = std[1] std_z = std[2] X[rng, 0] = radius * np.random.normal(0.0, std_x, n) X[rng, 1] = radius * np.random.normal(0.0, std_y, n) X[rng, 2] = radius * np.random.normal(0.0, std_z, n) X[si, :] = np.array([0.0, 0.0, 0.0]) if M is not None: M[rng] = mass_rng[0] + np.random.rand( n, 1) * (mass_rng[1] - mass_rng[0]) M[si] = black_hole_mass c = np.cross(X, np.array([0, 0, 1])) c = (c.T / np.sqrt(np.sum(c**2, 1))).T c[si, :] = np.array([0.0, 0.0, 0.0]) pset = ps.ParticlesSet(n) pset.X[:] = X[rng, :] pset.M[:] = M[rng] grav = gr.Gravity(n, Consts=G) grav.set_masses(pset.M) grav.update_force(pset) f = np.sqrt(np.sum(grav.F**2, 1)) r = np.sqrt(np.sum(pset.X**2, 1)) v = np.sqrt(f * r / pset.M[:, 0]) V[rng, :] = (v * c.T).T / 1.3 X[rng, :] = X[rng, :] + np.array(centre)
def electro(): """ Electrostatic demo """ steps = 1000000 dt = 0.01 r_min = 1.5 Ke = 8.9875517873681764e9 qe = 1.60217646e-19 * 1.0e8 me = 9.10938188e-31 mp = 1.67262158e-18 rand_c = rc.RandCluster() pset = ps.ParticlesSet(10, charge=True) pset.Q[:5] = qe pset.Q[5:10] = -qe pset.M[:] = 1e-3 pset.V[:] = 0.0 pset.X[:] = 1.0e-3 * np.array( [[0.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 0.0, -1.0], [0.0, 1.0, 1.0], [-1.0, -1.0, -1.0], [2.0, -2.0, 4.0], [4.0, 7.0, 2.0], [-3.0, -5.0, 1.0], [4.0, 4.0, -7.0], [2.0, 8.0, -6.0]]) #rand_c.insert3( X=pset.X , # M=pset.M , # start_indx=0 , # n=pset.size , # radius=5.0 , # mass_rng=(0.5,0.8) , # r_min=0.0 ) elecs = esf.Electrostatic(pset.size, dim=3, Consts=Ke) elecs.set_masses(pset.M) elecs.set_charges(pset.Q) #solver = els.EulerSolver( multif , pset , dt ) #solver = lps.LeapfrogSolver( lennard_jones , pset , dt ) #solver = svs.StormerVerletSolver( multif , pset , dt ) solver = rks.RungeKuttaSolver(elecs, pset, dt) #solver = mds.MidpointSolver( lennard_jones , pset , dt ) bound = rb.ReboundBoundary(bound=(-10.0e-3, 10.0e-3)) pset.set_boundary(bound) pset.unit = 2e-3 pset.mass_unit = 1e-3 pset.enable_log(True, log_max_size=1000) solver.update_force() a = aogl.AnimatedGl() a.ode_solver = solver a.trajectory = True a.pset = pset a.steps = steps a.draw_particles.color_fun = drp.charged_particles_color a.build_animation() a.start() return