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
