PyParticles3 0.4.0__py3-none-any.whl

pyparticles/ode/euler_solver_constrained.py

@@ -0,0 +1,49 @@
+# 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.ode.ode_solver_constrained as osc
+
+class EulerSolverConstrained( osc.OdeSolverConstrained ) :
+    def __init__( self , force , p_set , dt , x_constraint=None , v_constraint=None ):
+        super(EulerSolverConstrained,self).__init__( force , p_set , dt , x_constraint=None , v_constraint=None )
+        
+        if x_constraint != None :
+            self.x_constraint = x_constraint
+        
+
+    def get_x_constraint(self):
+        return super(EulerSolverConstrained,self).get_x_constraint()
+    
+    def set_x_constraint(self ,  xc ):
+        super(EulerSolverConstrained,self).set_x_constraint( xc )
+        self.__free_inx = self.x_constraint.get_cx_free_indicies()
+        self.__csrt_inx = self.x_constraint.get_cx_indicies()
+    
+    x_constraint = property( get_x_constraint , set_x_constraint , doc="get and set the current positionals constraints" )
+    
+    
+    def __step__( self , dt ):
+
+        self.force.update_force( self.pset )
+        
+        self.pset.V[self.__free_inx,:] = self.pset.V[self.__free_inx,:] + self.force.A[self.__free_inx,:] * dt
+        self.pset.X[self.__free_inx,:] = self.pset.X[self.__free_inx,:] + self.pset.V[self.__free_inx,:] * dt
+        
+        self.pset.V[self.__csrt_inx,:] = 0.0
+        
+        self.pset.update_boundary() 

pyparticles/ode/leapfrog_solver.py

@@ -0,0 +1,37 @@
+# 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.ode.ode_solver as os
+
+class LeapfrogSolver( os.OdeSolver ) :
+    def __init__( self , force , p_set , dt ):
+        super(LeapfrogSolver,self).__init__( force , p_set , dt )
+        self.__Ai = np.zeros( self.force.A.shape )
+    
+    def __step__( self , dt ):
+            
+        self.pset.X[:] = self.pset.X + self.pset.V * dt + 0.5*self.force.A * dt**2.0
+        self.__Ai[:] = self.force.A
+        
+        self.force.update_force( self.pset )
+        
+        self.pset.V[:] = self.pset.V + 0.5 * ( self.__Ai + self.force.A ) * dt
+        
+        
+        self.pset.update_boundary() 
+

pyparticles/ode/leapfrog_solver_constrained.py

@@ -0,0 +1,53 @@
+# 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.ode.ode_solver_constrained as osc
+
+class LeapfrogSolverConstrained( osc.OdeSolverConstrained ) :
+    def __init__( self , force , p_set , dt , x_constraint=None , v_constraint=None ):
+        super(LeapfrogSolverConstrained,self).__init__( force , p_set , dt , x_constraint=None , v_constraint=None )
+        self.__Ai = np.zeros( self.force.A.shape )
+        
+        if x_constraint != None :
+            self.x_constraint = x_constraint
+        
+    def get_x_constraint(self):
+        return super(LeapfrogSolverConstrained,self).get_x_constraint()
+    
+    def set_x_constraint(self ,  xc ):
+        super(LeapfrogSolverConstrained,self).set_x_constraint( xc )
+        self.__free_inx = self.x_constraint.get_cx_free_indicies()
+        self.__csrt_inx = self.x_constraint.get_cx_indicies()
+    
+    x_constraint = property( get_x_constraint , set_x_constraint , doc="get and set the current positionals constraints" )
+    
+    
+    def __step__( self , dt ):
+        
+        self.pset.X[self.__free_inx,:] = self.pset.X[self.__free_inx,:] + self.pset.V[self.__free_inx,:] * dt + 0.5*self.force.A[self.__free_inx,:] * dt**2.0
+        self.__Ai[self.__free_inx,:] = self.force.A[self.__free_inx,:]
+        
+        self.force.update_force( self.pset )
+        
+        self.pset.V[self.__free_inx,:] = self.pset.V[self.__free_inx,:] + 0.5 * ( self.__Ai[self.__free_inx,:] + self.force.A[self.__free_inx,:] ) * dt
+        
+        self.pset.V[self.__csrt_inx,:] = 0.0
+        
+        #print( self.pset.V )
+        
+        self.pset.update_boundary() 

