PyParticles3 0.4.0__py3-none-any.whl

pyparticles/demo/solar_system.py

@@ -0,0 +1,222 @@
+# PyParticles : Particles simulation in python
+# Copyright (C) 2012  Simone Riva
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import numpy as np
+
+import pyparticles.pset.particles_set as ps
+
+import pyparticles.forces.gravity as gr
+
+import pyparticles.ode.euler_solver as els
+import pyparticles.ode.leapfrog_solver as lps
+import pyparticles.ode.runge_kutta_solver as rks
+import pyparticles.ode.stormer_verlet_solver as svs
+import pyparticles.ode.midpoint_solver as mds
+
+import pyparticles.measures.kinetic_energy as ke
+import pyparticles.measures.total_energy as te
+
+import pyparticles.animation.animated_ogl as aogl
+
+
+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 

pyparticles/demo/springs.py

@@ -0,0 +1,141 @@
+# PyParticles : Particles simulation in python
+# Copyright (C) 2012  Simone Riva
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import numpy as np
+
+import pyparticles.pset.particles_set as ps
+
+import pyparticles.forces.linear_spring as ls
+import pyparticles.forces.const_force as cf
+import pyparticles.forces.multiple_force as mf
+import pyparticles.forces.drag as dr 
+
+import pyparticles.pset.rebound_boundary as rb
+
+import pyparticles.measures.elastic_potential_energy as epe
+import pyparticles.measures.kinetic_energy as ke
+import pyparticles.measures.momentum as mm
+import pyparticles.measures.total_energy as te
+
+
+
+import pyparticles.ode.euler_solver as els
+import pyparticles.ode.leapfrog_solver as lps
+import pyparticles.ode.runge_kutta_solver as rks
+import pyparticles.ode.stormer_verlet_solver as svs
+import pyparticles.ode.midpoint_solver as mds
+
+import sys
+
+import pyparticles.animation.animated_ogl as aogl
+
+
+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 

pyparticles/demo/springs_constr.py

