PyParticles3 0.4.0rc1__py3-none-any.whl

pyparticles/animation/animated_ogl_compat.py

@@ -0,0 +1,243 @@
+# 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.
+
+"""Compatibility layer for the legacy PyParticles OpenGL animation.
+
+The historical renderer is kept intact.  This module adapts the pieces whose
+runtime behaviour changed between the 2012 PyOpenGL/GLUT stack and current
+FreeGLUT/PyOpenGL/NumPy releases.  It also provides lifecycle hooks needed to
+create OpenCL/OpenGL shared resources after the GL context exists.
+"""
+
+import ctypes
+import gc
+import signal
+
+import pyparticles.animation.animated_ogl as legacy
+import pyparticles.ogl.draw_particles_ogl as legacy_draw
+import pyparticles.ogl.draw_particles_ogl_compat as draw_compat
+import pyparticles.ogl.draw_vector_field as legacy_vector_field
+
+
+legacy_draw.DrawParticlesGL = draw_compat.DrawParticlesGL
+legacy_draw.charged_particles_color = draw_compat.charged_particles_color
+legacy_draw.charged_particles_vect_color = draw_compat.charged_particles_vect_color
+legacy.drp.DrawParticlesGL = draw_compat.DrawParticlesGL
+
+
+def _safe_vector_field_del(self):
+    pass
+
+
+legacy_vector_field.DrawVectorField.__del__ = _safe_vector_field_del
+
+
+_legacy_key_pressed = legacy.KeyPressed
+_active_animation = None
+
+
+def _cleanup_active_animation():
+    animation = _active_animation
+    if animation is None:
+        return
+    cleanup = getattr(animation, "cleanup_resources", None)
+    if cleanup is not None:
+        cleanup()
+
+
+def _leave_main_loop():
+    """Request a clean FreeGLUT exit when the extension is available."""
+    leave = getattr(legacy, "glutLeaveMainLoop", None)
+    if leave is not None:
+        try:
+            if bool(leave):
+                leave()
+                return
+        except Exception:
+            pass
+
+    raise KeyboardInterrupt
+
+
+def _key_pressed(key, x, y):
+    """Adapt modern PyOpenGL byte keyboard callbacks to the legacy handler."""
+    if isinstance(key, bytes):
+        key = key.decode("latin-1")
+
+    if key in ("q", "Q", "\x1b"):
+        # Shared CL/GL objects must be released while the GLUT window and its
+        # GLX context are still alive.  Calling glutLeaveMainLoop first may
+        # destroy the context before Python finally-block cleanup runs.
+        _cleanup_active_animation()
+        _leave_main_loop()
+        return
+
+    return _legacy_key_pressed(key, x, y)
+
+
+def _sigint_handler(signum, frame):
+    _cleanup_active_animation()
+    _leave_main_loop()
+
+
+def _close_window():
+    # FreeGLUT invokes the close callback as part of window destruction.
+    # Do not call glutLeaveMainLoop() recursively from here: that re-enters
+    # FreeGLUT's teardown path and can segfault with shared GL/CL resources.
+    _cleanup_active_animation()
+
+
+def _configure_freeglut_exit():
+    """Ask FreeGLUT to return from its main loop when a window is closed."""
+    set_option = getattr(legacy, "glutSetOption", None)
+    action_key = getattr(legacy, "GLUT_ACTION_ON_WINDOW_CLOSE", None)
+    return_action = getattr(legacy, "GLUT_ACTION_GLUTMAINLOOP_RETURNS", None)
+
+    if set_option is not None and action_key is not None and return_action is not None:
+        try:
+            if bool(set_option):
+                set_option(action_key, return_action)
+        except Exception:
+            pass
+
+    close_func = getattr(legacy, "glutCloseFunc", None)
+    if close_func is not None:
+        try:
+            if bool(close_func):
+                close_func(_close_window)
+        except Exception:
+            pass
+
+
+class AnimatedGl(legacy.AnimatedGl):
+    """Legacy renderer with modern FreeGLUT and CL/GL lifecycle hooks."""
+
+    def __init__(self):
+        super(AnimatedGl, self).__init__()
+        self.__gl_context_ready_callback = None
+        self.__pre_step_callback = None
+        self.__post_step_callback = None
+        self.__cleanup_callbacks = []
+        self.__cleanup_done = False
+
+    def get_trajectory_step(self):
+        return legacy.pan.Animation.get_trajectory_step(self)
+
+    def set_trajectory_step(self, value):
+        legacy.pan.Animation.set_trajectory_step(self, value)
+        self.draw_particles.set_trajectory_step(value)
+
+    trajectory_step = property(get_trajectory_step, set_trajectory_step)
+
+    def set_gl_context_ready_callback(self, callback):
+        """Run *callback(animation)* immediately after GLUT creates the window.
+
+        At that point the GL context is current, but the legacy builder has not
+        yet called ``ode_solver.update_force()``.  A callback may therefore
+        create a GL-sharing OpenCL context and replace ``animation.ode_solver``
+        before the first force evaluation.
+        """
+        self.__gl_context_ready_callback = callback
+
+    def set_pre_step_callback(self, callback):
+        """Run *callback(animation)* immediately before each solver step."""
+        self.__pre_step_callback = callback
+
+    def set_post_step_callback(self, callback):
+        """Run *callback(animation)* after each solver step and before draw."""
+        self.__post_step_callback = callback
+
+    def add_cleanup_callback(self, callback):
+        self.__cleanup_callbacks.append(callback)
+
+    def cleanup_resources(self):
+        """Release GL-dependent resources exactly once while GL is current."""
+        if self.__cleanup_done:
+            return
+        self.__cleanup_done = True
+
+        # No more CL/GL work may be scheduled once teardown starts.
+        self.__pre_step_callback = None
+        self.__post_step_callback = None
+
+        # Consume cleanup closures while the GL context is still current.
+        # Keeping an already-executed closure in this list can retain OpenCL
+        # kernels/contexts until after FreeGLUT destroys GLX, which is unsafe
+        # for objects derived from cl_khr_gl_sharing on the NVIDIA driver.
+        while self.__cleanup_callbacks:
+            callback = self.__cleanup_callbacks.pop()
+            try:
+                callback(self)
+            except Exception:
+                pass
+            finally:
+                callback = None
+
+        # Collect any cycles released by the callbacks before returning to the
+        # key/close handler that asks FreeGLUT to tear down the GL context.
+        gc.collect()
+
+    def build_animation(self):
+        global _active_animation
+
+        legacy.ctypes = ctypes
+        legacy.KeyPressed = _key_pressed
+        self.__cleanup_done = False
+        _active_animation = self
+
+        # The legacy builder creates the GLUT window and immediately evaluates
+        # the force.  Wrap just the window creation call so CL/GL resources can
+        # be established in the narrow interval where the GL context is current
+        # and before the solver is first used.
+        original_create_window = legacy.glutCreateWindow
+
+        def create_window_with_hook(*args, **kwargs):
+            window = original_create_window(*args, **kwargs)
+            callback = self.__gl_context_ready_callback
+            if callback is not None:
+                callback(self)
+            return window
+
+        legacy.glutCreateWindow = create_window_with_hook
+        try:
+            result = super(AnimatedGl, self).build_animation()
+        finally:
+            legacy.glutCreateWindow = original_create_window
+
+        _configure_freeglut_exit()
+        return result
+
+    def data_stream(self):
+        callback = self.__pre_step_callback
+        if callback is not None:
+            callback(self)
+
+        result = super(AnimatedGl, self).data_stream()
+
+        callback = self.__post_step_callback
+        if callback is not None:
+            callback(self)
+        return result
+
+    def start(self):
+        global _active_animation
+
+        previous_sigint = signal.getsignal(signal.SIGINT)
+        signal.signal(signal.SIGINT, _sigint_handler)
+        _active_animation = self
+        try:
+            return super(AnimatedGl, self).start()
+        except KeyboardInterrupt:
+            return None
+        finally:
+            # This is a fallback for non-keyboard exits.  Normal q/Esc and
+            # close-window paths have already run cleanup while GL was current.
+            self.cleanup_resources()
+            if _active_animation is self:
+                _active_animation = None
+            signal.signal(signal.SIGINT, previous_sigint)

