Fixed flake issues

Author: cheginit

advection/tests/smooth_0040.h5

@@ -1,6 +1,7 @@
 import mesh.reconstruction as reconstruction
 import numpy as np
 
+
 def unsplit_fluxes(my_data, rp, dt, scalar_name):
     """
     Construct the fluxes through the interfaces for the linear advection
@@ -58,10 +59,10 @@ def unsplit_fluxes(my_data, rp, dt, scalar_name):
 
     u = my_data.get_var("x-velocity")
     v = my_data.get_var("y-velocity")
-    
+
     cx = myg.scratch_array()
     cy = myg.scratch_array()
-    
+
     cx.v(buf=1)[:, :] = u.v(buf=1)*dt/myg.dx
     cy.v(buf=1)[:, :] = v.v(buf=1)*dt/myg.dy
 
@@ -73,37 +74,37 @@ def unsplit_fluxes(my_data, rp, dt, scalar_name):
 
     ldelta_ax = reconstruction.limit(a, myg, 1, limiter)
     ldelta_ay = reconstruction.limit(a, myg, 2, limiter)
-    
+
     # x-direction
     a_x = myg.scratch_array()
     shift_x = my_data.get_var("x-shift").astype(int)
-    
-    for index,vel in np.ndenumerate(u.v(buf=1)):
+
+    for index, vel in np.ndenumerate(u.v(buf=1)):
         # upwind
         if vel < 0:
             a_x.v(buf=1)[index] = a.ip(shift_x.v(buf=1)[index], buf=1)[index] - \
-                                  0.5*(1.0 + cx.v(buf=1)[index])* \
+                                  0.5*(1.0 + cx.v(buf=1)[index]) * \
                                   ldelta_ax.ip(shift_x.v(buf=1)[index], buf=1)[index]
         else:
             a_x.v(buf=1)[index] = a.ip(shift_x.v(buf=1)[index], buf=1)[index] + \
-                                  0.5*(1.0 - cx.v(buf=1)[index])* \
+                                  0.5*(1.0 - cx.v(buf=1)[index]) * \
                                   ldelta_ax.ip(shift_x.v(buf=1)[index], buf=1)[index]
 
     # y-direction
     a_y = myg.scratch_array()
     shift_y = my_data.get_var("y-shift").astype(int)
-    
-    for index,vel in np.ndenumerate(v.v(buf=1)):
+
+    for index, vel in np.ndenumerate(v.v(buf=1)):
         # upwind
         if vel < 0:
             a_y.v(buf=1)[index] = a.jp(shift_y.v(buf=1)[index], buf=1)[index] - \
-                                  0.5*(1.0 + cy.v(buf=1)[index])* \
+                                  0.5*(1.0 + cy.v(buf=1)[index]) * \
                                   ldelta_ay.jp(shift_y.v(buf=1)[index], buf=1)[index]
         else:
             a_y.v(buf=1)[index] = a.jp(shift_y.v(buf=1)[index], buf=1)[index] + \
-                                  0.5*(1.0 - cy.v(buf=1)[index])* \
+                                  0.5*(1.0 - cy.v(buf=1)[index]) * \
                                   ldelta_ay.jp(shift_y.v(buf=1)[index], buf=1)[index]
-    
+
     # compute the transverse flux differences.  The flux is just (u a)
     # HOTF
     F_xt = u*a_x
@@ -116,15 +117,15 @@ def unsplit_fluxes(my_data, rp, dt, scalar_name):
     # depends on the sign of the advective velocity
     dtdx2 = 0.5*dt/myg.dx
     dtdy2 = 0.5*dt/myg.dy
-    
+
     for index, vel in np.ndenumerate(u.v(buf=1)):
         F_x.v(buf=1)[index] = vel*(a_x.v(buf=1)[index] -
                               dtdy2*(F_yt.ip_jp(shift_x.v(buf=1)[index], 1, buf=1)[index] -
                                      F_yt.ip(shift_x.v(buf=1)[index], buf=1)[index]))
-    
+
     for index, vel in np.ndenumerate(v.v(buf=1)):
         F_y.v(buf=1)[index] = vel*(a_y.v(buf=1)[index] -
                               dtdx2*(F_xt.ip_jp(1, shift_y.v(buf=1)[index], buf=1)[index] -
                                      F_xt.jp(shift_y.v(buf=1)[index], buf=1)[index]))
+
     return F_x, F_y
-    

advection_nonuniform/advective_fluxes.py

@@ -1,57 +1,55 @@
 from __future__ import print_function
-
 import numpy as np
-import matplotlib.pyplot as plt
 
 import mesh.patch as patch
 from util import msg
 
 
 def init_data(my_data, rp):
-    """ initialize the smooth advection problem """
-
+    """ initialize the slotted advection problem """
     msg.bold("initializing the slotted advection problem...")
 
     # make sure that we are passed a valid patch object
     if not isinstance(my_data, patch.CellCenterData2d):
         print(my_data.__class__)
         msg.fail("ERROR: patch invalid in slotted.py")
-    
+
     offset = rp.get_param("slotted.offset")
     omega = rp.get_param("slotted.omega")
-    
+
     myg = my_data.grid
-    
+
     xctr_dens = 0.5*(myg.xmin + myg.xmax)
     yctr_dens = 0.5*(myg.ymin + myg.ymax) + offset
-    
+
     # setting initial condition for density
     dens = my_data.get_var("density")
     dens[:, :] = 0.0
 
     R = 0.15
     slot_width = 0.05
-    
+
     inside = (myg.x2d - xctr_dens)**2 + (myg.y2d - yctr_dens)**2 < R**2
-    
+
     slot_x = np.logical_and(myg.x2d > (xctr_dens - slot_width*0.5),
                             myg.x2d < (xctr_dens + slot_width*0.5))
     slot_y = np.logical_and(myg.y2d > (yctr_dens - R),
                             myg.y2d < (yctr_dens))
     slot = np.logical_and(slot_x, slot_y)
-    
+
     dens[inside] = 1.0
     dens[slot] = 0.0
-    
+
     # setting initial condition for velocity
     u = my_data.get_var("x-velocity")
     v = my_data.get_var("y-velocity")
-    
+
     u[:, :] = omega*(myg.y2d - xctr_dens)
     v[:, :] = -omega*(myg.x2d - (yctr_dens-offset))
-                
+
     print("extrema: ", np.amax(u), np.amin(u))
-    
+
+
 def finalize():
     """ print out any information to the user at the end of the run """
     pass

advection_nonuniform/problems/slotted.py

@@ -1,8 +1,7 @@
 from __future__ import print_function
 
-import sys
 import mesh.patch as patch
-import numpy
+import numpy as np
 from util import msg
 
 
@@ -27,15 +26,16 @@ def init_data(my_data, rp):
     xctr = 0.5*(xmin + xmax)
     yctr = 0.5*(ymin + ymax)
 
-    dens[:, :] = 1.0 + numpy.exp(-60.0*((my_data.grid.x2d-xctr)**2 +
+    dens[:, :] = 1.0 + np.exp(-60.0*((my_data.grid.x2d-xctr)**2 +
                                         (my_data.grid.y2d-yctr)**2))
-    
+
     u = my_data.get_var("x-velocity")
     v = my_data.get_var("y-velocity")
-    
+
     u[:, :] = rp.get_param("advection.u")
     v[:, :] = rp.get_param("advection.v")
 
+
 def finalize():
     """ print out any information to the user at the end of the run """
     pass

advection_nonuniform/problems/smooth.py

@@ -1,6 +1,5 @@
 from __future__ import print_function
 
-import sys
 import mesh.patch as patch
 
 
@@ -9,9 +8,8 @@ def init_data(my_data, rp):
 
     # make sure that we are passed a valid patch object
     if not isinstance(my_data, patch.CellCenterData2d):
-        print("ERROR: patch invalid in sedov.py")
         print(my_data.__class__)
-        sys.exit()
+        msg.fail("ERROR: patch invalid in slotted.py")
 
     # get the density, momenta, and energy as separate variables
     dens = my_data.get_var("density")
@@ -20,12 +18,13 @@ def init_data(my_data, rp):
     # + 0.5*rho*v**2, where eint is the specific internal energy
     # (erg/g)
     dens[:, :] = 1.0
-    
+
     u = my_data.get_var("x-velocity")
     v = my_data.get_var("y-velocity")
-    
-    u[:, :] = rp.get_param("advection.u")
-    v[:, :] = rp.get_param("advection.v")
+
+    u[:, :] = 1.0
+    v[:, :] = 1.0
+
 
 def finalize():
     """ print out any information to the user at the end of the run """

advection_nonuniform/problems/test.py

@@ -1,28 +1,26 @@
 from __future__ import print_function
 
-import sys
 import mesh.patch as patch
 from util import msg
 
 
-def init_data(myd, rp):
+def init_data(my_data, rp):
     """ initialize the tophat advection problem """
 
     msg.bold("initializing the tophat advection problem...")
 
     # make sure that we are passed a valid patch object
-    if not isinstance(myd, patch.CellCenterData2d):
-        print("ERROR: patch invalid in tophat.py")
-        print(myd.__class__)
-        sys.exit()
+    if not isinstance(my_data, patch.CellCenterData2d):
+        print(my_data.__class__)
+        msg.fail("ERROR: patch invalid in slotted.py")
 
-    dens = myd.get_var("density")
+    dens = my_data.get_var("density")
 
-    xmin = myd.grid.xmin
-    xmax = myd.grid.xmax
+    xmin = my_data.grid.xmin
+    xmax = my_data.grid.xmax
 
-    ymin = myd.grid.ymin
-    ymax = myd.grid.ymax
+    ymin = my_data.grid.ymin
+    ymax = my_data.grid.ymax
 
     xctr = 0.5*(xmin + xmax)
     yctr = 0.5*(ymin + ymax)
@@ -31,16 +29,17 @@ def init_data(myd, rp):
 
     R = 0.1
 
-    inside = (myd.grid.x2d - xctr)**2 + (myd.grid.y2d - yctr)**2 < R**2
+    inside = (my_data.grid.x2d - xctr)**2 + (my_data.grid.y2d - yctr)**2 < R**2
 
     dens[inside] = 1.0
-    
+
     u = my_data.get_var("x-velocity")
     v = my_data.get_var("y-velocity")
-    
+
     u[:, :] = rp.get_param("advection.u")
     v[:, :] = rp.get_param("advection.v")
 
+
 def finalize():
     """ print out any information to the user at the end of the run """
     pass

advection_nonuniform/problems/tophat.py

@@ -19,18 +19,18 @@ def initialize(self):
         def shift(velocity):
             """
             Computes the direction of shift for each node for upwind
