Merged in more-bug-fixes (pull request #177)

Bunch of handy fixes/features

pysph/base/cython_generator.py

@@ -208,7 +208,8 @@ def _get_c_method_spec(self, name, returns, args):
         c_ret = 'double' if returns else 'void'
         c_arg_def = ', '.join(c_args)
         if self._config.use_openmp:
-            gil = " nogil" if name != "reduce" else ""
+            ignore = ['reduce', 'converged']
+            gil = " nogil" if name not in ignore else ""
         else:
             gil = ""
         cdefn = 'cdef inline {ret} {name}({arg_def}){gil}:'.format(
@@ -312,11 +313,9 @@ def matrix(size):
             sz = matrix(eval(code[7:-1]))
             defn = 'cdef double %s%s'%(name, sz)
             return defn
-        elif code.startswith('cPoint'):
-            defn = 'cdef cPoint %s'%name
-            return defn
         else:
-            raise RuntimeError('Unknown declaration %s'%declare)
+            defn = 'cdef {type} {name}'.format(type=code, name=name)
+            return defn
 
     def _parse_function(self, obj):
         c_code, py_code = self._get_method_wrapper(obj, indent=' '*4)

pysph/base/tests/test_cython_generator.py

@@ -37,6 +37,14 @@ def func(self, d_idx, d_x=[0.0, 0.0]):
         vec = declare('matrix((3,))')
         vec[0] = d_x[d_idx]
 
+class EqWithDeclare:
+    def func(self, d_idx, d_x=[0.0, 0.0]):
+        val = declare('float')
+        val = d_x[d_idx]
+        index = declare('unsigned int')
+        index = d_idx
+
+
 def func_with_return(d_idx, d_x, x=0.0):
     x += 1
     return d_x[d_idx] + x
@@ -247,6 +255,23 @@ def __init__(self, **kwargs):
         """)
         self.assert_code_equal(cg.get_code().strip(), expect.strip())
 
+    def test_method_with_declare(self):
+        cg = CythonGenerator()
+        cg.parse(EqWithDeclare())
+        expect = dedent("""
+        cdef class EqWithDeclare:
+            def __init__(self, **kwargs):
+                for key, value in kwargs.iteritems():
+                    setattr(self, key, value)
+
+            cdef inline void func(self, long d_idx, double* d_x):
+                cdef float val
+                val = d_x[d_idx]
+                cdef unsigned int index
+                index = d_idx
+        """)
+        self.assert_code_equal(cg.get_code().strip(), expect.strip())
+
     def test_method_with_known_types(self):
         cg = CythonGenerator(
             known_types={'WIJ':0.0, 'DWIJ':[0.0, 0.0, 0.0],

pysph/sph/equation.py

@@ -294,6 +294,8 @@ def get_predefined_types(precomp):
     the precomputed symbols.
     """
     result = {'DT_ADAPT':[0.0, 0.0, 0.0],
+              'dt': 0.0,
+              't': 0.0,
               'dst': KnownType('ParticleArrayWrapper'),
               'src': KnownType('ParticleArrayWrapper')}
     for sym, value in precomp.iteritems():
@@ -324,7 +326,7 @@ class Equation(object):
     ##########################################################################
     # `object` interface.
     ##########################################################################
-    def __init__(self, dest, sources=None, name=None):
+    def __init__(self, dest, sources=None):
         r"""
         Parameters
         ----------
@@ -338,8 +340,8 @@ def __init__(self, dest, sources=None, name=None):
                                                                 else None
         # Does the equation require neighbors or not.
         self.no_source = self.sources is None
-        self.name = self.__class__.__name__ if name is None else name
-        # The name of the variable used in the compliled AccelerationEval
+        self.name = self.__class__.__name__
+        # The name of the variable used in the compiled AccelerationEval
         # instance.
         self.var_name = ''
 

pysph/sph/iisph.py

@@ -21,7 +21,7 @@ def initialize(self):
 
     def stage1(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w,
                d_uadv, d_vadv, d_wadv, d_au, d_av, d_aw,
-               d_ax, d_ay, d_az, dt=0.0):
+               d_ax, d_ay, d_az, dt):
         d_u[d_idx] = d_uadv[d_idx] + dt * d_au[d_idx]
         d_v[d_idx] = d_vadv[d_idx] + dt * d_av[d_idx]
         d_w[d_idx] = d_wadv[d_idx] + dt * d_aw[d_idx]

pysph/sph/integrator_cython.mako

@@ -86,6 +86,7 @@ cdef class Integrator:
         cdef long d_idx
         cdef ParticleArrayWrapper dst
         cdef double dt = self.dt
+        cdef double t = self.t
         ${indent(helper.get_array_declarations(method), 2)}
 
         % for dest in sorted(helper.object.steppers.keys()):

pysph/sph/integrator_cython_helper.py

@@ -51,10 +51,11 @@ def get_stepper_code(self):
             cls = stepper.__class__.__name__
             classes[cls] = stepper
 
+        known_types = dict(self.acceleration_eval_helper.known_types)
+        known_types.update(dict(t=0.0, dt=0.0))
+        code_gen = CythonGenerator(known_types=known_types)
+
         wrappers = []
-        code_gen = CythonGenerator(
-            known_types=self.acceleration_eval_helper.known_types
-        )
         for cls in sorted(classes.keys()):
             code_gen.parse(classes[cls])
             wrappers.append(code_gen.get_code())

pysph/sph/integrator_step.py

@@ -22,7 +22,7 @@ class EulerStep(IntegratorStep):
     def initialize(self):
         pass
     def stage1(self, d_idx, d_u, d_v, d_w, d_au, d_av, d_aw, d_x, d_y,
-                  d_z, d_rho, d_arho, dt=0.0):
+                  d_z, d_rho, d_arho, dt):
         d_u[d_idx] += dt*d_au[d_idx]
         d_v[d_idx] += dt*d_av[d_idx]
         d_w[d_idx] += dt*d_aw[d_idx]
@@ -63,7 +63,7 @@ def initialize(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
 
     def stage1(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                    d_u0, d_v0, d_w0, d_u, d_v, d_w, d_rho0, d_rho, d_au, d_av,
-                   d_aw, d_ax, d_ay, d_az, d_arho, dt=0.0):
+                   d_aw, d_ax, d_ay, d_az, d_arho, dt):
         dtb2 = 0.5*dt
         d_u[d_idx] = d_u0[d_idx] + dtb2*d_au[d_idx]
         d_v[d_idx] = d_v0[d_idx] + dtb2*d_av[d_idx]
@@ -78,7 +78,7 @@ def stage1(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
 
     def stage2(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                    d_u0, d_v0, d_w0, d_u, d_v, d_w, d_rho0, d_rho, d_au, d_av,
-                   d_aw, d_ax, d_ay, d_az, d_arho, dt=0.0):
+                   d_aw, d_ax, d_ay, d_az, d_arho, dt):
 
         d_u[d_idx] = d_u0[d_idx] + dt*d_au[d_idx]
         d_v[d_idx] = d_v0[d_idx] + dt*d_av[d_idx]
@@ -116,7 +116,7 @@ def initialize(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
     def stage1(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                d_u0, d_v0, d_w0, d_u, d_v, d_w, d_rho0, d_rho,
                d_au, d_av, d_aw, d_ax, d_ay, d_az, d_arho,
-               dt=0.0):
+               dt):
 
         # update velocities
         d_u[d_idx] = d_u0[d_idx] + dt * d_au[d_idx]
@@ -133,7 +133,7 @@ def stage1(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
 
     def stage2(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                d_u0, d_v0, d_w0, d_u, d_v, d_w, d_rho0, d_rho, d_au, d_av,
-               d_aw, d_ax, d_ay, d_az, d_arho, dt=0.0):
+               d_aw, d_ax, d_ay, d_az, d_arho, dt):
 
         # update velocities
         d_u[d_idx] = 0.75*d_u0[d_idx] + 0.25*( d_u[d_idx] + dt * d_au[d_idx] )
@@ -150,7 +150,7 @@ def stage2(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
 
     def stage3(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                d_u0, d_v0, d_w0, d_u, d_v, d_w, d_rho0, d_rho, d_au, d_av,
-               d_aw, d_ax, d_ay, d_az, d_arho, dt=0.0):
+               d_aw, d_ax, d_ay, d_az, d_arho, dt):
 
         oneby3 = 1./3.
         twoby3 = 2./3.
@@ -202,7 +202,7 @@ def stage1(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                   d_s00, d_s01, d_s02, d_s11, d_s12, d_s22,
                   d_s000, d_s010, d_s020, d_s110, d_s120, d_s220,
                   d_as00, d_as01, d_as02, d_as11, d_as12, d_as22,
-                  dt=0.0):
+                  dt):
         dtb2 = 0.5*dt
         d_u[d_idx] = d_u0[d_idx] + dtb2*d_au[d_idx]
         d_v[d_idx] = d_v0[d_idx] + dtb2*d_av[d_idx]
@@ -230,7 +230,7 @@ def stage2(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                   d_s00, d_s01, d_s02, d_s11, d_s12, d_s22,
                   d_s000, d_s010, d_s020, d_s110, d_s120, d_s220,
                   d_as00, d_as01, d_as02, d_as11, d_as12, d_as22,
-                  dt=0.0):
+                  dt):
 
         d_u[d_idx] = d_u0[d_idx] + dt*d_au[d_idx]
         d_v[d_idx] = d_v0[d_idx] + dt*d_av[d_idx]
@@ -267,7 +267,7 @@ def initialize(self):
         pass
 
     def stage1(self, d_idx, d_u, d_v, d_au, d_av, d_uhat, d_auhat, d_vhat,
-                  d_avhat, d_x, d_y, dt=0.0):
+                  d_avhat, d_x, d_y, dt):
         dtb2 = 0.5*dt
 
         # velocity update eqn (14)
@@ -282,7 +282,7 @@ def stage1(self, d_idx, d_u, d_v, d_au, d_av, d_uhat, d_auhat, d_vhat,
         d_x[d_idx] += dt*d_uhat[d_idx]
         d_y[d_idx] += dt*d_vhat[d_idx]
 
-    def stage2(self, d_idx, d_u, d_v, d_au, d_av, d_vmag2, dt=0.0):
+    def stage2(self, d_idx, d_u, d_v, d_au, d_av, d_vmag2, dt):
         dtb2 = 0.5*dt
 
         # corrector update eqn (17)
@@ -307,7 +307,7 @@ class AdamiVerletStep(IntegratorStep):
     def initialize(self):
         pass
 
-    def stage1(self, d_idx, d_u, d_v, d_au, d_av, d_x, d_y, dt=0.0):
+    def stage1(self, d_idx, d_u, d_v, d_au, d_av, d_x, d_y, dt):
         dtb2 = 0.5*dt
 
         # velocity predictor eqn (14)
@@ -319,7 +319,7 @@ def stage1(self, d_idx, d_u, d_v, d_au, d_av, d_x, d_y, dt=0.0):
         d_y[d_idx] += dtb2*d_v[d_idx]
 
     def stage2(self, d_idx, d_u, d_v, d_au, d_av, d_x, d_y, d_rho, d_arho,
-               d_vmag2, dt=0.0):
+               d_vmag2, dt):
         dtb2 = 0.5*dt
 
         # velocity corrector eqn (18)
@@ -373,7 +373,7 @@ def stage1(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                d_aw, d_ae, d_rho, d_rho0, d_arho, d_h, d_h0, d_ah,
                d_alpha1, d_aalpha1, d_alpha10,
                d_alpha2, d_aalpha2, d_alpha20,
-               dt=0.0):
+               dt):
         dtb2 = 0.5*dt
 
         d_u[d_idx] = d_u0[d_idx] + dtb2 * d_au[d_idx]
@@ -401,7 +401,7 @@ def stage2(self, d_idx, d_x0, d_y0, d_z0, d_x, d_y, d_z,
                d_u0, d_v0, d_w0, d_u, d_v, d_w, d_e0, d_e, d_au, d_av,
                d_alpha1, d_aalpha1, d_alpha10,
                d_alpha2, d_aalpha2, d_alpha20,
-               d_aw, d_ae, dt=0.0):
+               d_aw, d_ae, dt):
 
         d_u[d_idx] = d_u0[d_idx] + dt * d_au[d_idx]
         d_v[d_idx] = d_v0[d_idx] + dt * d_av[d_idx]
@@ -445,7 +445,7 @@ def initialize(self, d_idx, d_x, d_y, d_z, d_x0, d_y0, d_z0,
 
     def stage1(self, d_idx, d_x, d_y, d_z, d_x0, d_y0, d_z0,
                d_u, d_v, d_w, d_u0, d_v0, d_w0, d_ax, d_ay, d_az,
-               dt=0.0):
+               dt):
 
         dtb2 = 0.5*dt
 
@@ -460,7 +460,7 @@ def stage1(self, d_idx, d_x, d_y, d_z, d_x0, d_y0, d_z0,
 
     def stage2(self, d_idx, d_x, d_y, d_z, d_x0, d_y0, d_z0,
                d_u, d_v, d_w, d_u0, d_v0, d_w0, d_ax, d_ay, d_az,
-               dt=0.0):
+               dt):
 
         d_u[d_idx] = d_u0[d_idx] + dt * d_ax[d_idx]
         d_v[d_idx] = d_v0[d_idx] + dt * d_ay[d_idx]
@@ -489,12 +489,12 @@ def initialize(self, d_idx, d_x, d_y, d_z, d_x0, d_y0, d_z0,
 
     def stage1(self, d_idx, d_x, d_y, d_z, d_x0, d_y0, d_z0,
                d_u, d_v, d_w, d_u0, d_v0, d_w0, d_ax, d_ay, d_az,
-               dt=0.0):
+               dt):
         pass
 
     def stage2(self, d_idx, d_x, d_y, d_z, d_x0, d_y0, d_z0,
                d_u, d_v, d_w, d_u0, d_v0, d_w0, d_ax, d_ay, d_az,
-               dt=0.0):
+               dt):
 
         # update velocities
         d_u[d_idx] += dt * d_ax[d_idx]
@@ -533,7 +533,7 @@ class VerletSymplecticWCSPHStep(IntegratorStep):
     def initialize(self):
         pass
 
-    def stage1(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w, dt=0.0):
+    def stage1(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w, dt):
 
         dtb2 = 0.5 * dt
 
@@ -543,7 +543,7 @@ def stage1(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w, dt=0.0):
         d_z[d_idx] += dtb2 * d_w[d_idx]
 
     def stage2(self, d_idx, d_x, d_y, d_z, d_ax, d_ay, d_az,
-               d_u, d_v, d_w, d_au, d_av, d_aw, dt=0.0):
+               d_u, d_v, d_w, d_au, d_av, d_aw, dt):
 
         dtb2 = 0.5 * dt
 
@@ -575,7 +575,7 @@ class VelocityVerletSymplecticWCSPHStep(IntegratorStep):
     def initialize(self):
         pass
 
-    def stage1(self, d_idx, d_u, d_v, d_w, d_au, d_av, d_aw, dt=0.0):
+    def stage1(self, d_idx, d_u, d_v, d_w, d_au, d_av, d_aw, dt):
 
         dtb2 = 0.5 * dt
 
@@ -585,7 +585,7 @@ def stage1(self, d_idx, d_u, d_v, d_w, d_au, d_av, d_aw, dt=0.0):
         d_w[d_idx] += dtb2 * d_aw[d_idx]
 
     def stage2(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w,
-               d_au, d_av, d_aw, dt=0.0):
+               d_au, d_av, d_aw, dt):
 
         dtb2 = 0.5 * dt
 
@@ -608,13 +608,13 @@ class InletOutletStep(IntegratorStep):
     def initialize(self):
         pass
 
-    def stage1(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w, dt=0.0):
+    def stage1(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w, dt):
         dtb2 = 0.5*dt
         d_x[d_idx] += dtb2 * d_u[d_idx]
         d_y[d_idx] += dtb2 * d_v[d_idx]
         d_z[d_idx] += dtb2 * d_w[d_idx]
 
-    def stage2(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w, dt=0.0):
+    def stage2(self, d_idx, d_x, d_y, d_z, d_u, d_v, d_w, dt):
         dtb2 = 0.5*dt
         d_x[d_idx] += dtb2 * d_u[d_idx]
         d_y[d_idx] += dtb2 * d_v[d_idx]

pysph/sph/tests/test_equations.py

@@ -89,8 +89,8 @@ def test_simple_equation(self):
         self.assertFalse(hasattr(eq, 'post_loop'))
         self.assertFalse(hasattr(eq, 'initialize'))
 
-        eq = Equation('fluid', sources=['fluid'], name='Test')
-        self.assertEqual(eq.name, 'Test')
+        eq = Equation('fluid', sources=['fluid'])
+        self.assertEqual(eq.name, 'Equation')
         self.assertEqual(eq.no_source, False)
         self.assertEqual(eq.dest, 'fluid')
         self.assertEqual(eq.sources, ['fluid'])