pyparticles/ode/midpoint_solver.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.
+#
+# 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.ode.ode_solver as os
+import pyparticles.pset.particles_set as ps
+
+class MidpointSolver( os.OdeSolver ) :
+    def __init__( self , force , p_set , dt ):
+        
+        super(MidpointSolver,self).__init__( force , p_set , dt )
+        
+        self.__mid_pset = ps.ParticlesSet( p_set.size , p_set.dim )
+    
+    
+    def __step__( self , dt ):
+    
+        self.__mid_pset.X[:] = self.pset.X[:] + dt/2.0 * self.pset.V
+        
+        self.force.update_force( self.__mid_pset )
+        
+        self.__mid_pset.V[:] = self.pset.V[:] + dt/2.0 * self.force.A
+        
+        self.pset.V[:] = self.pset.V[:] + dt * self.force.A
+        self.pset.X[:] = self.pset.X[:] + dt * self.__mid_pset.V[:]
+        
+        self.pset.update_boundary() 
+        self.force.update_force( self.pset )
+

pyparticles/ode/midpoint_solver_constrained.py

@@ -0,0 +1,60 @@
+# 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.ode.ode_solver_constrained as osc
+import pyparticles.pset.particles_set as ps
+
+class MidpointSolverConstrained( osc.OdeSolverConstrained ) :
+    
+    def __init__( self , force , p_set , dt , x_constraint=None , v_constraint=None ):
+        super(MidpointSolverConstrained,self).__init__( force , p_set , dt , x_constraint=None , v_constraint=None )
+        
+        self.__mid_pset = ps.ParticlesSet( p_set.size , p_set.dim )
+ 
+        if x_constraint != None :
+            self.x_constraint = x_constraint
+    
+    
+    def get_x_constraint(self):
+        return super(MidpointSolverConstrained,self).get_x_constraint()
+    
+    def set_x_constraint(self ,  xc ):
+        super(MidpointSolverConstrained,self).set_x_constraint( xc )
+        self.__free_inx = self.x_constraint.get_cx_free_indicies()
+        self.__csrt_inx = self.x_constraint.get_cx_indicies()
+    
+    x_constraint = property( get_x_constraint , set_x_constraint , doc="get and set the current positionals constraints" )
+ 
+
+
+    def __step__( self , dt ):
+    
+        
+        self.__mid_pset.X[self.__free_inx,:] = self.pset.X[self.__free_inx,:] + dt/2.0 * self.pset.V[self.__free_inx,:]
+        self.__mid_pset.X[self.__csrt_inx,:] = self.pset.X[self.__csrt_inx,:]
+        
+        self.force.update_force( self.__mid_pset )
+        
+        self.__mid_pset.V[self.__free_inx,:] = self.pset.V[self.__free_inx,:] + dt/2.0 * self.force.A[self.__free_inx,:]
+        
+        self.pset.V[self.__free_inx,:] = self.pset.V[self.__free_inx,:] + dt * self.force.A[self.__free_inx,:]
+        self.pset.X[self.__free_inx,:] = self.pset.X[self.__free_inx,:] + dt * self.__mid_pset.V[self.__free_inx,:]
+        
+        self.pset.update_boundary() 
+        self.force.update_force( self.pset )
+        

pyparticles/ode/ode_solver.py

