PyParticles3 0.4.0__py3-none-any.whl

pyparticles/animation/test_animation.py

@@ -0,0 +1,310 @@
+# 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.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.midpoint_solver as mps
+import pyparticles.ode.stormer_verlet_solver as svs
+
+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
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import pyparticles.forces.const_force as cf
+import pyparticles.forces.drag as dr
+import pyparticles.forces.multiple_force as mf
+import pyparticles.forces.linear_spring as ls
+import pyparticles.forces.damping as da
+
+import pyparticles.pset.constrained_x as csx
+import pyparticles.pset.constrained_force_interactions as cfi
+
+from matplotlib.ticker import FuncFormatter
+
+
+
+def free_fall( t , m=1. , g=10. , k=1. ):
+    z = (np.sqrt(2.*g*k)*t*m**2.-2.*m**(5./2.)*np.log((1./2.)*np.exp(np.sqrt(2.)*np.sqrt(g*k)*t/np.sqrt(m))+1./2.))/(m**(3./2.)*k)
+    return np.array( [ 0.0 , 0.0 , z ] )
+
+def harmonic( t ):
+    a = np.cos( t ) / np.sqrt(3.0)
+    return np.array( [ a , a , a ] )
+
+def damp_harmonic( t ):
+    a = (1./15.)*np.sqrt(15.)*np.exp(-(1./4.)*t)*np.sin((1./4.)*np.sqrt(15.)*t)+np.exp(-(1./4.)*t)*np.cos((1./4.)*np.sqrt(15.)*t)
+    a = a / np.sqrt(3.0)
+
+    return np.array( [ a , a , a ] )
+
+
+class TestAnimation( pan.Animation ):
+    """
+    Test the free fall with the fluid drag
+    """
+    def __init__(self):
+        super( TestAnimation , self ).__init__()
+        
+        self.__analytical_sol = free_fall
+ 
+    def set_analytical_sol( self , f ):
+        self.__analytical_sol = f
+        
+    def get_analytical_sol( self ):
+        return self.__analytical_sol
+        
+    analytical_sol = property( get_analytical_sol , set_analytical_sol )
+ 
+ 
+ 
+    def set_ip( self , i ):
+        self.__ip = i
+        
+    def get_ip( self ):
+        return self.__ip    
+    
+    ip = property( get_ip , set_ip )
+ 
+ 
+    def init_pset(self):
+        self.pset.M[:] = 1.0
+        self.pset.V[:] = 0.0
+        self.pset.X[:] = 0.0
+ 
+    def build_animation(self):
+        
+        self.steps = 3000
+        
+        self.pset = ps.ParticlesSet( 1 , 3 )
+        
+        self.ip = 0
+        
+        self.pset.M[:] = 1.0
+        self.pset.V[:] = 0.0
+        
+        self.t = np.zeros(( self.steps ))
+        self.x = np.zeros(( self.steps , self.pset.dim ))
+        
+        self.xn = np.zeros(( self.steps , self.pset.dim ))
+        
+        constf = cf.ConstForce( self.pset.size , u_force=[ 0 , 0 , -10.0 ] , dim=self.pset.dim )
+        drag = dr.Drag( self.pset.size , Consts=1.0 )
+        
+        multi = mf.MultipleForce( self.pset.size )
+        
+        multi.append_force( constf )
+        multi.append_force( drag )
+        
+        multi.set_masses( self.pset.M )
+        
+        dt = 0.001
+        
+        self.odes = dict()
+        
+        self.odes["Euler      "] = els.EulerSolver( multi , self.pset , dt ) 
+        self.odes["Runge Kutta"] = rks.RungeKuttaSolver( multi , self.pset , dt ) 
+        self.odes["Leap Frog  "] = lps.LeapfrogSolver( multi , self.pset , dt ) 
+        self.odes["MidPoint   "] = mps.MidpointSolver( multi , self.pset , dt ) 
+        self.odes["Verlet     "] = svs.StormerVerletSolver( multi , self.pset , dt ) 
+        
+    def data_stream( self ):
+        
+        for i in range( self.steps ) :
+            
+            self.t[i] = self.ode_solver.time
+            
+            #print( self.t[i] )
+            
+            self.x[i,:] = self.analytical_sol( self.t[i] )
+        
+            self.xn[i,:] = self.pset.X[self.ip,:]
+            
+            #print( " t: %f , x: %s , xn: %s " % ( self.t[i] , self.x[i,:] , self.xn[i,:] ) )
+            self.ode_solver.step()
+            
+            
+
+    def start(self):
+        
+        print( "Start testing:" )
+        
+        j = 0
+        
+        print("")
+        print("Errors:")
+        
+        #plt.ion()
+        
+        for ky in self.odes.keys():
+            
+            self.init_pset()
+            
+            self.ode_solver = self.odes[ky]
+            self.data_stream()
+        
+            err = np.sqrt( np.sum( (self.x-self.xn)**2 , 1 ) )
+        
+            merr = np.mean( err )
+        
+            mt = np.array( [ self.t[0] , self.t[self.steps-1] ] )
+            me = np.array( [ merr , merr ] )
+            
+            print( " %s - mean err: %f " % ( ky , merr ) )
+        
+            ax = plt.subplot( 230+j+1 )
+                    
+            ax.yaxis.set_major_formatter(FuncFormatter(lambda x, pos: ('%.1f')%(x*1e3)))
+        
+            p1, = plt.plot( self.t[:] , err , linewidth=2 )
+            p2, = plt.plot( mt , me , linewidth=1 , color="g" )
+            
+            plt.title( "Absolute error: %s " % ky )
+            plt.xlabel( "Time" )
+            plt.ylabel( "Abs error [1e-3]" )
+        
+            plt.legend([p1, p2], ["Abs Error", "Mean"] , loc=4 )
+        
+            plt.grid(1)
+            
+            plt.draw()
+            
+            j += 1
+        
+        plt.show()
+        
+
+        
+class TestAnimationHarmonic( TestAnimation ):
+    """
+    Test the harmonic motion with two particles.
+    """
+    
+    def __init__(self):
+        self.analytical_sol = harmonic
+
+    def init_pset(self):
+        self.pset.X[0,:] = 0.0
+        self.pset.X[1,:] = 1.0 / np.sqrt(3)
+        self.pset.M[:] = 1.0
+        self.pset.V[:] = 0.0
+        
+    def build_animation(self):
+        
+        self.steps = 6000
+        dt = 0.004
+        
+        self.ip = 1
+        
+        self.pset = ps.ParticlesSet( 2 , 3 )
+        self.pset.M[:] = 1.0
+        self.pset.V[:] = 0.0
+        
+        self.pset.X[0,:] = 0.0
+        self.pset.X[1,:] = 1.0 / np.sqrt(3)
+        
+        ci = np.array( [ 0 ] )
+        cx = np.array( [ 0.0 , 0.0 , 0.0 ] )
+        
+        costrs = csx.ConstrainedX( self.pset )
+        costrs.add_x_constraint( ci , cx )
+        
+        self.t = np.zeros(( self.steps ))
+        self.x = np.zeros(( self.steps , self.pset.dim ))
+        
+        self.xn = np.zeros(( self.steps , self.pset.dim ))
+                
+        spring = ls.LinearSpring( self.pset.size , self.pset.dim , Consts=1.0 )
+        
+        spring.set_masses( self.pset.M )
+               
+        self.odes = dict()
+        
+        self.odes["Euler      "] = asc.EulerSolverConstrained( spring , self.pset , dt , costrs )
+        self.odes["Runge Kutta"] = rkc.RungeKuttaSolverConstrained( spring , self.pset , dt , costrs )
+        self.odes["Leap Frog  "] = lpc.LeapfrogSolverConstrained( spring , self.pset , dt , costrs )
+        self.odes["MidPoint   "] = mdc.MidpointSolverConstrained( spring , self.pset , dt , costrs )
+        self.odes["Verlet     "] = svc.StormerVerletSolverConstrained( spring , self.pset , dt , costrs )
+
+
+class TestAnimationDampedHarmonic( TestAnimation ):
+    """
+    Test the damped harmonic motion with two particles.
+    """
+    
+    def __init__(self):
+        self.analytical_sol = damp_harmonic
+
+    def init_pset(self):
+        self.pset.X[0,:] = 0.0
+        self.pset.X[1,:] = 1.0 / np.sqrt(3)
+        self.pset.M[:] = 1.0
+        self.pset.V[:] = 0.0
+        
+    def build_animation(self):
+        
+        self.steps = 6000
+        dt = 0.004
+        
+        self.ip = 1
+        
+        self.pset = ps.ParticlesSet( 2 , 3 )
+        self.pset.M[:] = 1.0
+        self.pset.V[:] = 0.0
+        
+        self.pset.X[0,:] = 0.0
+        self.pset.X[1,:] = 1.0 / np.sqrt(3)
+        
+        ci = np.array( [ 0 ] )
+        cx = np.array( [ 0.0 , 0.0 , 0.0 ] )
+        
+        costrs = csx.ConstrainedX( self.pset )
+        costrs.add_x_constraint( ci , cx )
+        
+        self.t = np.zeros(( self.steps ))
+        self.x = np.zeros(( self.steps , self.pset.dim ))
+        
+        self.xn = np.zeros(( self.steps , self.pset.dim ))
+                
+        spring = ls.LinearSpring( self.pset.size , self.pset.dim , Consts=1.0 )
+        damp = da.Damping( self.pset.size , self.pset.dim , Consts=0.5 )
+        
+        multi = mf.MultipleForce( self.pset.size )
+        
+        multi.append_force( spring )
+        multi.append_force( damp )
+        
+        multi.set_masses( self.pset.M )
+               
+        self.odes = dict()
+        
+        self.odes["Euler      "] = asc.EulerSolverConstrained( multi , self.pset , dt , costrs )
+        self.odes["Runge Kutta"] = rkc.RungeKuttaSolverConstrained( multi , self.pset , dt , costrs )
+        self.odes["Leap Frog  "] = lpc.LeapfrogSolverConstrained( multi , self.pset , dt , costrs )
+        self.odes["MidPoint   "] = mdc.MidpointSolverConstrained( multi , self.pset , dt , costrs )
+        self.odes["Verlet     "] = svc.StormerVerletSolverConstrained( multi , self.pset , dt , costrs )

