[Yt-svn] yt-commit r1142 - in trunk: tests yt/lagos

mturk at wrangler.dreamhost.com mturk at wrangler.dreamhost.com
Fri Jan 23 15:13:18 PST 2009


Author: mturk
Date: Fri Jan 23 15:13:17 2009
New Revision: 1142
URL: http://yt.spacepope.org/changeset/1142

Log:
Added "strict" regions that do not have any dx padding to the selected cells.
(This should fix some lingering issues with parallel halo finding.)  Added
tests for them.  Refactored class creation in the hierarchy, as a first step
toward automatic registration of classes via an AMRData metaclass.  (Maybe.)  



Modified:
   trunk/tests/test_lagos.py
   trunk/yt/lagos/BaseDataTypes.py
   trunk/yt/lagos/HierarchyType.py
   trunk/yt/lagos/ParallelTools.py

Modified: trunk/tests/test_lagos.py
==============================================================================
--- trunk/tests/test_lagos.py	(original)
+++ trunk/tests/test_lagos.py	Fri Jan 23 15:13:17 2009
@@ -216,7 +216,6 @@
         ps = cPickle.dumps(self.data)
         pf, obj = cPickle.loads(ps)
         self.assertEqual(obj["CellMassMsun"].sum(), self.data["CellMassMsun"].sum())
-        print "TEST PICKLE"
 
 for field_name in yt.lagos.FieldInfo:
     field = yt.lagos.FieldInfo[field_name]
@@ -358,6 +357,37 @@
         vol = self.data["CellVolume"].sum() / self.data.convert("cm")**3.0
         self.assertAlmostEqual(vol,1.0,7)
 
