PyParticles3 0.4.0__py3-none-any.whl

pyparticles/ogl/trackball.py

@@ -0,0 +1,131 @@
+# 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
+
+class TrackBall( object ):
+    """
+    Class used for controlling the rotation of the scene via mouse or joystick, by generating the virtual trackball effect
+    
+    Constructor
+        
+        ========== =========================
+        Arguments
+        ========== =========================
+        w_size     size of the window
+        ========== =========================
+        
+        Example:
+            Event On click: ::
+            
+                ( x , y ) = get_click_coords_on_window()
+                trk.track_ball_mapping( [ x , y ] )
+                
+            Event On Move: ::
+                
+                ( x , y ) = get_current_coords_on_window()
+                ( rot_axis , rot_angle ) = trk.on_move( [ x , y ] )
+                glRotatef( rot_angle , rot_axis[0] , rot_axis[1] , rot_axis[2] )
+    """
+    def __init__( self , w_size ):
+        
+        self.__v     = np.array( [ 0.0 , 0.0 , 0.0 ] )
+        self.__v_old = np.array( [ 0.0 , 0.0 , 0.0 ] )
+        
+        self.__win_size = ( 800 , 600 )
+        
+        self.__win_width = 800
+        self.__win_height = 600
+        
+        self.win_size = w_size
+    
+    def get_V( self ):
+        return self.__v 
+    
+    def set_V( self , v ):
+        self.__v = v
+        
+    V = property( get_V , set_V )
+    
+        
+    def get_win_size( self ):
+        return ( self.__win_width , self.__win_height )
+    
+    def set_win_size( self , w_size ):
+        self.__win_width  = w_size[0]
+        self.__win_height = w_size[1]
+        
+    win_size = property( get_win_size , set_win_size )
+    
+        
+    def track_ball_mapping( self , point ):
+        """
+        Function to be called after a click on the mouse or at beginnig of the rotation, it takes the current coordinates of the pointer.
+        """
+        self.__v_old[:] = self.__v[:]
+        
+        self.__v[0] = ( 2.0 * point[0]   - self.win_size[0] ) / self.win_size[0]
+        self.__v[1] = ( self.win_size[1] - 2.0 * point[1] )   / self.win_size[1]
+        
+        self.__v[2] = 0.0
+        
+        d = np.linalg.norm( self.__v )
+        
+        if d > 1.0 :
+            self.__v[:] = self.__v[:] / d
+        
+        tb_radius = 4.0
+        
+        self.__v[:] = self.__v[:] * tb_radius * 0.999
+        
+        self.__v[2] = np.sqrt( tb_radius**2 - self.__v[0]**2 - self.__v[1]**2 )
+        
+        self.__v[:] = self.__v / np.linalg.norm( self.__v )
+        
+        
+    def on_move( self , point ):
+        """
+        function to be called when the mouse is moved. argument requires the coordinates of the mouse pointer and it returns the axis of rotation and angle.
+        """
+        
+        self.track_ball_mapping( point )
+        
+        direction = self.__v - self.__v_old
+        
+        velocity = np.linalg.norm( direction )
+        
+        rot_axis = np.cross( self.__v_old , self.__v )
+        rot_angle = velocity * 400.0
+        
+        rot_axis = rot_axis / np.linalg.norm( rot_axis ) 
+        
+        return ( rot_axis , rot_angle )
+   
+    
+    def on_joystick( self , jaxes ):
+        """
+        Given the axes ( x and y ) of the joystick; it returns the axis and the angle of rotation.
+            Example: ::
+            
+                ( rot_axis , rot_angle ) = trk.on_joystick( [ x , y ] )
+        """
+        ws = self.win_size
+        
+        jd = 400
+        
+        self.track_ball_mapping( ( ws[0]/2 , ws[1]/2 ) )
+        return self.on_move( ( ws[0]/2 + jaxes[0]/jd , ws[1]/2 + jaxes[1]/jd ) )

pyparticles/ogl/translate_scene.py

