PyParticles3 0.4.0rc1__py3-none-any.whl

pyparticles/forces/damping.py

@@ -0,0 +1,174 @@
+# 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.forces.force as fr
+
+import pyparticles.pset.opencl_context as occ 
+
+try:
+    import pyopencl as cl
+    import pyopencl.array as cla
+except:
+    ___foo = 0
+
+
+class Damping( fr.Force ) :
+    r"""
+    Compute the damping forces, the damping is a force that react proportionally to the velocity
+    
+    The force is given the equation:
+    
+    .. math::
+    
+        F_i = -C\dot{X}
+        
+    Constructor
+         
+    :param    size:        the number of particles in the system
+    :param    dim:         the dimension of the system
+    :param    m:           a vector containig the masses
+    :param    Const:       the damping factor
+    """
+    def __init__(self , size , dim=3 , m=None , Consts=1.0 ):
+        
+        self.__dim = dim
+        self.__size = size
+        
+        self.__C = np.zeros( ( size , 1 ) )
+        self.__C[:] = Consts
+        
+        self.__A = np.zeros( ( size , dim ) )
+        self.__F = np.zeros( ( size , dim ) )
+                
+        self.__M = np.zeros( ( size , 1 ) )
+        if m != None :
+            self.set_masses( m )
+        
+        
+    
+    def set_masses( self , m ):
+        self.__M[:] = m
+    
+    
+    def update_force( self , pset ):
+        
+        self.__F[:] =  -pset.V[:] * self.__C[:]
+        self.__A = self.__F[:] / self.__M
+        
+        return self.__A
+    
+
+    def getA(self):
+        return self.__A
+    
+    A = property( getA )
+
+
+    def getF(self):
+        return self.__A * self.__M[:,0]
+    
+    F = property( getF )
+    
+    
+class DampingOCL( fr.Force ) :
+    r"""
+    Compute the damping forces, the damping is a force that react proportionally to the velocity
+    
+    The force is given the equation:
+    
+    .. math::
+    
+        F_i = -C\dot{X}
+        
+    Constructor
+         
+    :param    size:        the number of particles in the system
+    :param    dim:         the dimension of the system
+    :param    m:           a vector containig the masses
+    :param    Const:       the damping factor
+    """
+    def __init__(self , size , dim=3 , m=None , Consts=1.0 , ocl_context=None ):
+        
+        self.__dim = np.int( dim )
+        self.__size = np.int( size )
+        
+        if ocl_context == None :
+            self.__occ = occ.OpenCLcontext( size , dim , ( occ.OCLC_V | occ.OCLC_A | occ.OCLC_M )  )
+        else :
+            self.__occ = ocl_context        
+        
+        self.__dtype = self.__occ.dtype
+        
+        self.__K = self.__occ.dtype( Consts )
+        
+        self.__A = np.zeros( ( size , dim ) , dtype=self.__occ.dtype )
+        self.__F = np.zeros( ( size , dim ) , dtype=self.__occ.dtype )
+                        
+        if m != None :
+            self.set_masses( m )
+        
+        self.__init_prog_cl()
+        
+     
+    def __init_prog_cl(self):
+        self.__damping_prg = """
+        __kernel void damping(__global const float *V , 
+                              __global const float *M ,
+                                             float  K , 
+                              __global       float *A )
+        {
+            int i = get_global_id(0) ;
+                        
+            A[3*i]   = ( K * V[3*i]   )  / M[i] ;
+            A[3*i+1] = ( K * V[3*i+1] )  / M[i] ;
+            A[3*i+2] = ( K * V[3*i+2] )  / M[i] ;
+        }
+        """
+        
+        self.__cl_program = cl.Program( self.__occ.CL_context , self.__damping_prg ).build()
+        
+    
+    def set_masses( self , m ):
+        self.__occ.M_cla.set( self.__dtype( m ) , queue=self.__occ.CL_queue )
+    
+    
+    def update_force( self , pset ):
+        
+        self.__occ.V_cla.set( self.__dtype( pset.V ) , queue=self.__occ.CL_queue )
+        
+        self.__cl_program.damping( self.__occ.CL_queue , ( self.__size , ) , None , 
+                                   self.__occ.V_cla.data ,
+                                   self.__occ.M_cla.data , 
+                                   self.__K , 
+                                   self.__occ.A_cla.data )
+    
+        self.__occ.A_cla.get( self.__occ.CL_queue , self.__A )
+        
+        return self.__A
+    
+
+    def getA(self):
+        return self.__A
+    
+    A = property( getA )
+
+
+    def getF(self):
+        return self.__A * self.__M[:,0]
+    
+    F = property( getF )