+class TestRegionStrictDataType(Data3DBase, DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+    def setUp(self):
+        DataTypeTestingBase.setUp(self)
+        self.data=self.hierarchy.region_strict(
+                     [0.5,0.5,0.5],[0.0, 0.0, 0.0],
+                     [1.0, 1.0, 1.0])
+    def testVolume(self):
+        vol = self.data["CellVolume"].sum() / self.data.convert("cm")**3.0
+        self.assertAlmostEqual(vol,1.0,7)
+
+class TestPeriodicRegionDataType(Data3DBase, DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+    def setUp(self):
+        DataTypeTestingBase.setUp(self)
+        self.data=self.hierarchy.periodic_region(
+                     [0.5,0.5,0.5],[0.5, 0.5, 0.5],
+                     [1.5,1.5,1.5])
+    def testVolume(self):
+        vol = self.data["CellVolume"].sum() / self.data.convert("cm")**3.0
+        self.assertAlmostEqual(vol,1.0,7)
+
+class TestPeriodicRegionStrictDataType(Data3DBase,
+            DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+    def setUp(self):
+        DataTypeTestingBase.setUp(self)
+        self.data=self.hierarchy.periodic_region_strict(
+                     [0.5,0.5,0.5],[0.5, 0.5, 0.5],
+                     [1.5,1.5,1.5])
+    def testVolume(self):
+        vol = self.data["CellVolume"].sum() / self.data.convert("cm")**3.0
+        self.assertAlmostEqual(vol,1.0,7)
+
 class TestSphereDataType(Data3DBase, DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
     def setUp(self):
         DataTypeTestingBase.setUp(self)

Modified: trunk/yt/lagos/BaseDataTypes.py
==============================================================================
--- trunk/yt/lagos/BaseDataTypes.py	(original)
+++ trunk/yt/lagos/BaseDataTypes.py	Fri Jan 23 15:13:17 2009
@@ -83,6 +83,7 @@
                      'dx':grid['dx'],
                      'dy':grid['dy'],
                      'dz':grid['dz']}
+        self.dds = grid.dds.copy()
         self.real_grid = grid
         self.child_mask = 1
         self.ActiveDimensions = self.data['x'].shape
@@ -1588,6 +1589,7 @@
     """
     _type_name = "region"
     _con_args = ('center', 'left_edge', 'right_edge')
+    _dx_pad = 0.5
     def __init__(self, center, left_edge, right_edge, fields = None,
                  pf = None, **kwargs):
         """
@@ -1613,20 +1615,28 @@
         if self._is_fully_enclosed(grid):
             return True
         else:
-            cm = ( (grid['x'] - 0.5 * grid['dx'] < self.right_edge[0])
-                 & (grid['x'] + 0.5 * grid['dx'] > self.left_edge[0])
-                 & (grid['y'] - 0.5 * grid['dy'] < self.right_edge[1])
-                 & (grid['y'] + 0.5 * grid['dy'] > self.left_edge[1])
-                 & (grid['z'] - 0.5 * grid['dz'] < self.right_edge[2])
-                 & (grid['z'] + 0.5 * grid['dz'] > self.left_edge[2]) )
+            dxp, dyp, dzp = self._dx_pad * grid.dds
+            cm = ( (grid['x'] - dxp < self.right_edge[0])
+                 & (grid['x'] + dxp > self.left_edge[0])
+                 & (grid['y'] - dyp < self.right_edge[1])
+                 & (grid['y'] + dyp > self.left_edge[1])
+                 & (grid['z'] - dzp < self.right_edge[2])
+                 & (grid['z'] + dzp > self.left_edge[2]) )
         return cm
 
+class AMRRegionStrictBase(AMRRegionBase):
+    """
+    AMRRegion without any dx padding for cell selection
+    """
+    _dx_pad = 0.0
+
 class AMRPeriodicRegionBase(AMR3DData):
     """
     AMRRegions are rectangular prisms of data.
     """
     _type_name = "periodic_region"
     _con_args = ('center', 'left_edge', 'right_edge')
+    _dx_pad = 0.5
     def __init__(self, center, left_edge, right_edge, fields = None,
                  pf = None, **kwargs):
         """
@@ -1666,15 +1676,23 @@
             return True
         else:
             cm = na.zeros(grid.ActiveDimensions,dtype='bool')
+            dxp, dyp, dzp = self._dx_pad * grid.dds
             for off_x, off_y, off_z in self.offsets:
-                cm = cm | ( (grid['x'] - grid['dx'] + off_x < self.right_edge[0])
-                          & (grid['x'] + grid['dx'] + off_x > self.left_edge[0])
-                          & (grid['y'] - grid['dy'] + off_y < self.right_edge[1])
-                          & (grid['y'] + grid['dy'] + off_y > self.left_edge[1])
-                          & (grid['z'] - grid['dz'] + off_z < self.right_edge[2])
-                          & (grid['z'] + grid['dz'] + off_z > self.left_edge[2]) )
+                cm = cm | ( (grid['x'] - dxp + off_x < self.right_edge[0])
+                          & (grid['x'] + dxp + off_x > self.left_edge[0])
+                          & (grid['y'] - dyp + off_y < self.right_edge[1])
+                          & (grid['y'] + dyp + off_y > self.left_edge[1])
+                          & (grid['z'] - dzp + off_z < self.right_edge[2])
+                          & (grid['z'] + dzp + off_z > self.left_edge[2]) )
             return cm
 
+
+class AMRPeriodicRegionStrictBase(AMRPeriodicRegionBase):
+    """
+    AMRPeriodicRegion without any dx padding for cell selection
+    """
+    _dx_pad = 0.0
+
 class AMRGridCollection(AMR3DData):
     """
     An arbitrary selection of grids, within which we accept all points.

Modified: trunk/yt/lagos/HierarchyType.py
==============================================================================
--- trunk/yt/lagos/HierarchyType.py	(original)
+++ trunk/yt/lagos/HierarchyType.py	Fri Jan 23 15:13:17 2009
@@ -200,38 +200,33 @@
             del self._data_file
             self._data_file = None
 
-    def _add_object_class(self, name, obj):
+    def _add_object_class(self, name, class_name, base, dd):
         self.object_types.append(name)
+        obj = classobj(class_name, (base,), dd)
         setattr(self, name, obj)
 
     def _setup_classes(self, dd):
         self.object_types = []
-        self._add_object_class('proj', 
-              classobj("AMRProj",(AMRProjBase,), dd))
-        self._add_object_class('slice', 
-              classobj("AMRSlice",(AMRSliceBase,), dd))
-        self._add_object_class('region', 
-              classobj("AMRRegion",(AMRRegionBase,), dd))
-        self._add_object_class('periodic_region', 
-              classobj("AMRPeriodicRegion",(AMRPeriodicRegionBase,), dd))
-        self._add_object_class('covering_grid', 
-              classobj("AMRCoveringGrid",(AMRCoveringGridBase,), dd))
-        self._add_object_class('smoothed_covering_grid', 
-              classobj("AMRSmoothedCoveringGrid",(AMRSmoothedCoveringGridBase,), dd))
-        self._add_object_class('sphere', 
-              classobj("AMRSphere",(AMRSphereBase,), dd))
-        self._add_object_class('cutting', 
-              classobj("AMRCuttingPlane",(AMRCuttingPlaneBase,), dd))
-        self._add_object_class('ray', 
-              classobj("AMRRay",(AMRRayBase,), dd))
-        self._add_object_class('ortho_ray', 
-              classobj("AMROrthoRay",(AMROrthoRayBase,), dd))
-        self._add_object_class('disk', 
-              classobj("AMRCylinder",(AMRCylinderBase,), dd))
-        self._add_object_class('grid_collection', 
-              classobj("AMRGridCollection",(AMRGridCollection,), dd))
-        self._add_object_class('extracted_region', 
-              classobj("ExtractedRegion",(ExtractedRegionBase,), dd))
+        self._add_object_class('proj', "AMRProj", AMRProjBase, dd)
+        self._add_object_class('slice', "AMRSlice", AMRSliceBase, dd)
+        self._add_object_class('region', "AMRRegion", AMRRegionBase, dd)
+        self._add_object_class('region_strict', "AMRRegionStrict",
+                        AMRRegionStrictBase, dd)
+        self._add_object_class('periodic_region', "AMRPeriodicRegion",
+                        AMRPeriodicRegionBase, dd)
+        self._add_object_class('periodic_region_strict', "AMRPeriodicRegionStrict",
+                        AMRPeriodicRegionStrictBase, dd)
+        self._add_object_class('covering_grid', "AMRCoveringGrid",
+                        AMRCoveringGridBase, dd)
+        self._add_object_class('smoothed_covering_grid', "AMRSmoothedCoveringGrid",
+                        AMRSmoothedCoveringGridBase, dd)
+        self._add_object_class('sphere', "AMRSphere", AMRSphereBase, dd)
+        self._add_object_class('cutting', "AMRCuttingPlane", AMRCuttingPlaneBase, dd)
+        self._add_object_class('ray', "AMRRay", AMRRayBase, dd)
+        self._add_object_class('ortho_ray', "AMROrthoRay", AMROrthoRayBase, dd)
+        self._add_object_class('disk', "AMRCylinder", AMRCylinderBase, dd)
+        self._add_object_class('grid_collection', "AMRGridCollection", AMRGridCollection, dd)
+        self._add_object_class('extracted_region', "ExtractedRegion", ExtractedRegionBase, dd)
         self.object_types.sort()
 
     def _deserialize_hierarchy(self, harray):
@@ -650,8 +645,7 @@
     def _setup_classes(self):
         dd = self._get_data_reader_dict()
         AMRHierarchy._setup_classes(self, dd)
-        self._add_object_class('grid', 
-              classobj("EnzoGrid",(EnzoGridBase,), dd))
+        self._add_object_class('grid', "EnzoGrid", EnzoGridBase, dd)
         self.object_types.sort()
 
     def __guess_data_style(self, rank, testGrid, testGridID):
@@ -1352,8 +1346,7 @@
         dd = self._get_data_reader_dict()
         dd["field_indexes"] = self.field_indexes
         AMRHierarchy._setup_classes(self, dd)
-        self._add_object_class('grid', 
-              classobj("OrionGrid",(OrionGridBase,), dd))
+        self._add_object_class('grid', "OrionGrid", OrionGridBase, dd)
         self.object_types.sort()
 
     def _get_grid_children(self, grid):

Modified: trunk/yt/lagos/ParallelTools.py
==============================================================================
--- trunk/yt/lagos/ParallelTools.py	(original)
+++ trunk/yt/lagos/ParallelTools.py	Fri Jan 23 15:13:17 2009
@@ -197,7 +197,7 @@
         LE[y_dict[axis]] = y[0]
         RE[y_dict[axis]] = y[1]
 
-        reg = self.hierarchy.region(self.center, LE, RE)
+        reg = self.hierarchy.region_strict(self.center, LE, RE)
         return True, reg
 
     def _partition_hierarchy_3d(self, padding=0.0):
@@ -217,9 +217,9 @@
 
         if padding > 0:
             return True, \
-                LE, RE, self.hierarchy.periodic_region(self.center, LE-padding, RE+padding)
+                LE, RE, self.hierarchy.periodic_region_strict(self.center, LE-padding, RE+padding)
 
-        return False, LE, RE, self.hierarchy.region(self.center, LE, RE)
+        return False, LE, RE, self.hierarchy.region_strict(self.center, LE, RE)
         
     def _barrier(self):
         if not parallel_capable: return



More information about the yt-svn mailing list