@@ -0,0 +1,87 @@
+# 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
+
+class TranslateScene(object):
+    def __init__( self , w_size ):
+        
+        self.__v     = np.array( [ 0.0 , 0.0 , 0.0 ] )
+        self.__v_old = np.array( [ 0.0 , 0.0 , 0.0 ] )
+        
+        self.__win_size = ( 800 , 600 )
+        
+        self.__win_width = 800
+        self.__win_height = 600
+        
+        self.win_size = w_size
+        
+        self.factor = 100
+        self.__fovy   = 2.0
+    
+    def get_V( self ):
+        return self.__v 
+    
+    def set_V( self , v ):
+        self.__v = v
+        
+    V = property( get_V , set_V )
+    
+    
+    def get_fovy( self ):
+        return self.__fovy 
+    
+    def set_fovy( self , fv ):
+        if fv > 2.0 :
+            fv = 2.0 
+        self.__fovy = fv
+        
+    fovy = property( get_fovy , set_fovy )    
+    
+        
+    def get_win_size( self ):
+        return ( self.__win_width , self.__win_height )
+    
+    def set_win_size( self , w_size ):
+        self.__win_width  = w_size[0]
+        self.__win_height = w_size[1]
+        
+    win_size = property( get_win_size , set_win_size )
+
+
+    def translate_mapping( self , point ):
+        self.__v_old[:] = self.__v[:]
+        
+        self.__v[0] = ( 2.0 * point[0]   - self.win_size[0] ) / self.win_size[0]
+        self.__v[1] = ( self.win_size[1] - 2.0 * point[1] )   / self.win_size[1]
+        self.__v[2] = 1.0
+        
+        
+    def on_move( self , point ):
+        self.translate_mapping( point )
+        
+        direction = self.__v - self.__v_old
+        
+        velocity = np.linalg.norm( direction )
+        
+        delta = direction * velocity * self.factor * self.fovy
+        
+        return ( delta[0] , delta[1] )
+        
+        
+        
+        

pyparticles/pset/__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/pset/boundary.py

@@ -0,0 +1,69 @@
+# PyParticles : Particles simulation in python
+# 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 sys
+
+
+class Boundary(object):
+    def __init__(self):
+        pass
+    
+    def set_boundary( self , bound=(-1,1) , dim=3 ):
+        if len(bound) not in ( 2 , 4 , 6 ):
+            raise ValueError
+        
+        self.__dim = dim
+        self.__bound = np.zeros((dim,2))
+        
+        if len(bound) >= 2 :
+            self.__bound[0,0] = bound[0]
+            self.__bound[0,1] = bound[1]
+            
+            if dim >= 2 :
+                self.__bound[1,0] = bound[0]
+                self.__bound[1,1] = bound[1]
+            
+            if dim == 3 :
+                self.__bound[2,0] = bound[0]
+                self.__bound[2,1] = bound[1]             
+                
+        if len(bound) == 6:
+            self.__bound[1,0] = bound[2]
+            self.__bound[1,1] = bound[3] 
+            
+            self.__bound[2,0] = bound[4]
+            self.__bound[2,1] = bound[5]
+            
+        if len(bound) == 4:
+            self.__bound[1,0] = bound[2]
+            self.__bound[1,1] = bound[3]
+    
+    def get_dim(self):
+        return self.__dim
+    
+    dim = property( get_dim )
+    
+    def get_bound(self):
+        return self.__bound
+    
+    bound = property( get_bound )
+    
+    def boundary( self , p_set ):
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+
+

pyparticles/pset/cluster.py

@@ -0,0 +1,28 @@
+# 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
+
+class Cluster(object):
+    def __init__(self):
+        pass
+
+    def insert3( self , X , M=None ,V=None ):
+        pass
+    
+    def write_out( self , X , M=None ,V=None ):
+        pass
+

pyparticles/pset/constrained_force_interactions.py