@@ -0,0 +1,134 @@
+# 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
+
+import pyparticles.ode.sim_time as st
+
+class OdeSolver(object) :
+    """
+    Base abstract class for defining the integration method of the ordinary differential equation like Runge Kutta or Euler method,
+    the user must overide the method **__step__**
+    
+    Example (Euler method):
+    ::
+    
+        import numpy as np
+        import pyparticles.ode.ode_solver as os
+       
+        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() 
+    
+    Constructor:
+    
+    :param force:      the force model
+    :param p_set:      the particle set
+    :param dt:         delta time
+    """
+    def __init__( self , force , p_set , dt ):
+        self.__force = force
+        self.__p_set = p_set
+        self.__dt = dt
+        
+        self.__sim_time = st.SimTime( self )
+        
+        self.__steps_cnt = 0        
+    
+    def get_dt( self ):
+        return self.__dt
+
+    def set_dt( self , dt ):
+        self.__dt = dt
+
+    dt = property( get_dt , set_dt , doc="get and set the delta time of the step")
+    
+    
+    def get_steps(self):
+        return self.__steps_cnt
+    
+    def del_steps(self):
+        self.__steps_cnt = 0
+    
+    steps_cnt = property( get_steps , fdel=del_steps , doc="return the count of the performed steps")
+    
+    
+    def get_time(self):
+        return self.__sim_time.time
+    
+    def set_time( self , t0 ):
+        self.__sim_time.time = t0
+        
+    time = property( get_time , set_time , doc="get and set the current simulation time" )
+    
+    
+    def get_sim_time( self ):
+        return self.__sim_time
+    
+    sim_time = property( get_sim_time , doc="get the reference to the SimTime object, used for storing and sharing the current simulation time" )
+    
+    
+    def get_force( self ):
+        return self.__force
+    
+    def set_force( self , force ):
+        self.__force = force
+        
+    force = property( get_force , set_force , doc="get and set the used force model")
+    
+    
+    def update_force( self ):
+        self.__force.update_force( self.pset )
+    
+    def get_pset( self ):
+        return self.__p_set
+    
+    def set_pset( self , p_set ):
+        self.__p_set = p_set
+        
+    pset = property( get_pset , set_pset , "get and set the used particles set")
+    
+    
+    def step( self , dt=None ):
+        """
+        Perform an integration step. If the dt is not given (reccomended) it uses the stored *dt*.
+        You must alway use this method for executing a step.
+        """
+        if dt == None:
+            dt = self.dt
+        
+        self.__sim_time.time += dt
+        
+        self.__steps_cnt += 1
+        
+        self.__step__( dt )
+        
+    def __step__( self , dt ):
+        """
+        Abstract methos that contain the code for computing the new status of the particles system. This methos must be overidden by the user.
+        """
+        NotImplementedError(" %s : is virtual and must be overridden." % sys._getframe().f_code.co_name )

pyparticles/ode/ode_solver_constrained.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.
+#
+# 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.ode.ode_solver as os
+
+class OdeSolverConstrained( os.OdeSolver ) :
+    def __init__(self , force , p_set , dt , x_constraint=None , v_constraint=None ):
+        
+        self.__x_constr = x_constraint
+        self.__v_constr = v_constraint
+        
+        super(OdeSolverConstrained,self).__init__( force , p_set , dt )
+        
+
+    def get_x_constraint(self):
+        """
+        returns a reference to the current positionals constraints
+        """
+        return self.__x_constr
+    
+    def set_x_constraint(self ,  xc ):
+        """
+        set the new positionals contraints
+        """
+        self.__x_constr = xc
+        self.__x_constr.pset = self.pset
+    
+    x_constraint = property( get_x_constraint , set_x_constraint , doc="get and set the current positionals constraints" )

pyparticles/ode/runge_kutta_solver.py