pyparticles/forces/drag.py

@@ -0,0 +1,167 @@
+# 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 Drag(fr.Force):
+    """Quadratic drag force."""
+
+    def __init__(self, size, dim=3, m=None, Consts=1.0):
+        self.__dim = int(dim)
+        self.__size = int(size)
+        self.__G = np.zeros((size, 1))
+        self.__G[:] = Consts
+        self.__A = np.zeros((size, dim))
+        self.__F = np.zeros((size, dim))
+        self.__V = np.zeros((size, 1))
+        self.__M = np.zeros((size, 1))
+
+        if m is not None:
+            self.set_masses(m)
+
+    def set_masses(self, m):
+        self.__M[:] = m
+
+    def update_force(self, pset):
+        self.__V[:, 0] = np.sqrt(np.sum(pset.V**2, axis=1))
+        self.__F[:] = -0.5 * self.__V * pset.V * self.__G
+        self.__A[:] = self.__F / self.__M
+        return self.__A
+
+    def getA(self):
+        return self.__A
+
+    A = property(getA)
+
+    def getF(self):
+        return self.__A * self.__M
+
+    F = property(getF)
+
+
+class DragOCL(fr.Force):
+    """OpenCL implementation of 3-D quadratic drag."""
+
+    def __init__(self, size, dim=3, m=None, Consts=1.0, ocl_context=None):
+        if cl is None:
+            raise RuntimeError("PyOpenCL is required for DragOCL")
+        if int(dim) != 3:
+            raise ValueError("DragOCL currently supports only 3 dimensions")
+
+        self.__dim = int(dim)
+        self.__size = int(size)
+
+        if ocl_context is None:
+            self.__occ = occ.OpenCLcontext(
+                size,
+                dim,
+                occ.OCLC_V | occ.OCLC_A | occ.OCLC_M,
+            )
+        else:
+            self.__occ = ocl_context
+
+        self.__dtype = self.__occ.dtype
+        self.__K = self.__dtype(Consts)
+        self.__A = np.zeros((size, dim), dtype=self.__dtype)
+        self.__M = np.zeros((size, 1), dtype=self.__dtype)
+
+        self.__init_prog_cl()
+        if m is not None:
+            self.set_masses(m)
+
+    def __init_prog_cl(self):
+        source = r"""
+        __kernel void drag(
+            __global const float *V,
+            __global const float *M,
+                           float  K,
+                             int  accumulate,
+            __global       float *A)
+        {
+            int i = get_global_id(0);
+            int i0 = 3*i;
+            int i1 = i0 + 1;
+            int i2 = i0 + 2;
+
+            float speed = sqrt(
+                V[i0]*V[i0] + V[i1]*V[i1] + V[i2]*V[i2]
+            );
+
+            float ax = (-0.5f * K * speed * V[i0]) / M[i];
+            float ay = (-0.5f * K * speed * V[i1]) / M[i];
+            float az = (-0.5f * K * speed * V[i2]) / M[i];
+
+            if (accumulate)
+            {
+                A[i0] += ax;
+                A[i1] += ay;
+                A[i2] += az;
+            }
+            else
+            {
+                A[i0] = ax;
+                A[i1] = ay;
+                A[i2] = az;
+            }
+        }
+        """
+        self.__cl_program = cl.Program(self.__occ.CL_context, source).build()
+        self.__drag_kernel = cl.Kernel(self.__cl_program, "drag")
+
+    def set_masses(self, m):
+        self.__M[:] = np.asarray(m, dtype=self.__dtype)
+        self.__occ.set_from_host("M", self.__M)
+
+    def update_force_device(self, pset, accumulate=False, host_authoritative=False):
+        if host_authoritative:
+            self.__occ.mark_host_modified("V")
+        self.__occ.sync_to_device("V", pset.V)
+
+        self.__drag_kernel(
+            self.__occ.CL_queue,
+            (self.__size,),
+            None,
+            self.__occ.V_cla.data,
+            self.__occ.M_cla.data,
+            self.__K,
+            np.int32(bool(accumulate)),
+            self.__occ.A_cla.data,
+        )
+        self.__occ.mark_device_modified("A")
+        return self.__occ.A_cla
+
+    def update_force(self, pset):
+        self.update_force_device(pset, accumulate=False, host_authoritative=True)
+        self.__occ.sync_to_host("A", self.__A)
+        return self.__A
+
+    def getA(self):
+        return self.__A
+
+    A = property(getA)
+
+    def getF(self):
+        # Keep the legacy host property useful even after a device-only update.
+        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)