pyparticles/animation/animated_scatter.py

@@ -0,0 +1,94 @@
+# 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.pset.particles_set as ps
+
+import pyparticles.animation.animation as pan
+
+#import pyparticles.rand_cluster as clu
+#import pyparticles.euler_solver as els
+#import pyparticles.leapfrog_solver as lps
+#import pyparticles.runge_kutta_solver as rks
+
+import matplotlib.animation as animation
+
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.pyplot as plt
+import numpy as np
+#import pyparticles.periodic_boundary as pb
+#import pyparticles.rebound_boundary as rb
+
+
+
+FLOOR = -10
+CEILING = 10
+
+class AnimatedScatter( pan.Animation ):
+    
+    def __init__(self, numpoints=50):
+        super( AnimatedScatter , self ).__init__()
+
+ 
+    def build_animation(self):       
+        self.fig = plt.figure()
+        self.ax = self.fig.add_subplot(111, projection='3d')
+        
+        self.stream = self.data_stream()
+        
+        self.ani = animation.FuncAnimation(self.fig, self.update, interval=5, 
+                                           init_func=self.setup_plot, blit=True)
+        
+        
+    def setup_plot(self):
+        
+        j = next(self.stream)
+        self.scat = self.ax.scatter( self.pset.X[:,0]/self.pset.unit ,
+                                     self.pset.X[:,1]/self.pset.unit ,
+                                     self.pset.X[:,2]/self.pset.unit ,
+                                     animated=True , marker='o' , alpha=None , s=10)
+        
+        self.ax.set_xlim3d( self.xlim )
+        self.ax.set_ylim3d( self.ylim )
+        self.ax.set_zlim3d( self.zlim )
+        
+        return self.scat,
+
+
+    def data_stream(self):
+        
+        self.ode_solver.update_force()
+        
+        for j in range(self.steps):
+            self.ode_solver.step()            
+            yield j
+            
+
+
+    def update(self, i):
+        """Update the scatter plot."""
+        j = next(self.stream)
+         
+        self.scat._offsets3d = ( np.ma.ravel(self.pset.X[:,0]/self.pset.unit) ,
+                                 np.ma.ravel(self.pset.X[:,1]/self.pset.unit) ,
+                                 np.ma.ravel(self.pset.X[:,2]/self.pset.unit)
+                                 )       
+                
+        plt.draw()
+        return self.scat,
+
+    def start(self):
+        plt.show()
+        