@@ -0,0 +1,63 @@
+# 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
+from scipy.sparse import dok_matrix
+
+import pyparticles.pset.constraint as ct
+
+
+class ConstrainedForceInteractions(ct.Constraint):
+    def __init__(self, pset=None):
+        self.__S = dok_matrix((1, 1), dtype=np.byte)
+        super(ConstrainedForceInteractions, self).__init__(pset=None)
+        if pset is not None:
+            self.pset = pset
+
+    def get_pset(self):
+        return super(ConstrainedForceInteractions, self).get_pset()
+
+    def set_pset(self, pset):
+        self.__S.resize((pset.size, pset.size))
+        super(ConstrainedForceInteractions, self).set_pset(pset)
+
+    pset = property(get_pset, set_pset)
+
+    def add_connections(self, fc):
+        for c in fc:
+            i, j = int(c[0]), int(c[1])
+            self.__S[i, j] = True
+
+    def remove_connections(self, fc):
+        for c in fc:
+            i, j = int(c[0]), int(c[1])
+            if (i, j) in self.__S:
+                del self.__S[i, j]
+
+    def get_dense(self):
+        return np.asarray(self.__S.todense(), dtype=np.bool_)
+
+    dense = property(get_dense)
+
+    def get_sparse(self):
+        return self.__S
+
+    sparse = property(get_sparse)
+
+    def get_items(self):
+        return self.__S.items()
+
+    items = property(get_items)

pyparticles/pset/constrained_x.py

@@ -0,0 +1,158 @@
+# 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.constraint as ct
+
+
+class ConstrainedX(ct.Constraint):
+    def __init__(self, pset=None):
+        self.__X_cr = None
+        self.__X_cr_i = None
+        self.__X_free = None
+
+        self.__use_slice_const = False
+        self.__use_slice_free = False
+
+        super(ConstrainedX, self).__init__(pset=pset)
+
+    def add_x_constraint(self, indx, constr):
+        """Add positional constraints and update the referenced particle set."""
+        if isinstance(indx, slice):
+            self.__X_cr = np.array(constr)
+            self.__X_cr_i = indx
+            self.__use_slice_const = True
+            self.pset.X[indx, :] = constr
+            self._optimize()
+            return
+
+        indx = np.asarray(indx, dtype=np.int64)
+        constr = np.asarray(constr)
+
+        if self.__X_cr is None:
+            self.__X_cr = constr.copy()
+            self.__X_cr_i = indx.copy()
+        else:
+            self.__X_cr_i = np.concatenate((self.__X_cr_i, indx))
+            self.__X_cr = np.concatenate((self.__X_cr, constr))
+
+        self._optimize()
+        self.pset.X[indx, :] = constr
+
+    def _optimize(self):
+        """Use a slice for free indices when they form one contiguous range."""
+        free = list(range(self.pset.size))
+
+        if self.__X_cr_i is None:
+            constrained = []
+        elif isinstance(self.__X_cr_i, slice):
+            constrained = range(*self.__X_cr_i.indices(self.pset.size))
+        else:
+            constrained = self.__X_cr_i
+
+        for i in constrained:
+            i = int(i)
+            if i in free:
+                free.remove(i)
+
+        if not free:
+            self.__X_free = np.array([], dtype=np.int64)
+            self.__use_slice_free = False
+            return
+
+        sequential = all((free[i + 1] - free[i]) == 1 for i in range(len(free) - 1))
+        if sequential:
+            self.__X_free = slice(free[0], free[-1] + 1)
+            self.__use_slice_free = True
+        else:
+            self.__X_free = np.asarray(free, dtype=np.int64)
+            self.__use_slice_free = False
+
+    def get_pset(self):
+        return super(ConstrainedX, self).get_pset()
+
+    def set_pset(self, pset):
+        super(ConstrainedX, self).set_pset(pset)
+        if self.__X_cr_i is not None and self.__X_cr is not None:
+            pset.X[self.__X_cr_i, :] = self.__X_cr
+            self._optimize()
+
+    pset = property(get_pset, set_pset, doc="get and set the particles set (pset)")
+
+    def remove_x_constraint(self, indxs):
+        """Remove constraints whose particle indices are listed in *indxs*."""
+        if self.__use_slice_const or self.__X_cr_i is None:
+            return
+
+        remove_positions = []
+        for i in indxs:
+            matches = np.flatnonzero(self.__X_cr_i == i)
+            remove_positions.extend(matches.tolist())
+
+        if not remove_positions:
+            return
+
+        remove_positions = np.asarray(sorted(set(remove_positions)), dtype=np.int64)
+        self.__X_cr = np.delete(self.__X_cr, remove_positions, axis=0)
+        self.__X_cr_i = np.delete(self.__X_cr_i, remove_positions, axis=0)
+
+        if self.__X_cr_i.size == 0:
+            self.__X_cr = None
+            self.__X_cr_i = None
+
+        self._optimize()
+
+    def get_cx_indicies(self):
+        """Return a copy of the constrained indices (legacy spelling kept)."""
+        if isinstance(self.__X_cr_i, slice):
+            return self.__X_cr_i
+        if self.__X_cr_i is None:
+            return None
+        return np.copy(self.__X_cr_i)
+
+    def set_free_indicies(self, indx):
+        if isinstance(indx, slice):
+            self.__X_free = indx
+            self.__use_slice_free = True
+            return
+
+        indx = np.asarray(indx, dtype=np.int64)
+        if self.__X_free is None:
+            self.__X_free = indx
+        elif isinstance(self.__X_free, slice):
+            current = np.arange(self.pset.size, dtype=np.int64)[self.__X_free]
+            self.__X_free = np.concatenate((current, indx))
+        else:
+            self.__X_free = np.concatenate((self.__X_free, indx))
+        self.__use_slice_free = False
+
+    def get_cx_free_indicies(self):
+        return self.__X_free
+
+    def clear_all_x_constraint(self):
+        self.__X_cr = None
+        self.__X_cr_i = None
+        self.__X_free = slice(0, self.pset.size) if self.pset is not None else None
+        self.__use_slice_const = False
+        self.__use_slice_free = self.pset is not None
+
+    def get_cX(self):
+        if self.__X_cr_i is None:
+            return None
+        return self.pset.X[self.__X_cr_i, :]
+
+    cX = property(get_cX, doc="return the constrained X elements")