@@ -0,0 +1,135 @@
+# PyParticles : Particles simulation in python
+# Copyright (C) 2012  Simone Riva
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import numpy as np
+
+import pyparticles.pset.particles_set as ps
+
+import pyparticles.forces.linear_spring_constrained as lsc
+
+import pyparticles.forces.const_force as cf
+import pyparticles.forces.multiple_force as mf
+import pyparticles.forces.drag as dr
+import pyparticles.forces.damping as da
+
+import pyparticles.pset.constrained_x as csx
+import pyparticles.pset.constrained_force_interactions as cfi
+
+
+import pyparticles.measures.elastic_potential_energy as epe
+import pyparticles.measures.kinetic_energy as ke
+import pyparticles.measures.momentum as mm
+import pyparticles.measures.total_energy as te
+
+import pyparticles.animation.animated_ogl as aogl
+
+import pyparticles.ode.euler_solver_constrained as asc
+import pyparticles.ode.leapfrog_solver_constrained as lpc
+import pyparticles.ode.stormer_verlet_solver_constrained as svc
+import pyparticles.ode.runge_kutta_solver_constrained as rkc
+import pyparticles.ode.midpoint_solver_constrained as mdc
+
+
+def spring_constr():
+    """
+    Constrained catenary springs demo
+    """
+    
+    dt = 0.01
+    steps = 1000000
+    
+    K = 30
+
+    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[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 = asc.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

pyparticles/demo/test.py

@@ -0,0 +1,34 @@
+# PyParticles : Particles simulation in python
+# Copyright (C) 2012  Simone Riva
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import pyparticles.animation.test_animation as tt
+
+def test( ty ):
+    """
+    testing procedures
+    
+    ty: test name
+    """
+    if ty == "fall":
+        tst = tt.TestAnimation()
+    elif ty == "harmonic" :
+        tst = tt.TestAnimationHarmonic()
+    elif ty == "dharmonic" :
+        tst = tt.TestAnimationDampedHarmonic()
+        
+    tst.build_animation()
+    tst.start()

pyparticles/forces/__init__.py

@@ -0,0 +1,21 @@
+# PyParticles : Particles simulation in python
+#Copyright (C) 2012  Simone Riva
+#
+#This program is free software: you can redistribute it and/or modify
+#it under the terms of the GNU General Public License as published by
+#the Free Software Foundation, either version 3 of the License, or
+#(at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import os
+import glob
+
+__all__ = [ os.path.splitext( os.path.basename(f) )[0] for f in glob.glob(os.path.dirname(os.path.abspath(__file__))+"/*.py")]

pyparticles/forces/const_force.py

@@ -0,0 +1,140 @@
+# PyParticles : Particles simulation in python
+# Copyright (C) 2012  Simone Riva
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+import numpy as np
+
+import pyparticles.forces.force as fr
+import pyparticles.pset.opencl_context as occ
+
+try:
+    import pyopencl as cl
+except ImportError:
+    cl = None
+
+
+class ConstForce(fr.Force):
+    """Constant acceleration field."""
+
+    def __init__(self, size, dim=3, m=None, u_force=(0, 0, 0), Consts=1.0):
+        self.__dim = int(dim)
+        self.__size = int(size)
+        self.__G = Consts
+        self.__UF = np.asarray(u_force, dtype=float)
+        self.__A = np.zeros((size, dim))
+        self.__M = np.zeros((size, 1))
+        self.__A[:] = self.__UF
+
+        if m is not None:
+            self.set_masses(m)
+
+    def set_masses(self, m):
+        self.__M[:] = m
+
+    def update_force(self, p_set):
+        return self.__A
+
+    def getA(self):
+        return self.__A
+
+    A = property(getA)
+
+    def getF(self):
+        return self.__A * self.__M
+
+    F = property(getF)
+
+
+class ConstForceOCL(fr.Force):
+    """Constant acceleration field accumulated directly in an OpenCL A buffer."""
+
+    def __init__(self, size, dim=3, m=None, u_force=(0, 0, 0), Consts=1.0, ocl_context=None):
+        if cl is None:
+            raise RuntimeError("PyOpenCL is required for ConstForceOCL")
+        if int(dim) != 3:
+            raise ValueError("ConstForceOCL currently supports only 3 dimensions")
+
+        self.__size = int(size)
+        self.__dim = int(dim)
+        self.__occ = ocl_context or occ.OpenCLcontext(size, dim, occ.OCLC_A | occ.OCLC_M)
+        self.__dtype = self.__occ.dtype
+        self.__UF = np.asarray(u_force, dtype=self.__dtype).reshape(3)
+        self.__A = np.zeros((size, dim), dtype=self.__dtype)
+        self.__M = np.zeros((size, 1), dtype=self.__dtype)
+
+        source = r"""
+        __kernel void const_force(
+            float ax,
+            float ay,
+            float az,
+            int accumulate,
+            __global float *A)
+        {
+            int i = get_global_id(0);
+            int i0 = 3*i;
+            int i1 = i0 + 1;
+            int i2 = i0 + 2;
+
+            if (accumulate)
+            {
+                A[i0] += ax;
+                A[i1] += ay;
+                A[i2] += az;
+            }
+            else
+            {
+                A[i0] = ax;
+                A[i1] = ay;
+                A[i2] = az;
+            }
+        }
+        """
+        self.__program = cl.Program(self.__occ.CL_context, source).build()
+        self.__kernel = cl.Kernel(self.__program, "const_force")
+
+        if m is not None:
+            self.set_masses(m)
+
+    def set_masses(self, m):
+        self.__M[:] = np.asarray(m, dtype=self.__dtype)
+        if self.__occ.M_cla is not None:
+            self.__occ.set_from_host("M", self.__M)
+
+    def update_force_device(self, p_set=None, accumulate=False, host_authoritative=False):
+        self.__kernel(
+            self.__occ.CL_queue,
+            (self.__size,),
+            None,
+            self.__dtype(self.__UF[0]),
+            self.__dtype(self.__UF[1]),
+            self.__dtype(self.__UF[2]),
+            np.int32(bool(accumulate)),
+            self.__occ.A_cla.data,
+        )
+        self.__occ.mark_device_modified("A")
+        return self.__occ.A_cla
+
+    def update_force(self, p_set):
+        self.update_force_device(p_set, accumulate=False)
+        self.__occ.sync_to_host("A", self.__A)
+        return self.__A
+
+    def getA(self):
+        return self.__A
+
+    A = property(getA)
+
+    def getF(self):
+        self.__occ.sync_to_host("A", self.__A)
+        return self.__A * self.__M
+
+    F = property(getF)
+
+    def get_ocl_context(self):
+        return self.__occ
+
+    ocl_context = property(get_ocl_context)