pyparticles/animation/animation.py

@@ -0,0 +1,251 @@
+
+
+# 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
+import time
+
+
+class Animation(object):
+    """
+    Base abstract class used for controling the simulation.
+        This class should be used as a base class for building and runnig a simulation problem.
+        The class animation contains all foudamental element for working with a PyParticles in an easy way.
+    The user must overide the methods:
+            build_animation: For setting up averithing
+            data_stream: for performing a simulation step or runnig the main loop
+            start: start the smulation
+    
+    In a few word you must follow this procedure:
+    ::
+    
+        # Construct a new object
+        a = MyAnimation()
+        
+        # setup the particles set
+        a.pset = pset
+        
+        # setup the numeric integration 
+        a.ode_solver = solver
+        
+        # max number of steps
+        a.steps = steps
+        
+        # set up everythings 
+        a.build_animation()
+        
+        # start!
+        a.start()
+    """
+    def __init__(self):
+        self.__ode_solver = None
+        self.__pset = None
+        self.__steps = 10000
+        
+        self.__xl = (-1,1)
+        self.__yl = (-1,1)
+        self.__zl = (-1,1)
+        
+        self.__trajectory = False
+        self.__trajectory_step = 1
+        
+        self.__measures = dict()
+        self.__measures_names = []
+        
+        self.__fps = 0.0
+        self.__fps_init_time = 0.0
+        self.__fps_steps = 7
+        self.__fps_cnt = 0
+        self.__fps_print = False
+        
+        
+    def set_ode_solver( self , solver ):
+        self.__ode_solver = solver
+    
+    def get_ode_solver( self ):
+        return self.__ode_solver     
+        
+    ode_solver = property( get_ode_solver , set_ode_solver )
+    
+    
+    def add_measure( self , measure ):
+        """
+        Add a class delegeted for performing a measure
+        """
+        self.__measures[measure.name()] = measure
+        self.__measures_names.append( measure.name() )
+        
+    def perform_measurement( self ):
+        """
+        Execute all listed measures
+        """
+        for m in self.__measures_names :
+            self.__measures[m].pset = self.pset
+            self.__measures[m].update_measure()
+            
+    def get_measure_value( self , name ):
+        """
+        get the value of the measure named 'name'
+        """
+        return self.__measures[name].value()
+    
+    
+    def get_measure_value_str( self , name ):
+        """
+        return a string containig the value of the measure
+        """
+        return self.__measures[name].value_str()
+    
+    
+    def get_measure( self , name ):
+        """
+        return the measure named 'name'
+        """
+        return self.__measures[name]
+    
+    def get_measures_names( self ):
+        """
+        Return a list containg the names of the executed measured.
+        """
+        return self.__measures_names
+    
+    def measures_cnt( self ):
+        return len( self.__measures )
+        
+    
+    def get_pset(self):
+        return self.__pset
+    
+    def set_pset( self , pset ):
+        self.__pset = pset
+        
+    pset = property( get_pset , set_pset )
+    
+    
+    def get_steps( self ):
+        return self.__steps
+    
+    def set_steps( self , steps ):
+        self.__steps = steps
+    
+    steps = property( get_steps , set_steps )
+    
+    
+    def update_fps(self):
+        """
+        Update the FPS, this method must be called every step.
+        
+        :returns: True if the FPS has been updated
+        """
+        if self.__fps_cnt == 0 :
+            self.__fps_init_time = time.time()
+            self.__fps_cnt += 1
+            return False
+            
+        elif self.__fps_cnt == self.__fps_steps :
+            et = time.time()
+            self.__fps = float(self.__fps_cnt) / ( et - self.__fps_init_time )
+            self.__fps_cnt = 0 
+            return True
+             
+        else :
+            self.__fps_cnt += 1
+            return False 
+    
+    def get_fps(self):
+        return self.__fps 
+    
+    fps = property( get_fps , doc="get the current FPS" )
+    
+    
+    def get_fps_steps(self):
+        return self.__fps_steps
+    
+    def set_fps_steps( self , stp ):
+        self.__fps_steps = stp
+    
+    fps_steps = property( get_fps_steps , set_fps_steps , doc="get and set the steps used for computing the fps" )
+    
+    
+    def get_fps_print( self ):
+        return self.__fps_print
+    
+    def set_fps_print( self , f ):
+        self.__fps_print = f 
+    
+    fps_print = property( get_fps_print , set_fps_print , doc="Toggle the printing of the FPS (True | False)")   
+    
+    
+    def set_xlim( self , xl ):
+        self.__xl = xl
+        
+    def get_xlim( self ):
+        return self.__xl
+ 
+    def set_ylim( self , yl ):
+        self.__yl = yl
+        
+    def get_ylim( self ):
+        return self.__yl    
+           
+    def set_zlim( self , zl ):
+        self.__zl = zl
+        
+    def get_zlim( self ):
+        return self.__zl
+           
+    xlim = property( get_xlim , set_xlim )
+    ylim = property( get_ylim , set_ylim )
+    zlim = property( get_zlim , set_zlim )
+     
+     
+    def get_trajectory( self ) :
+        return self.__trajectory
+    
+    def set_trajectory( self , tr ):
+        self.__trajectory = tr
+        
+    trajectory = property( get_trajectory , set_trajectory , doc="enable or disable the trajectory" )
+    
+    
+    def get_trajectory_step( self ) :
+        return self.__trajectory_step
+    
+    def set_trajectory_step( self , trs ):
+        self.__trajectory_step = trs
+        
+    trajectory_step = property( get_trajectory_step , set_trajectory_step , doc="set or get the step for drawing the trajectory" )
+
+     
+    def build_animation(self):
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+    
+    def data_stream(self):
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+        
+    def closing_procedure(self):
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+        
+    def start(self):
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )
+        
+    
+        
+
+        
+