@@ -0,0 +1,79 @@
+# 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.ode.ode_solver as os
+import pyparticles.pset.particles_set as ps
+
+class RungeKuttaSolver( os.OdeSolver ) :
+    def __init__( self , force , p_set , dt ):
+        
+        super(RungeKuttaSolver,self).__init__( force , p_set , dt )
+        
+        self.__Kv1 = np.zeros( self.force.A.shape )
+        self.__Kv2 = np.zeros( self.force.A.shape )
+        self.__Kv3 = np.zeros( self.force.A.shape )
+        self.__Kv4 = np.zeros( self.force.A.shape )
+        
+        self.__Kx1 = np.zeros( self.force.A.shape )
+        self.__Kx2 = np.zeros( self.force.A.shape )
+        self.__Kx3 = np.zeros( self.force.A.shape )
+        self.__Kx4 = np.zeros( self.force.A.shape )
+        
+        self.__tmp_pset = ps.ParticlesSet( p_set.size , p_set.dim )
+    
+    
+    def __step__( self , dt ):
+    
+        self.__tmp_pset.V[:] = self.pset.V[:]
+          
+        # K1
+        self.__Kv1[:] = self.force.A
+        self.__Kx1[:] = self.pset.V
+        
+        # K2
+        self.__tmp_pset.X[:] = self.pset.X + dt/2.0*self.__Kx1[:]
+        self.force.update_force( self.__tmp_pset )
+        
+        self.__Kv2[:] = self.force.A
+        self.__Kx2[:] = self.pset.V + dt/2.0*self.__Kv1[:]
+        
+        #K3
+        self.__tmp_pset.X[:] = self.pset.X + dt/2.0*self.__Kx2[:]
+        self.force.update_force( self.__tmp_pset )
+        
+        self.__Kv3[:] = self.force.A
+        self.__Kx3[:] = self.pset.V + dt/2.0*self.__Kv2[:]
+        
+        #K4
+        self.__tmp_pset.X[:] = self.pset.X + dt*self.__Kx3[:]
+        self.force.update_force( self.__tmp_pset )
+        
+        self.__Kv4[:] = self.force.A
+        self.__Kx4[:] = self.pset.V + dt*self.__Kv3[:]
+        
+
+        
+        self.pset.V[:] = self.pset.V[:] + dt/6.0 * ( self.__Kv1 + 2.0*self.__Kv2 + 2.0*self.__Kv3 + self.__Kv4 )
+        self.pset.X[:] = self.pset.X[:] + dt/6.0 * ( self.__Kx1 + 2.0*self.__Kx2 + 2.0*self.__Kx3 + self.__Kx4 )
+        
+        #self.pset.X[:] = self.pset.X[:] + dt*self.pset.V[:]
+                
+        self.pset.update_boundary() 
+        self.force.update_force( self.pset )
+        
+        

pyparticles/ode/runge_kutta_solver_constrained.py