pyparticles/forces/electromagnetic.py

@@ -0,0 +1,105 @@
+# 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 scipy.spatial.distance as dist
+
+import pyparticles.forces.force as fr
+
+class Electromagnetic( fr.Force ) :
+    r"""
+    Compute the electromagnetic force of a self-interacting particles system according to the Lorenz formulation.
+    
+    
+    
+    Not yet tested.
+    """
+    def __init__( self , size , dim=3 , m=None , Consts=1.0 ):
+        
+        self.__dim = dim
+        self.__size = size
+        
+        self.__Ke = Consts[0]
+        self.__Km = Consts[1]
+
+        self.__Am = np.zeros( ( size , dim ) )
+        self.__Ae = np.zeros( ( size , dim ) )
+        
+        self.__Fe = np.zeros( ( size , size ) )
+        self.__Fm = np.zeros( ( size , size ) )
+        
+        self.__V = np.zeros( ( size , size ) )
+        self.__D = np.zeros( ( size , size ) )
+        self.__Q = np.zeros( ( size , size ) )
+        self.__M = np.zeros( ( size , 1 ) )
+        
+        self.__r = np.zeros( ( size , dim ) )
+        
+        self.__Cr = np.zeros( ( size , dim ) )
+        
+        if m != None :
+            self.set_masses( m )
+          
+    def set_masses( self , m ):
+        self.__M[:] = m
+        
+    def set_charges( self , q ):
+        self.__Q[:,:] = q
+        self.__Q[:,:] = self.__Q * self.__Q.T
+    
+    def update_force( self , p_set ):        
+        self.__D[:] = dist.squareform( dist.pdist( p_set.X , 'euclidean' ) )
+        
+        self.__Fe[:] = self.__Ke * self.__Q[:] / ( ( self.__D[:] ) ** 3.0 )
+        self.__Fm[:] = self.__Km * self.__Q[:] / ( ( self.__D[:] ) ** 2.0 )
+
+        np.fill_diagonal( self.__Fe , 0.0 )
+        np.fill_diagonal( self.__Fm , 0.0 )
+                
+        for i in range( self.__dim ):
+            self.__V[:,:] = p_set.X[:,i]
+            self.__V[:,:] = ( self.__V[:,:].T - p_set.X[:,i] ).T 
+                        
+            self.__Ae[:,i] = np.sum( self.__Fe * self.__V[:,:] , 0 ) 
+        
+        r = self.__r
+        for j in range( self.__size ) :
+            r[:] = p_set.X[j,:] - p_set.X[:]
+            
+            r[:] = (r.T / np.sqrt( np.sum(r**2,1))).T
+            r[j,:] = 0.0
+            
+            r[:] = np.cross( p_set.V[:] , r[:] )
+            r[:] = np.cross( p_set.V[j,:] , r[:] )
+            
+            self.__Am[j,:] = np.sum( self.__Fm[:,j].T * r[:] , 0 ).T / self.__M[j]
+            
+            
+        #print( self.__X )
+        self.__A[:] = self.__Ae + self.__Am
+        
+        return self.__A
+    
+    def getA(self):
+        return self.__A
+    
+    A = property( getA )
+
+
+    def getF(self):
+        return self.__A * self.__M
+    
+    F = property( getF )

pyparticles/forces/electromagnetic_field.py

