PyParticles3 0.4.0__py3-none-any.whl

pyparticles/measures/mass.py

@@ -0,0 +1,59 @@
+# 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 Mass( object ):
+    """
+    'Meaure' for computing the total mass of the particle system
+    """
+    def __init__( self , pset=None, force=None  ):
+        super( Mass , self ).__init__( pset=pset , force=force )
+        self.__M = 0.0
+    
+     
+    def update_measure( self ):
+        """
+        Compute and return the totale mass of the system
+        """
+        self.__M = np.sum( self.pset.M[:] )
+        return self.__M
+    
+    
+    def value(self):
+        """
+        Return the current measured total mass 
+        """
+        return self.__M
+    
+    
+    def shape(self ):
+        """
+        return a tuple containing the shape of the measures dataset
+        """
+        return 1,
+    
+    def dim( self ):
+        """
+        return the dimension of the measure: 1 for the mass
+        """
+        return 1
+    
+    def name(self):
+        """
+        Return the string: "mass"
+        """
+        return "mass"

pyparticles/measures/measure.py

@@ -0,0 +1,156 @@
+# 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 Measure( object ):
+    """
+    Main abstract class for defining the measurement procedures of the system, for example the total kinetic energy.
+    """
+    def __init__( self , pset=None , force=None ):
+        """
+        Constructor
+          
+        :param pset:    The particles set
+        :param force:   The model of the used force
+        """
+        self.__pset  = pset
+        self.__force = force
+        self.__par   = dict()
+        
+        self.__str_f = "%f"
+    
+    def get_pset( self ):
+        return self.__pset
+    
+    def set_pset( self , pset ):
+        self.__pset = pset
+    
+    pset = property( get_pset , set_pset , doc="set and get the current measured particle set" )
+    
+    
+    def get_force( self ):
+        return self.__force
+    
+    def set_force( self , force ):
+        self.__force = force
+    
+    force = property( get_force , set_force , doc="set and get the current force model" )
+    
+    
+    def get_parameter( self , name , val ):
+        """
+        return the reference to the dict of the used parameter
+            A parameter  should be the volume, some constant ....
+        """
+        return self.__par
+    
+    parameter = property( get_parameter , doc="return the reference to the dict of the used paramenter" )
+    
+    
+    def update_measure( self ):
+        """
+        compute and return the value of the measured quantity
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+    
+    
+    def value( self ):
+        """
+        Return the value of the current measure
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+    
+    def set_str_format( self , f="%5.3f" ):
+        self.__str_f = f
+        
+    def get_str_format( self ):
+        return self.__str_f
+    
+    str_format = property( get_str_format , set_str_format , doc="get ad set the string format for representing the value" )
+    
+    def value_str( self ):
+        """
+        return a string containig the value of the current neasure formmatted according to the format defined with the str_property format. By default if uses the simple floaf format
+        """
+        return self.str_format % ( self.value() )
+    
+    def shape(self ):
+        """
+        return a tuple containing the shape of the measures dataset
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+    
+    def dim( self ):
+        """
+        return the dimension of the measure, for the dimensionless measure it must return 1 (like kinetic energy or mass)
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+        
+    def name(self):
+        """
+        return a string containig the name of the measure
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+        
+        
+        
+        
+        
+class MeasureParticles( Measure ):
+    """
+    Abstract class used fopr measuring a subset of partiles or a set of singles particles.
+    """
+    def __init__( self , pset=None , force=None , subset=None , model="part_by_part" ):
+        """
+        Constructor:
+          
+        :param pset:    The particles set
+        :param force:   The model of the used force
+        :param subset:  a numpy 1D array containing the indicies of the measured particles
+        :param model:   a strung describing the model for the measure: "part_by_part" or "subsystem"
+          
+        """
+        self.__subset = np.copy(subset)
+        
+        self.__model = None
+        
+        self.model = model
+        
+        super( MeasureParticles , self ).__init__( pset=pset , force=force )
+
+    
+    def set_subset( self , subset ):
+        self.__subset = np.copy(subset)    
+    
+    def get_subset( self ):
+        return self.__subset
+    
+    
+    subset = property( get_subset , set_subset , doc="get and set the subset of particles to be measured" )
+    
+    
+    def get_model ( self ):
+        return self.__model
+
+    def set_model ( self , model ):
+        if model not in [ "part_by_part" , "subsystem" ] :
+            ValueError
+            
+        self.__model = model
+    
+    model = property( get_model , set_model , doc="set and get the measurement model: \"part_by_part\" or \"subsystem\" ")
+        

pyparticles/measures/momentum.py

@@ -0,0 +1,144 @@
+# 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.measures.measure as me
+
+class MomentumSystem( me.Measure ):
+    """
+    'Measure' for computing the total momentum of the particle system
+    """
+    def __init__( self , pset=None ):
+        
+        if pset != None :
+            self.__P = np.zeros(( pset.dim ))
+        else :
+            self.__P = None
+        
+        super( MomentumSystem , self ).__init__( pset=pset , force=None )
+        
+        
+    def value(self):
+        """
+        return the current value of the total momentum
+        """
+        return self.__P
+    
+    
+    def update_measure( self ):
+        """
+        Compute and return the total momentum of the system 
+        """
+        
+        self.__P = np.sum( self.pset.V * self.pset.M , 0 )
+        
+        return self.__P
+        
+    
+    def shape( self ):
+        """
+        return a tuple containing the shape of the measures dataset
+        """
+        return ( self.pset.dim )
+    
+    def dim( self ):
+        """
+        return the dimension of the measure: Dim  for the momentum
+        """
+        return self.pset.dim
+    
+    def name(self):
+        """
+        Return the string: "momentum"
+        """
+        return "momentum"
+    
+    
+    
+class MomentumParticles( me.MeasureParticles ):
+    """
+    'Measure' for computing the momentum particle by particle or of a subsystem
+    Example: ::
+    
+        P = MomentumParticles( pset , subset=np.array([1,4,5]) , model="part_by_part")
+        P.update_measure()
+        print( P.value )
+        >    [[ 1.1 , 2.3 , 3.2 ],
+        >     [ 1.7 , 5.2 , 6.9 ],
+        >     [ 1.8 , 2.3 , 1.7 ]
+        >    ]
+     
+    Constructor:
+      
+    :param pset      The particles set
+    :param force     The model of the used force
+    :param subset    a numpy 1D array containing the indicies of the measured particles
+    :param model     a strung describing the model for the measure: "part_by_part" or "subsystem"
+    """
+    def __init__( self , pset=None , force=None , subset=None , model="part_by_part" ):
+      
+        if pset != None and model == "subsystem" :
+            self.__P = np.zeros(( pset.dim ))
+        elif pset != None and model == "part_by_part" and subset != None :
+            self.__P = np.zeros(( len(subset) , pset.dim ))
+        else :
+            self.__P = None
+        
+        super( MomentumParticles , self ).__init__( pset , force , subset , model )
+        
+        
+    def value(self):
+        """
+        return the current value of the momentum
+        """
+        return self.__P
+    
+    
+    def update_measure( self ):
+        """
+        Compute and return the total momentum of the specified particles 
+        """
+        
+        if self.model == "part_by_part" :
+            self.__P = self.pset.V[self.subset] * self.pset.M[self.subset]
+        else :
+            self.__P = np.sum( self.pset.V[self.subset] * self.pset.M[self.subset] , 0 )
+        
+        return self.__P
+        
+    
+    def shape( self ):
+        """
+        return a tuple containing the shape of the measures dataset
+        """
+        if self.model == "part_by_part" :
+            return ( len( self.subset ) , pset.dim  )
+        else :
+            return ( 1 , pset.dim )
+    
+    def dim( self ):
+        """
+        return the dimension of the measure: Dim: (2D or 3D) for the momentum
+        """
+        return self.pset.dim
+    
+    def name(self):
+        """
+        Return the string: "momentum"
+        """
+        return "momentum" 

pyparticles/measures/total_energy.py

@@ -0,0 +1,68 @@
+# 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.measures.measure as me
+
+class TotalEnergy( me.Measure ):
+    """
+    Class derived from Measure used for computing the total energy of the particle system
+        given a potential and a kinetic energy it simply sum the two value
+    """
+    def __init__( self , kinetic , potential ):
+        
+        self.__kinetic = kinetic
+        self.__potential = potential
+        
+        self.__tot = 0.0
+        
+        super( TotalEnergy , self ).__init__( pset=None , force=None )
+    
+    
+    def value(self):
+        """
+        return the current value of the potential energy
+        """
+        self.__tot = self.__kinetic.value() + self.__potential.value()
+        return self.__tot
+    
+    
+    def update_measure( self ):
+        """
+        Compute and return the total energy on the current state of pset 
+        """
+        return self.__tot
+        
+    
+    def shape( self ):
+        """
+        return a tuple containing the shape of the measures dataset
+        """
+        return 1,
+    
+    def dim( self ):
+        """
+        return the dimension of the measure: 1 for the energy
+        """
+        return 1
+    
+    def name(self):
+        """
+        Return the string: "total energy"
+        """
+        return "total energy"

pyparticles/ode/__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/ode/euler_solver.py

@@ -0,0 +1,214 @@
+# 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.ode.ode_solver as os
+import pyparticles.pset.opencl_context as occ
+
+try:
+    import pyopencl as cl
+except ImportError:
+    cl = None
+
+
+class EulerSolver(os.OdeSolver):
+    def __init__(self, force, p_set, dt):
+        super(EulerSolver, self).__init__(force, p_set, dt)
+
+    def __step__(self, dt):
+        self.force.update_force(self.pset)
+        self.pset.V[:] = self.pset.V + self.force.A * dt
+        self.pset.X[:] = self.pset.X + self.pset.V * dt
+        self.pset.update_boundary()
+
+
+class EulerSolverOCL(os.OdeSolver):
+    """Euler integrator with persistent OpenCL X/V/A buffers.
+
+    ``sync_velocity`` defaults to True to preserve the historical API where
+    ``pset.V`` is current immediately after every step. Rendering-only demos
+    may disable it. Boundaries implementing ``needs_update`` then trigger a V
+    download only on frames where a particle actually crosses the domain.
+
+    ``sync_positions`` defaults to True because the legacy renderer consumes
+    host ``pset.X`` every frame. Compute-only users, or a renderer backed by an
+    OpenCL/OpenGL shared buffer, may disable it so X never crosses PCIe during
+    the integration hot path. A host-side boundary still forces X current.
+
+    Device forces may optionally expose ``euler_step_device``. Fused calls
+    receive the current simulation time and step count so device-side boundary
+    or source models can evolve without synchronizing through the host.
+    """
+
+    def __init__(
+        self,
+        force,
+        p_set,
+        dt,
+        ocl_context=None,
+        sync_velocity=True,
+        sync_positions=True,
+    ):
+        if cl is None:
+            raise RuntimeError("PyOpenCL is required for EulerSolverOCL")
+        if p_set.dim != 3:
+            raise ValueError("EulerSolverOCL currently supports only 3 dimensions")
+
+        super(EulerSolverOCL, self).__init__(force, p_set, dt)
+
+        if ocl_context is None:
+            self.__occ = occ.OpenCLcontext(
+                self.pset.size,
+                self.pset.dim,
+                occ.OCLC_X | occ.OCLC_V | occ.OCLC_A,
+            )
+        else:
+            self.__occ = ocl_context
+
+        self.__sync_velocity = bool(sync_velocity)
+        self.__sync_positions = bool(sync_positions)
+        self.__init_prog_cl()
+
+    def __init_prog_cl(self):
+        source = r"""
+        __kernel void euler(
+            __global       float *V,
+            __global const float *A,
+            __global       float *X,
+                           float  dt)
+        {
+            int i = get_global_id(0);
+            int i0 = 3*i;
+            int i1 = i0 + 1;
+            int i2 = i0 + 2;
+
+            V[i0] = V[i0] + A[i0]*dt;
+            V[i1] = V[i1] + A[i1]*dt;
+            V[i2] = V[i2] + A[i2]*dt;
+
+            X[i0] = X[i0] + V[i0]*dt;
+            X[i1] = X[i1] + V[i1]*dt;
+            X[i2] = X[i2] + V[i2]*dt;
+        }
+        """
+        self.__cl_program = cl.Program(self.__occ.CL_context, source).build()
+        self.__euler_kernel = cl.Kernel(self.__cl_program, "euler")
+
+    def _has_device_force(self):
+        return (
+            hasattr(self.force, "update_force_device")
+            and getattr(self.force, "ocl_context", None) is self.__occ
+        )
+
+    def _has_fused_euler_force(self):
+        return (
+            hasattr(self.force, "euler_step_device")
+            and getattr(self.force, "ocl_context", None) is self.__occ
+        )
+
+    def __step__(self, dt):
+        if self._has_fused_euler_force():
+            self.__occ.sync_to_device("X", self.pset.X)
+            self.__occ.sync_to_device("V", self.pset.V)
+            self.force.euler_step_device(
+                self.pset,
+                dt,
+                sim_time=self.time,
+                step=self.steps_cnt,
+            )
+        else:
+            if self._has_device_force():
+                self.force.update_force_device(self.pset)
+            else:
+                self.__occ.sync_to_host("X", self.pset.X)
+                self.__occ.sync_to_host("V", self.pset.V)
+                self.force.update_force(self.pset)
+                self.__occ.set_from_host("A", self.force.A)
+
+            self.__occ.sync_to_device("X", self.pset.X)
+            self.__occ.sync_to_device("V", self.pset.V)
+
+            self.__euler_kernel(
+                self.__occ.CL_queue,
+                (self.pset.size,),
+                None,
+                self.__occ.V_cla.data,
+                self.__occ.A_cla.data,
+                self.__occ.X_cla.data,
+                np.float32(dt),
+            )
+            self.__occ.mark_device_modified("X")
+            self.__occ.mark_device_modified("V")
+
+        boundary = self.pset.boundary
+        need_host_positions = (
+            self.__sync_positions
+            or self.pset.log_X_enabled
+            or boundary is not None
+        )
+        if need_host_positions:
+            self.__occ.sync_to_host("X", self.pset.X)
+
+        boundary_active = False
+        if boundary is not None:
+            needs_update = getattr(boundary, "needs_update", None)
+            if needs_update is None:
+                boundary_active = True
+            else:
+                boundary_active = bool(needs_update(self.pset))
+
+        need_host_velocity = (
+            self.__sync_velocity
+            or self.pset.log_V_enabled
+            or boundary_active
+        )
+        if need_host_velocity:
+            self.__occ.sync_to_host("V", self.pset.V)
+
+        if boundary is not None and boundary_active:
+            changed = boundary.boundary(self.pset)
+            changed = True if changed is None else bool(changed)
+            if changed:
+                self.__occ.mark_host_modified("X")
+                self.__occ.mark_host_modified("V")
+
+    def sync_to_host(self, velocity=True):
+        """Explicitly synchronize resident state for external host consumers."""
+        self.__occ.sync_to_host("X", self.pset.X)
+        if velocity:
+            self.__occ.sync_to_host("V", self.pset.V)
+        return self.pset
+
+    def notify_host_modified(self, positions=True, velocities=True):
+        """Tell the solver that external code changed host X and/or V."""
+        if positions:
+            self.__occ.mark_host_modified("X")
+        if velocities:
+            self.__occ.mark_host_modified("V")
+
+    def get_ocl_context(self):
+        return self.__occ
+
+    ocl_context = property(get_ocl_context)
+
+    def get_sync_velocity(self):
+        return self.__sync_velocity
+
+    def set_sync_velocity(self, value):
+        self.__sync_velocity = bool(value)
+
+    sync_velocity = property(get_sync_velocity, set_sync_velocity)
+
+    def get_sync_positions(self):
+        return self.__sync_positions
+
+    def set_sync_positions(self, value):
+        self.__sync_positions = bool(value)
+
+    sync_positions = property(get_sync_positions, set_sync_positions)