[Yt-svn] yt-commit r595 - branches/yt-generalization/tests
mturk at wrangler.dreamhost.com
mturk at wrangler.dreamhost.com
Sat Jun 21 14:01:25 PDT 2008
Author: mturk
Date: Sat Jun 21 14:01:24 2008
New Revision: 595
URL: http://yt.spacepope.org/changeset/595
Log:
This file will likely go away. Tests for Orion reading.
Added:
branches/yt-generalization/tests/test_orion.py
Added: branches/yt-generalization/tests/test_orion.py
==============================================================================
--- (empty file)
+++ branches/yt-generalization/tests/test_orion.py Sat Jun 21 14:01:24 2008
@@ -0,0 +1,482 @@
+"""
+Test that we can get outputs, and interact with them in some primitive ways.
+"""
+
+# @TODO: Add unit test for deleting field from fieldInfo
+
+import unittest, glob, os.path, os, sys, StringIO
+
+print "Reporting from %s" % (os.getcwd())
+sys.path = ['.'] + sys.path
+
+from yt.config import ytcfg
+ytcfg["yt","LogLevel"] = '50'
+ytcfg["yt","logFile"] = "False"
+ytcfg["yt","suppressStreamLogging"] = "True"
+ytcfg["lagos","serialize"] = "False"
+
+import yt.lagos
+import numpy as na
+
+# The dataset used is located at:
+# http://yt.spacepope.org/DD0018.zip
+fn = "uniformCollapse_base64_maxLev4"
+fn = os.path.join(os.path.dirname(__file__), fn)
+print "I AM GOING TO GET",fn
+
+class LagosTestingBase:
+ def setUp(self):
+ self.OutputFile = yt.lagos.OrionStaticOutput(fn)
+ self.hierarchy = self.OutputFile.hierarchy
+ self.v, self.c = self.hierarchy.find_max("Density")
+ gp = os.path.join(os.path.dirname(fn),"*.yt")
+ ytFiles = glob.glob(gp)
+ for i in ytFiles:
+ #print "Removing %s" % (i)
+ os.unlink(i)
+
+ def tearDown(self):
+ if hasattr(self,'data'): del self.data
+ if hasattr(self,'region'): del self.region
+ if hasattr(self,'ind_to_get'): del self.ind_to_get
+ del self.OutputFile, self.hierarchy
+
+
+class TestHierarchy(LagosTestingBase, unittest.TestCase):
+ def testGetHierarchy(self):
+ self.assert_(self.OutputFile.hierarchy != None)
+
+ def testGetUnits(self):
+ self.assert_(self.OutputFile["cm"] != 1.0)
+
+ def testGetSmallestDx(self):
+ self.assertAlmostEqual(self.hierarchy.get_smallest_dx(),
+ 0.00048828125, 7)
+
+ def testGetNumberOfGrids(self):
+ self.assertEqual(self.hierarchy.num_grids, len(self.hierarchy.grids))
+ self.assertEqual(self.hierarchy.num_grids, 10)
+
+ def testChildrenOfRootGrid(self):
+ for child in self.hierarchy.grids[0].Children:
+ self.assert_(child.Parent.id == self.hierarchy.grids[0].id)
+
+ def testGetSelectLevels(self):
+ for level in range(self.hierarchy.maxLevel+1):
+ for grid in self.hierarchy.select_grids(level):
+ self.assert_(grid.Level == level)
+
+ def testPrintStats(self):
+ a = sys.stdout
+ sys.stdout = StringIO.StringIO()
+ try:
+ self.hierarchy.print_stats()
+ worked = True
+ except:
+ worked = False
+ sys.stdout = a
+ self.assert_(worked)
+
+ def testDataTypes(self):
+ r=self.hierarchy.region(
+ [0.5,0.5,0.5],[0.0, 0.0, 0.0],
+ [1.0, 1.0, 1.0],
+ ["CellMass","Temperature"])
+ # Testing multiple fields fed in
+ s=self.hierarchy.sphere(
+ [0.5,0.5,0.5],2.0,
+ ["CellMass","Temperature"])
+ ms = s["CellMass"].sum() # Testing adding new field transparently
+ mr = r["CellMass"].sum() # Testing adding new field transparently
+ self.assertEqual(ms,mr) # Asserting equality between the two
+
+ def testProjectionCorrectnessMultipleFields(self):
+ p = self.hierarchy.proj(0,["Density","Ones"], weight=None) # Unweighted
+ self.assertTrue(na.all(p["Ones"] == 1.0))
+
+ def testProjectionMakingMultipleFields(self):
+ p = self.hierarchy.proj(0,["Density","Temperature","Ones"],weight_field="Ones") # Unweighted
+ # One for each field, pdx, pdy, px, py, and one for the weight
+ self.assertEqual(len(p.data.keys()), 8)
+
+ def testProjectionSuccess(self):
+ p = self.hierarchy.proj(0,"Density") # Unweighted
+ p = self.hierarchy.proj(1,"Temperature","Density") # Weighted
+ p = self.hierarchy.proj(2,"Entropy") # Derived field
+
+ def testUnweightedProjectionCorrectness(self):
+ # Now we test that we get good answers
+ for axis in range(3):
+ p = self.hierarchy.proj(axis, "Ones") # Derived field
+ self.assertTrue(na.all(p["Ones"] == 1.0))
+ # Regardless of weighting, we want ones back
+
+ def testWeightedProjectionCorrectness(self):
+ # Now we test that we get good answers
+ for axis in range(3):
+ # Regardless of weighting, we want ones back
+ p = self.hierarchy.proj(axis, "Ones", "Density")
+ self.assertTrue(na.all(p["Ones"] == 1.0))
+
+# Now we test each datatype in turn
+
+def _returnFieldFunction(field):
+ def field_function(self):
+ try:
+ self.data[field.name]
+ if not field.particle_type and not field.vector_field and \
+ self.data[field.name].size > 1:
+ self.assertEqual(na.product(self.data["Density"].shape),
+ na.product(self.data[field.name].shape))
+ del self.data[field.name]
+ except yt.lagos.ValidationException:
+ pass
+ return field_function
+
+def _returnProfile1DFunction(field, weight, accumulation, lazy):
+ def add_field_function(self):
+ self.data.set_field_parameter("center",[.5,.5,.5])
+ profile = yt.lagos.BinnedProfile1D(
+ self.data, 8, "RadiusCode", 0, 1.0, False, lazy)
+ profile.add_fields(field, weight=weight, accumulation=accumulation)
+ return add_field_function
+
+def _returnProfile2DFunction(field, weight, accumulation, lazy):
+ def add_field_function(self):
+ self.data.set_field_parameter("center",[.5,.5,.5])
+ cv_min = self.hierarchy.gridDxs.min()**3.0
+ cv_max = self.hierarchy.gridDxs.max()**3.0
+ profile = yt.lagos.BinnedProfile2D(self.data,
+ 8, "RadiusCode", 1e-3, 1.0, True,
+ 8, "CellVolumeCode", cv_min, cv_max, True, lazy)
+ profile.add_fields(field, weight=weight, accumulation=accumulation)
+ return add_field_function
+
+class DataTypeTestingBase:
+ def setUp(self):
+ LagosTestingBase.setUp(self)
+
+class Data3DBase:
+ def testProfileAccumulateMass(self):
+ self.data.set_field_parameter("center",[0.5]*3)
+ profile = yt.lagos.BinnedProfile1D(self.data, 8, "RadiusCode", 0, 1.0,
+ False, True)
+ profile.add_fields("CellMassMsun", weight=None, accumulation=True)
+ v1 = profile["CellMassMsun"].max()
+ v2 = self.data["CellMassMsun"].sum()
+ v2 = na.abs(1.0 - v2/v1)
+ self.assertAlmostEqual(v2, 0.0, 7)
+
+ def testContoursObtain(self):
+ # As a note, unfortunately this dataset only has one sphere.
+ # Frownie face.
+ cid = yt.lagos.identify_contours(self.data, "Density",
+ self.data["Density"].min()*2.00, self.data["Density"].max()*1.01)
+ self.assertEqual(len(cid), 2)
+
+ def testContoursValidityMax(self):
+ v1 = self.data["Density"].max()*0.99
+ v2 = self.data["Density"].max()*1.01
+ cid = yt.lagos.identify_contours(self.data, "Density", v1, v2)
+ self.assertTrue(na.all(v1 < self.data["Density"][cid[0]])
+ and na.all(v2 > self.data["Density"][cid[0]]))
+ self.assertEqual(len(cid), 1)
+
+ def testContoursValidityMin(self):
+ v1 = self.data["Density"].min()*0.99
+ v2 = self.data["Density"].min()*1.01
+ cid = yt.lagos.identify_contours(self.data, "Density", v1, v2)
+ self.assertTrue(na.all(v1 < self.data["Density"][cid[0]])
+ and na.all(v2 > self.data["Density"][cid[0]]))
+ self.assertEqual(len(cid), 3)
+
+
+for field in yt.lagos.fieldInfo.values():
+ setattr(DataTypeTestingBase, "test%s" % field.name, _returnFieldFunction(field))
+
+field = "Temperature"
+for weight in [None, "CellMassMsun"]:
+ for lazy in [True, False]:
+ for accumulation in [True, False]:
+ func = _returnProfile1DFunction(field, weight, accumulation, lazy)
+ name = "test%sProfile1D_w%s_l%s_a%s" % (field,
+ weight, lazy,
+ accumulation)
+ setattr(Data3DBase, name, func)
+
+for weight in [None, "CellMassMsun"]:
+ for lazy in [True, False]:
+ for accumulation_x in [True, False]:
+ for accumulation_y in [True, False]:
+ acc = (accumulation_x, accumulation_y)
+ func = _returnProfile2DFunction(field, weight, acc, lazy)
+ name = "test%sProfile2D_w%s_l%s_a%s_a%s" % (field,
+ weight, lazy,
+ accumulation_x,
+ accumulation_y)
+ setattr(Data3DBase, name, func)
+
+class TestSmoothedCoveringGrid(LagosTestingBase, unittest.TestCase):
+ def setUp(self):
+ LagosTestingBase.setUp(self)
+
+ def testAllCover(self):
+ DIMS = 32
+ for i in range(self.hierarchy.max_level+1):
+ dx = (DIMS*2**i)**-1
+ LE = na.array([0.5,0.5,0.5])-(dx*DIMS/2.0)
+ RE = na.array([0.5,0.5,0.5])+(dx*DIMS/2.0)
+ cg = self.hierarchy.smoothed_covering_grid(
+ level=i, left_edge=LE, right_edge=RE,
+ dims=[DIMS]*3, fields=["Density"])
+ self.assertFalse(na.any(na.isnan(cg["Density"])))
+ self.assertFalse(na.any(cg["Density"]==-999))
+
+ def testWrongDims(self):
+ self.failUnlessRaises(ValueError,
+ self.hierarchy.smoothed_covering_grid,
+ level=2, left_edge=[0.25, 0.25, 0.25],
+ right_edge=[0.75, 0.75, 0.75],
+ dims=[123, 124, 125])
+
+ def testAddField(self):
+ DIMS = 64
+ i = 5
+ dx = (DIMS*2**i)**-1
+ LE = na.array([0.5,0.5,0.5])-(dx*DIMS/2.0)
+ RE = na.array([0.5,0.5,0.5])+(dx*DIMS/2.0)
+ cg = self.hierarchy.smoothed_covering_grid(
+ level=i, left_edge=LE, right_edge=RE,
+ dims=[DIMS]*3, fields=["Density"])
+ self.assertFalse(na.any(na.isnan(cg["Temperature"])))
+ self.assertFalse(na.any(cg["Temperature"]==-999))
+
+
+
+class TestDataCube(LagosTestingBase, unittest.TestCase):
+ def setUp(self):
+ LagosTestingBase.setUp(self)
+
+ def testNoGhost(self):
+ for g in self.hierarchy.grids:
+ cube = g.retrieve_ghost_zones(0, "Density")
+ self.assertTrue(na.all(cube["Density"] == g["Density"]))
+ cube["Density"] = na.arange(cube["Density"].size).reshape(cube["Density"].shape)
+ cube.flush_data(field="Density")
+ self.assertTrue(na.all(g["Density"] == cube["Density"]))
+
+ def testTwoGhost(self):
+ for g in self.hierarchy.grids:
+ cube = g.retrieve_ghost_zones(2, "Density")
+
+ def testMultipleFields(self):
+ for g in self.hierarchy.grids:
+ cube1 = g.retrieve_ghost_zones(0, ["Density","Temperature"])
+ self.assertTrue(na.all(cube1["Density"] == g["Density"]))
+ self.assertTrue(na.all(cube1["Temperature"] == g["Temperature"]))
+ cube2a = g.retrieve_ghost_zones(0, "Density")
+ cube2b = g.retrieve_ghost_zones(0, "Temperature")
+ self.assertTrue(na.all(cube1["Density"] == cube2a["Density"]))
+ self.assertTrue(na.all(cube1["Temperature"] == cube2b["Temperature"]))
+
+ def testFlushBack(self):
+ ml = self.hierarchy.max_level
+ cg = self.hierarchy.covering_grid(3, [0.0]*3, [1.0]*3, [64,64,64])
+ cg["Ones"] *= 2.0
+ cg.flush_data(field="Ones")
+ for g in na.concatenate([self.hierarchy.select_grids(i) for i in range(3)]):
+ self.assertEqual(g["Ones"].max(), 2.0)
+ self.assertEqual(g["Ones"][g["Ones"]*g.child_mask>0].min(), 2.0)
+ cg2 = self.hierarchy.covering_grid(3, [0.0]*3, [1.0]*3, [64,64,64])
+ self.assertTrue(na.all(cg["Ones"] == cg2["Ones"]))
+
+ def testRawFlushBack(self):
+ ml = self.hierarchy.max_level
+ cg = self.hierarchy.covering_grid(3, [0.0]*3, [1.0]*3, [64,64,64])
+ cg["DensityNew"] = cg["Density"] * 2.111
+ cg.flush_data(field="DensityNew")
+ for g in na.concatenate([self.hierarchy.select_grids(i) for i in range(3)]):
+ ni = g["DensityNew"] > 0
+ min_diff = (g["DensityNew"][ni]/g["Density"][ni]).max()
+ max_diff = (g["DensityNew"][ni]/g["Density"][ni]).min()
+ min_diff_i = na.argmin(g["DensityNew"][ni]/g["Density"][ni])
+ max_diff_i = na.argmax(g["DensityNew"][ni]/g["Density"][ni])
+ self.assertAlmostEqual(min_diff, 2.111, 5)
+ self.assertAlmostEqual(max_diff, 2.111, 5)
+
+ def testAllCover(self):
+ cg = self.hierarchy.covering_grid(0, [0.0]*3, [1.0]*3, [32,32,32])
+ self.assertTrue(cg["Density"].max() \
+ == self.hierarchy.grids[0]["Density"].max())
+ self.assertTrue(cg["Density"].min() \
+ == self.hierarchy.grids[0]["Density"].min())
+
+class TestDiskDataType(Data3DBase, DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+ def setUp(self):
+ DataTypeTestingBase.setUp(self)
+ self.data=self.hierarchy.disk(
+ [0.5,0.5,0.5],[0.2, 0.1, 0.5],1.0,1.0)
+
+class TestRegionDataType(Data3DBase, DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+ def setUp(self):
+ DataTypeTestingBase.setUp(self)
+ self.data=self.hierarchy.region(
+ [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 TestSphereDataType(Data3DBase, DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+ def setUp(self):
+ DataTypeTestingBase.setUp(self)
+ self.data=self.hierarchy.sphere([0.5,0.5,0.5],2.0)
+ def testVolume(self):
+ vol = self.data["CellVolume"].sum() / self.data.convert("cm")**3.0
+ self.assertAlmostEqual(vol,1.0,7)
+
+class TestSliceDataType(DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+ def setUp(self):
+ DataTypeTestingBase.setUp(self)
+ self.data = self.hierarchy.slice(0,0.5)
+
+class TestCuttingPlane(DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+ def setUp(self):
+ DataTypeTestingBase.setUp(self)
+ self.data = self.hierarchy.cutting([0.1,0.3,0.4], [0.5,0.5,0.5])
+ def testAxisVectors(self):
+ x_v = self.data._x_vec
+ y_v = self.data._y_vec
+ z_v = self.data._norm_vec
+ self.assertAlmostEqual(na.dot(x_v, y_v), 0.0, 7)
+ self.assertAlmostEqual(na.dot(x_v, z_v), 0.0, 7)
+ self.assertAlmostEqual(na.dot(y_v, z_v), 0.0, 7)
+ def testZHeight(self):
+ self.assertTrue(na.all(self.data['pz'] < self.data['dx']))
+
+class TestGridDataType(DataTypeTestingBase, LagosTestingBase, unittest.TestCase):
+ def setUp(self):
+ DataTypeTestingBase.setUp(self)
+ self.data = self.hierarchy.grids[0]
+
+class TestExtractFromSphere(TestSphereDataType):
+ def setUp(self):
+ TestSphereDataType.setUp(self)
+ self.region = self.data
+ self.ind_to_get = na.where(self.region["Temperature"]>500)
+ self.data = self.region.extract_region(self.ind_to_get)
+ def testNumberOfEntries(self):
+ self.assertEqual(self.ind_to_get[0].shape,
+ self.data["Density"].shape)
+ def testVolume(self):
+ self.ind_to_get = na.where(self.region["CellVolume"]>0.0)
+ vol = self.region.extract_region(self.ind_to_get)["CellVolume"].sum() \
+ / self.data.convert("cm")**3.0
+ self.assertAlmostEqual(vol,1.0,7)
+
+class TestExtractFromRegion(TestRegionDataType):
+ def setUp(self):
+ TestRegionDataType.setUp(self)
+ self.region = self.data
+ self.ind_to_get = na.where(self.region["Temperature"]>500)
+ self.data = self.region.extract_region(self.ind_to_get)
+ def testNumberOfEntries(self):
+ self.assertEqual(self.ind_to_get[0].shape,
+ self.data["Density"].shape)
+ def testVolume(self):
+ ind_to_get = na.where(self.region["CellVolume"]>0.0)
+ vol = self.region.extract_region(ind_to_get)["CellVolume"].sum() \
+ / self.data.convert("cm")**3.0
+ self.assertAlmostEqual(vol,1.0,7)
+
+class TestUnilinearInterpolator(unittest.TestCase):
+ def setUp(self):
+ x0, x1 = na.random.uniform(-100,100,2)
+ nstep_x = na.random.randint(10,200)
+ nvals = na.random.randint(100,1000)
+
+ table = na.mgrid[x0:x1:nstep_x*1j]
+
+ self.ufi_x = yt.lagos.UnilinearFieldInterpolator(table,
+ (x0,x1),'x')
+ self.my_dict = {}
+ self.my_dict['x'] = na.random.uniform(x0,x1,nvals)
+
+ def testXInt(self):
+ nv = self.ufi_x(self.my_dict)
+ for i,v in enumerate(nv):
+ self.assertAlmostEqual(v, self.my_dict['x'][i], 5)
+
+class TestBilinearInterpolator(unittest.TestCase):
+ def setUp(self):
+ x0, x1 = na.random.uniform(-100,100,2)
+ y0, y1 = na.random.uniform(-100,100,2)
+ nstep_x = na.random.randint(10,200)
+ nstep_y = na.random.randint(10,200)
+ nvals = na.random.randint(100,1000)
+
+ table = na.mgrid[x0:x1:nstep_x*1j,
+ y0:y1:nstep_y*1j]
+
+ self.bfi_x = yt.lagos.BilinearFieldInterpolator(table[0,...],
+ (x0,x1,y0,y1),['x','y'])
+ self.bfi_y = yt.lagos.BilinearFieldInterpolator(table[1,...],
+ (x0,x1,y0,y1),['x','y'])
+ self.my_dict = {}
+ self.my_dict['x'] = na.random.uniform(x0,x1,nvals)
+ self.my_dict['y'] = na.random.uniform(y0,y1,nvals)
+
+ def testXInt(self):
+ nv = self.bfi_x(self.my_dict)
+ for i,v in enumerate(nv):
+ self.assertAlmostEqual(v, self.my_dict['x'][i], 5)
+
+ def testYInt(self):
+ nv = self.bfi_y(self.my_dict)
+ for i,v in enumerate(nv):
+ self.assertAlmostEqual(v, self.my_dict['y'][i], 5)
+
+class TestTrilinearInterpolator(unittest.TestCase):
+ def setUp(self):
+ x0, x1 = na.random.uniform(-100,100,2)
+ y0, y1 = na.random.uniform(-100,100,2)
+ z0, z1 = na.random.uniform(-100,100,2)
+ nstep_x = na.random.randint(10,200)
+ nstep_y = na.random.randint(10,200)
+ nstep_z = na.random.randint(10,200)
+ nvals = na.random.randint(100,1000)
+
+ table = na.mgrid[x0:x1:nstep_x*1j,
+ y0:y1:nstep_y*1j,
+ z0:z1:nstep_z*1j]
+
+ self.tfi_x = yt.lagos.TrilinearFieldInterpolator(table[0,...],
+ (x0,x1,y0,y1,z0,z1),['x','y','z'])
+ self.tfi_y = yt.lagos.TrilinearFieldInterpolator(table[1,...],
+ (x0,x1,y0,y1,z0,z1),['x','y','z'])
+ self.tfi_z = yt.lagos.TrilinearFieldInterpolator(table[2,...],
+ (x0,x1,y0,y1,z0,z1),['x','y','z'])
+ self.my_dict = {}
+ self.my_dict['x'] = na.random.uniform(x0,x1,nvals)
+ self.my_dict['y'] = na.random.uniform(y0,y1,nvals)
+ self.my_dict['z'] = na.random.uniform(z0,z1,nvals)
+
+ def testXInt(self):
+ nv = self.tfi_x(self.my_dict)
+ for i,v in enumerate(nv):
+ self.assertAlmostEqual(v, self.my_dict['x'][i], 5)
+
+ def testYInt(self):
+ nv = self.tfi_y(self.my_dict)
+ for i,v in enumerate(nv):
+ self.assertAlmostEqual(v, self.my_dict['y'][i], 5)
+
+ def testZInt(self):
+ nv = self.tfi_z(self.my_dict)
+ for i,v in enumerate(nv):
+ self.assertAlmostEqual(v, self.my_dict['z'][i], 5)
+
+
+
+if __name__ == "__main__":
+ unittest.main()
More information about the yt-svn
mailing list