pyparticles/demo/__init__.py

@@ -0,0 +1,33 @@
+# 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 glob
+import os
+import sys
+
+import pyparticles.animation as _animation
+from pyparticles.animation import animated_ogl_compat as _animated_ogl_compat
+
+# All official demos were written against the legacy animated_ogl module.
+# Route both the module cache and package attribute to the modern FreeGLUT
+# compatibility layer.  animated_ogl_compat itself keeps a private reference
+# to the original renderer.
+_animation.animated_ogl = _animated_ogl_compat
+sys.modules["pyparticles.animation.animated_ogl"] = _animated_ogl_compat
+
+__all__ = [ os.path.splitext( os.path.basename(f) )[0] for f in glob.glob(os.path.dirname(os.path.abspath(__file__))+"/*.py")]
+

pyparticles/demo/bubble.py

@@ -0,0 +1,106 @@
+# 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.pset.opencl_context as occ
+import pyparticles.pset.rand_cluster as rc
+import pyparticles.pset.rebound_boundary as rb
+
+import pyparticles.forces.pseudo_bubble as pb
+import pyparticles.forces.const_force as cf
+import pyparticles.forces.drag as dr
+import pyparticles.forces.multiple_force as mf
+
+import pyparticles.ode.stormer_verlet_solver as svs
+
+import pyparticles.animation.animated_ogl as aogl
+
+from pyparticles.utils.pypart_global import test_pyopencl
+
+
+def bubble():
+    """Pseudo bubble simulation."""
+    ocl_ok = test_pyopencl()
+
+    if ocl_ok:
+        pcnt = 9000
+        r_min = 0.5
+    else:
+        pcnt = 700
+        r_min = 1.5
+
+    steps = 1000000
+    dt = 0.01
+
+    pset = ps.ParticlesSet(pcnt, dtype=np.float32)
+    rand_c = rc.RandCluster()
+    rand_c.insert3(
+        X=pset.X,
+        M=pset.M,
+        start_indx=0,
+        n=pset.size,
+        radius=3.0,
+        mass_rng=(0.5, 0.8),
+        r_min=0.0,
+    )
+
+    if ocl_ok:
+        occx = occ.OpenCLcontext(
+            pset.size,
+            pset.dim,
+            occ.OCLC_X | occ.OCLC_V | occ.OCLC_A | occ.OCLC_M,
+        )
+        bubble_force = pb.PseudoBubbleOCL(
+            pset.size,
+            pset.dim,
+            Consts=(r_min, 10),
+            ocl_context=occx,
+        )
+        drag = dr.DragOCL(
+            pset.size,
+            pset.dim,
+            Consts=0.01,
+            ocl_context=occx,
+        )
+    else:
+        bubble_force = pb.PseudoBubble(pset.size, pset.dim, Consts=(r_min, 10))
+        drag = dr.Drag(pset.size, pset.dim, Consts=0.01)
+
+    constf = cf.ConstForce(pset.size, dim=pset.dim, u_force=[0, 0, -10.0])
+
+    multif = mf.MultipleForce(pset.size, pset.dim)
+    multif.append_force(bubble_force)
+    multif.append_force(constf)
+    multif.append_force(drag)
+    multif.set_masses(pset.M)
+
+    solver = svs.StormerVerletSolver(multif, pset, dt)
+
+    pset.set_boundary(rb.ReboundBoundary(bound=(-5.0, 5.0)))
+
+    a = aogl.AnimatedGl()
+    a.ode_solver = solver
+    a.pset = pset
+    a.steps = steps
+
+    if ocl_ok:
+        a.draw_particles.set_draw_model(a.draw_particles.DRAW_MODEL_VECTOR)
+
+    a.init_rotation(-80, [0.7, 0.05, 0])
+    a.build_animation()
+    a.start()