-            discretization based on sign of veclocity 
+            discretization based on sign of veclocity
             """
             shift_vel = np.sign(velocity)
             shift_vel[np.where(shift_vel <= 0)] = 0
-            shift_vel[np.where(shift_vel >  0)] = -1
+            shift_vel[np.where(shift_vel > 0)] = -1
             return shift_vel
-            
+
         my_grid = grid_setup(self.rp, ng=4)
-        
+
         # create the variables
         bc, bc_xodd, bc_yodd = bc_setup(self.rp)
-        
+
         my_data = patch.CellCenterData2d(my_grid)
 
         # velocities
@@ -40,10 +40,10 @@ def shift(velocity):
         # shift
         my_data.register_var("x-shift", bc_xodd)
         my_data.register_var("y-shift", bc_yodd)
-        
+
         # density
         my_data.register_var("density", bc)
-        
+
         my_data.create()
 
         self.cc_data = my_data
@@ -56,13 +56,13 @@ def shift(velocity):
         # now set the initial conditions for the problem
         problem = importlib.import_module("advection_nonuniform.problems.{}".format(self.problem_name))
         problem.init_data(self.cc_data, self.rp)
-        
+
         # compute the required shift for each node using corresponding velocity at the node
         shx = self.cc_data.get_var("x-shift")
         shx[:, :] = shift(self.cc_data.get_var("x-velocity"))
         shy = self.cc_data.get_var("y-shift")
         shy[:, :] = shift(self.cc_data.get_var("y-velocity"))
-        
+
     def method_compute_timestep(self):
         """
         The timestep() function computes the advective timestep