@@ -0,0 +1,95 @@
+# 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 random
+
+import numpy as np
+
+import pyparticles.forces.force as fr
+
+
+class ElectromagneticField(fr.Force):
+    r"""
+    Electromagnetic force for non-self-interacting charged particles.
+
+    .. math::
+
+        \mathbf{F} = q(\mathbf{E} + \mathbf{v} \times \mathbf{B})
+    """
+
+    def __init__(self, size, dim=3, m=None, q=None, Consts=1.0):
+        self.__dim = dim
+        self.__size = size
+
+        self.__A = np.zeros((size, dim))
+        self.__E = np.zeros((size, dim))
+        self.__B = np.zeros((size, dim))
+        self.__Fe = np.zeros((size, dim))
+        self.__Fm = np.zeros((size, dim))
+        self.__M = np.zeros((size, 1))
+        self.__Q = np.zeros((size, 1))
+
+        if m is not None:
+            self.set_masses(m)
+        if q is not None:
+            self.set_charges(q)
+
+        self.__el_fields = {}
+        self.__ma_fields = {}
+
+    def set_masses(self, m):
+        self.__M[:] = m
+
+    def set_charges(self, q):
+        self.__Q[:] = q
+
+    def append_electric_field(self, ef, key=None):
+        if key is None:
+            key = str(random.randint(0, 2**64))
+        self.__el_fields[key] = ef
+        return key
+
+    def append_magnetic_field(self, bf, key=None):
+        if key is None:
+            key = str(random.randint(0, 2**64))
+        self.__ma_fields[key] = bf
+        return key
+
+    def update_force(self, pset):
+        self.__Fe[:] = 0.0
+        self.__Fm[:] = 0.0
+
+        for field in self.__el_fields.values():
+            field(self.__E, pset.X)
+            self.__Fe += self.__Q * self.__E
+
+        for field in self.__ma_fields.values():
+            field(self.__B, pset.X)
+            self.__Fm += self.__Q * np.cross(pset.V, self.__B)
+
+        self.__Fe += self.__Fm
+        self.__A[:] = self.__Fe / self.__M
+        return self.__A
+
+    def getA(self):
+        return self.__A
+
+    A = property(getA)
+
+    def getF(self):
+        return self.__Fe
+
+    F = property(getF)

pyparticles/forces/electrostatic.py

@@ -0,0 +1,72 @@
+# 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 scipy.spatial.distance as dist
+
+import pyparticles.forces.force as fr
+
+
+class Electrostatic(fr.Force):
+    r"""Compute electrostatic force using Coulomb's law."""
+
+    def __init__(self, size, dim=3, m=None, q=None, Consts=1.0):
+        self.__dim = dim
+        self.__size = size
+        self.__K = Consts
+        self.__A = np.zeros((size, dim))
+        self.__Fm = np.zeros((size, size))
+        self.__V = np.zeros((size, size))
+        self.__D = np.zeros((size, size))
+        self.__Q = np.zeros((size, size))
+        self.__M = np.zeros((size, 1))
+
+        if m is not None:
+            self.set_masses(m)
+        if q is not None:
+            self.set_charges(q)
+
+    def set_masses(self, m):
+        self.__M[:] = m
+
+    def set_charges(self, q):
+        q = np.asarray(q).reshape(self.__size, 1)
+        self.__Q[:] = q * q.T
+
+    def update_force(self, p_set):
+        self.__D[:] = dist.squareform(dist.pdist(p_set.X, "euclidean"))
+
+        with np.errstate(divide="ignore", invalid="ignore"):
+            self.__Fm[:] = self.__K * self.__Q / self.__D**3.0
+        np.fill_diagonal(self.__Fm, 0.0)
+
+        for i in range(self.__dim):
+            self.__V[:, :] = p_set.X[:, i]
+            self.__V[:, :] = (self.__V.T - p_set.X[:, i]).T
+            force_component = np.sum(self.__Fm * self.__V, axis=0)
+            self.__A[:, i] = force_component / self.__M[:, 0]
+
+        return self.__A
+
+    def getA(self):
+        return self.__A
+
+    A = property(getA)
+
+    def getF(self):
+        return self.__A * self.__M
+
+    F = property(getF)

pyparticles/forces/force.py

@@ -0,0 +1,75 @@
+# 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 sys
+
+class Force(object):
+    """
+    The main abstract class used as interface for the forces classes
+
+    Constructor
+
+    :param        size:        the number of particles in the system
+    :param        dim:         the dimension of the system (3D, 2D..)
+    :param        m:           a vector containig the masses
+    :param        Const:       the force constants (Like G, K ...)
+    """
+
+    def __init__(self , size , dim , m=None , Conts=1.0 ):
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+
+    def set_masses( self , m ):
+        """
+        Set the masses used for computing the forces.
+
+        :param    m:         An array containig the masses
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+
+    def update_force( self , p_set ):
+        """
+        Computes the forces of the current status ad return the accelerations of the particles
+    
+        :param    p_set:     Particles set obj.
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+
+    def getA(self):
+        """
+        return the array of the acclerations
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+
+    A = property( getA , doc="(property) return the array of the acclerations")
+
+    def getF(self):
+        """
+        returns the array of the forces
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+
+    F = property( getF , doc="(property) returns the array of the forces" )
+
+
+    def get_const( self ):
+        """
+        returns the force contants
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )        
+
+    const = property( get_const , doc="(property) returns the force contants")
+
+