pyparticles/demo/electromagnetic_demo.py

@@ -0,0 +1,128 @@
+# PyParticles : Particles simulation in python
+# Copyright (C) 2012  Simone Riva mail: simone.rva {at} gmail {dot} com
+#
+# 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.pset.default_boundary as db
+
+import pyparticles.forces.electromagnetic_field as elmf
+
+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.animation.animated_ogl as aogl
+import pyparticles.ogl.draw_particles_ogl as drp
+
+def electric_field( E , X ):
+    E[:] = np.array( [ 10 , 10 , 10 ] )
+    
+
+def magnetic_field( B , X ):
+    #B[:] = 1000.0 * np.sin( 500.0 * X )
+    B[:] = np.array( [ 0 , 0 , 1000 ] )
+    
+
+def magf_color( RGBA , X ):
+    RGBA[:] = np.array([ 0.4 , 0.4 , 1.0 , 0.6 ])
+
+def elf_color( RGBA , X ):
+    RGBA[:] = np.array([ 0.4 , 1.0 , 0.4 , 0.6 ])
+
+def default_pos( pset , indx ):
+    pset.X[indx,:] = 0.0
+    pset.V[indx,:] = ( ( np.random.rand( len(indx) , 3 ) - 0.5 ) / 3.0 )
+
+
+def electromag_field():
+    """
+    Electrimagnetic field demo
+    """
+    
+    steps = 1000000
+    size = 25000
+    dt = 1e-4
+    
+    qe = 1.60217646e-19 
+    
+    me = 9.10938188e-31
+    mp = 1.67262158e-18
+    
+    pset = ps.ParticlesSet( size , charge=True )
+    
+    pset.X[:] = 10.0e-3 * ( ( 2.0*np.random.rand( size , 3 ) - 1.0 )  )
+    
+    pset.Q[:] = qe * np.sign( np.random.rand( size , 1 ) - 0.5 )
+    
+    pset.V[:] = 0.5 * ( ( np.random.rand( size , 3 ) - 0.5 ) / 2.0 )
+     
+    pset.M[:] = mp
+    
+    elmag = elmf.ElectromagneticField( pset.size , dim=pset.dim , m=pset.M , q=pset.Q )
+    
+    elmag.append_electric_field( electric_field )
+    elmag.append_magnetic_field( magnetic_field )
+    
+    #solver = els.EulerSolver( elmag , pset , dt )
+    #solver = lps.LeapfrogSolver( elmag , pset , dt )
+    #solver = svs.StormerVerletSolver( elmag , pset , dt )
+    #solver = rks.RungeKuttaSolver( elmag , pset , dt )    
+    solver = mds.MidpointSolver( elmag , pset , dt )
+    
+    pset.unit = 2e-3
+    pset.mass_unit = 1e-3   
+    
+    bound = db.DefaultBoundary( ( -pset.unit*5.0 , pset.unit*5.0 ) , dim=3 , defualt_pos=default_pos )
+    pset.set_boundary(bound)
+    
+    pset.enable_log( True , log_max_size=200 )
+    
+    solver.update_force()
+    
+    a = aogl.AnimatedGl()
+    
+    a.ode_solver = solver
+    
+    a.trajectory = False
+    
+    a.xlim = ( -pset.unit*5.0 , pset.unit*5.0 )
+    a.ylim = ( -pset.unit*5.0 , pset.unit*5.0 )
+    a.zlim = ( -pset.unit*5.0 , pset.unit*5.0 )
+    
+    a.add_vector_field_fun( magnetic_field , 2000.0 , pset.unit , color_fun=magf_color )
+    a.add_vector_field_fun( electric_field , 50.0 ,  pset.unit , color_fun=elf_color )
+    
+    a.draw_vector_field = False
+    
+    a.pset = pset
+    a.steps = steps
+    
+    a.draw_particles.color_fun = drp.charged_particles_color
+    
+    a.draw_particles.vect_color_fun = drp.charged_particles_vect_color
+    
+    a.draw_particles.set_draw_model( a.draw_particles.DRAW_MODEL_VECTOR )
+    
+    a.build_animation()
+        
+    a.start()
+    
+    return
+    