@@ -76,7 +76,7 @@ def method_compute_timestep(self):
 
         u = self.cc_data.get_var("x-velocity")
         v = self.cc_data.get_var("y-velocity")
-        
+
         # the timestep is min(dx/|u|, dy|v|)
         xtmp = self.cc_data.grid.dx/np.amax(np.fabs(u))
         ytmp = self.cc_data.grid.dy/np.amax(np.fabs(v))
@@ -90,7 +90,7 @@ def evolve(self):
         is part of the Simulation.
         """
         myd = self.cc_data
-        
+
         dtdx = self.dt/myd.grid.dx
         dtdy = self.dt/myd.grid.dy
 
@@ -110,7 +110,6 @@ def evolve(self):
                                     dtdy*(flux_y.v() - flux_y.jp(1))
 
         if self.particles is not None:
-            
             u = myd.get_var("x-velocity")
             v = myd.get_var("y-velocity")
 
@@ -165,4 +164,3 @@ def dovis(self):
 
         plt.pause(0.001)
         plt.draw()
-        

advection_nonuniform/simulation.py

@@ -31,4 +31,9 @@ def teardown_method(self):
 
     def test_initializationst(self):
         dens = self.sim.cc_data.get_var("density")
+        u = self.sim.cc_data.get_var("x-velocity")
+        v = self.sim.cc_data.get_var("y-velocity")
+
         assert dens.min() == 1.0 and dens.max() == 1.0
+        assert u.min() == 1.0 and u.max() == 1.0
+        assert v.min() == 1.0 and v.max() == 1.0