pyparticles/pset/constraint.py

@@ -0,0 +1,42 @@
+# 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
+from collections import deque
+
+import pyparticles.pset.particles_set as ps
+
+class Constraint( object ):
+    def __init__( self , pset=None ):
+        self.__pset = pset
+        
+        
+    def get_pset(self):
+        return self.__pset
+    
+    def set_pset( self , pset ):
+        self.__pset = pset
+        
+    pset = property( get_pset , set_pset )    
+
+
+    
+    
+    
+    
+    
+    

pyparticles/pset/default_boundary.py

@@ -0,0 +1,43 @@
+# 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.pset.boundary as bd
+
+
+class DefaultBoundary(bd.Boundary):
+    r"""Move particles outside the domain through a user callback."""
+
+    def __init__(self, bound=(-1, 1), dim=3, defualt_pos=None):
+        self.set_boundary(bound, dim)
+        self.__defualt_pos = defualt_pos
+
+    def needs_update(self, p_set):
+        """Return True when at least one position lies outside the domain."""
+        for i in range(self.dim):
+            if np.any(p_set.X[:, i] < self.bound[i, 0]):
+                return True
+            if np.any(p_set.X[:, i] > self.bound[i, 1]):
+                return True
+        return False
+
+    def boundary(self, p_set):
+        changed = False
+        for i in range(self.dim):
+            b_mi, = np.where(p_set.X[:, i] < self.bound[i, 0])
+            b_mx, = np.where(p_set.X[:, i] > self.bound[i, 1])
+
+            if len(b_mi) > 0:
+                self.__defualt_pos(p_set, b_mi)
+                changed = True
+
+            if len(b_mx) > 0:
+                self.__defualt_pos(p_set, b_mx)
+                changed = True
+
+        return changed