pyparticles/demo/electrostatic_demo.py

@@ -0,0 +1,126 @@
+# 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.electrostatic as esf
+
+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.pset.rand_cluster as rc
+import pyparticles.pset.rebound_boundary as rb
+
+import pyparticles.animation.animated_ogl as aogl
+import pyparticles.ogl.draw_particles_ogl as drp
+
+import sys
+
+def electro():
+    """
+    Electrostatic demo
+    """
+    
+    steps = 1000000
+    dt = 0.01
+    
+    r_min=1.5
+    
+    Ke = 8.9875517873681764e9
+    qe = 1.60217646e-19 * 1.0e8
+    
+    me = 9.10938188e-31
+    mp = 1.67262158e-18
+    
+    rand_c = rc.RandCluster()
+    
+    pset = ps.ParticlesSet( 10 , charge=True )
+    
+    pset.Q[:5] = qe
+    pset.Q[5:10] = -qe
+    
+    pset.M[:] = 1e-3
+    
+    pset.V[:] = 0.0
+    
+    pset.X[:] = 1.0e-3 * np.array( [
+                            [ 0.0 , 0.0 , 0.0  ] ,
+                            [ 0.0 , 0.0 , 1.0  ] ,
+                            [ 0.0 , 0.0 , -1.0  ] ,
+                            [ 0.0 , 1.0 , 1.0  ] ,
+                            [ -1.0 , -1.0 , -1.0  ] ,
+                            [ 2.0 , -2.0 , 4.0  ] ,
+                            [ 4.0 , 7.0 , 2.0  ] ,
+                            [ -3.0 , -5.0 , 1.0  ] ,
+                            [ 4.0 , 4.0 , -7.0  ] ,
+                            [ 2.0 , 8.0 , -6.0  ] 
+                            ]
+                        )
+    
+    #rand_c.insert3( X=pset.X ,
+    #                M=pset.M ,
+    #                start_indx=0 ,
+    #                n=pset.size ,
+    #                radius=5.0 ,
+    #                mass_rng=(0.5,0.8) ,
+    #                r_min=0.0 )
+    
+    elecs = esf.Electrostatic( pset.size , dim=3 , Consts=Ke )
+
+    
+    elecs.set_masses( pset.M )
+    elecs.set_charges( pset.Q )
+    
+    #solver = els.EulerSolver( multif , pset , dt )
+    #solver = lps.LeapfrogSolver( lennard_jones , pset , dt )
+    #solver = svs.StormerVerletSolver( multif , pset , dt )
+    solver = rks.RungeKuttaSolver( elecs , pset , dt )    
+    #solver = mds.MidpointSolver( lennard_jones , pset , dt ) 
+    
+    bound = rb.ReboundBoundary( bound=( -10.0e-3 , 10.0e-3 ) )
+    pset.set_boundary( bound )
+    
+    pset.unit = 2e-3
+    pset.mass_unit = 1e-3
+    
+    pset.enable_log( True , log_max_size=1000 )
+    
+    solver.update_force()
+    
+    a = aogl.AnimatedGl()
+    
+    a.ode_solver = solver
+    
+    a.trajectory = True
+    
+    a.pset = pset
+    a.steps = steps
+    
+    a.draw_particles.color_fun = drp.charged_particles_color
+    
+    a.build_animation()
+        
+    a.start()
+    
+    return