@@ -0,0 +1,98 @@
+# 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.ode.ode_solver_constrained as osc
+import pyparticles.pset.particles_set as ps
+
+
+
+class RungeKuttaSolverConstrained( osc.OdeSolverConstrained ) :
+    def __init__( self , force , p_set , dt , x_constraint=None , v_constraint=None ):
+        super(RungeKuttaSolverConstrained,self).__init__( force , p_set , dt , x_constraint=None , v_constraint=None )
+        
+        if x_constraint != None :
+            self.x_constraint = x_constraint
+            
+        self.__Kv1 = np.zeros( self.force.A.shape )
+        self.__Kv2 = np.zeros( self.force.A.shape )
+        self.__Kv3 = np.zeros( self.force.A.shape )
+        self.__Kv4 = np.zeros( self.force.A.shape )
+        
+        self.__Kx1 = np.zeros( self.force.A.shape )
+        self.__Kx2 = np.zeros( self.force.A.shape )
+        self.__Kx3 = np.zeros( self.force.A.shape )
+        self.__Kx4 = np.zeros( self.force.A.shape )
+        
+        self.__tmp_pset = ps.ParticlesSet( p_set.size , p_set.dim )
+        
+    
+    def get_x_constraint(self):
+        return super(RungeKuttaSolverConstrained,self).get_x_constraint()
+    
+    def set_x_constraint(self ,  xc ):
+        super(RungeKuttaSolverConstrained,self).set_x_constraint( xc )
+        self.__fi = self.x_constraint.get_cx_free_indicies()
+        self.__ci = self.x_constraint.get_cx_indicies()
+    
+    x_constraint = property( get_x_constraint , set_x_constraint , doc="get and set the current positionals constraints" )
+        
+        
+    def __step__( self , dt ):
+    
+        self.__tmp_pset.V[:] = self.pset.V[:]  
+        
+        # K1
+        self.__Kv1[self.__fi,:] = self.force.A[self.__fi,:]
+        self.__Kx1[self.__fi,:] = self.pset.V[self.__fi,:]
+        
+        # K2
+        self.__tmp_pset.X[self.__fi,:] = self.pset.X[self.__fi,:] + dt/2.0*self.__Kx1[self.__fi,:]
+        self.__tmp_pset.X[self.__ci,:] = self.pset.X[self.__ci,:]
+        self.force.update_force( self.__tmp_pset )
+        
+        self.__Kv2[self.__fi,:] = self.force.A[self.__fi,:]
+        self.__Kx2[self.__fi,:] = self.pset.V[self.__fi,:] + dt/2.0*self.__Kv1[self.__fi,:]
+        
+        #K3
+        self.__tmp_pset.X[self.__fi,:] = self.pset.X[self.__fi,:] + dt/2.0*self.__Kx2[self.__fi,:]
+        self.__tmp_pset.X[self.__ci,:] = self.pset.X[self.__ci,:]
+        self.force.update_force( self.__tmp_pset )
+        
+        self.__Kv3[self.__fi,:] = self.force.A[self.__fi,:]
+        self.__Kx3[self.__fi,:] = self.pset.V[self.__fi,:] + dt/2.0*self.__Kv2[self.__fi,:]
+        
+        #K4
+        self.__tmp_pset.X[self.__fi,:] = self.pset.X[self.__fi,:] + dt*self.__Kx3[self.__fi,:]
+        self.__tmp_pset.X[self.__ci,:] = self.pset.X[self.__ci,:]
+        self.force.update_force( self.__tmp_pset )
+        
+        self.__Kv4[self.__fi,:] = self.force.A[self.__fi,:]
+        self.__Kx4[self.__fi,:] = self.pset.V[self.__fi,:] + dt*self.__Kv3[self.__fi,:]
+        
+
+        
+        self.pset.V[self.__fi,:] = self.pset.V[self.__fi,:] + dt/6.0 * ( self.__Kv1[self.__fi,:] + 2.0*self.__Kv2[self.__fi,:] + 2.0*self.__Kv3[self.__fi,:] + self.__Kv4[self.__fi,:] )
+        self.pset.X[self.__fi,:] = self.pset.X[self.__fi,:] + dt/6.0 * ( self.__Kx1[self.__fi,:] + 2.0*self.__Kx2[self.__fi,:] + 2.0*self.__Kx3[self.__fi,:] + self.__Kx4[self.__fi,:] )
+        
+        self.pset.V[self.__ci,:] = 0.0
+        
+        self.pset.update_boundary() 
+        self.force.update_force( self.pset )
+        
+        
+    

pyparticles/ode/sim_time.py

@@ -0,0 +1,56 @@
+# 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/>.
+
+
+class SimTime( object ):
+    """
+    Class used for storing the current simulation time:
+    
+    Constructor
+    
+    :param controller: a reference to the object that control the simulation time
+    
+    """
+    def __init__( self , controller ):
+        self.__time = 0.0
+        self.__controller = controller
+    
+    def get_time( self ):
+        """
+        get the current time
+        """
+        return self.__time
+    
+    def set_time( self , t ):
+        """
+        set the current time
+        """
+        self.__time = t
+        
+    time = property( get_time , set_time , doc="get and set the current simulation time" )
+    
+    
+    def get_controller( self ):
+        r"""
+        Get a reference to the simulation time controller, normally an ODE solver
+        
+        :returns the reference to the ODE solver object
+        """
+        return self.__controller
+    
+    controller = property( get_controller , doc="get the reference to the time controller" )
+    
+